diff --git "a/demo/ort-phi3/dist/esm/ort.webgpu.js" "b/demo/ort-phi3/dist/esm/ort.webgpu.js" new file mode 100644--- /dev/null +++ "b/demo/ort-phi3/dist/esm/ort.webgpu.js" @@ -0,0 +1,19787 @@ +/*! + * ONNX Runtime Web v1.18.0 + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. + */ +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __esm = (fn, res) => function __init() { + return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; +}; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// common/dist/esm/backend-impl.js +var backends, backendsSortedByPriority, registerBackend, tryResolveAndInitializeBackend, resolveBackendAndExecutionProviders; +var init_backend_impl = __esm({ + "common/dist/esm/backend-impl.js"() { + "use strict"; + backends = /* @__PURE__ */ new Map(); + backendsSortedByPriority = []; + registerBackend = (name, backend, priority) => { + if (backend && typeof backend.init === "function" && typeof backend.createInferenceSessionHandler === "function") { + const currentBackend = backends.get(name); + if (currentBackend === void 0) { + backends.set(name, { backend, priority }); + } else if (currentBackend.priority > priority) { + return; + } else if (currentBackend.priority === priority) { + if (currentBackend.backend !== backend) { + throw new Error(`cannot register backend "${name}" using priority ${priority}`); + } + } + if (priority >= 0) { + const i = backendsSortedByPriority.indexOf(name); + if (i !== -1) { + backendsSortedByPriority.splice(i, 1); + } + for (let i2 = 0; i2 < backendsSortedByPriority.length; i2++) { + if (backends.get(backendsSortedByPriority[i2]).priority <= priority) { + backendsSortedByPriority.splice(i2, 0, name); + return; + } + } + backendsSortedByPriority.push(name); + } + return; + } + throw new TypeError("not a valid backend"); + }; + tryResolveAndInitializeBackend = async (backendName) => { + const backendInfo = backends.get(backendName); + if (!backendInfo) { + return "backend not found."; + } + if (backendInfo.initialized) { + return backendInfo.backend; + } else if (backendInfo.aborted) { + return backendInfo.error; + } else { + const isInitializing = !!backendInfo.initPromise; + try { + if (!isInitializing) { + backendInfo.initPromise = backendInfo.backend.init(backendName); + } + await backendInfo.initPromise; + backendInfo.initialized = true; + return backendInfo.backend; + } catch (e) { + if (!isInitializing) { + backendInfo.error = `${e}`; + backendInfo.aborted = true; + } + return backendInfo.error; + } finally { + delete backendInfo.initPromise; + } + } + }; + resolveBackendAndExecutionProviders = async (options) => { + const eps = options.executionProviders || []; + const backendHints = eps.map((i) => typeof i === "string" ? i : i.name); + const backendNames = backendHints.length === 0 ? backendsSortedByPriority : backendHints; + let backend; + const errors = []; + const availableBackendNames = /* @__PURE__ */ new Set(); + for (const backendName of backendNames) { + const resolveResult = await tryResolveAndInitializeBackend(backendName); + if (typeof resolveResult === "string") { + errors.push({ name: backendName, err: resolveResult }); + } else { + if (!backend) { + backend = resolveResult; + } + if (backend === resolveResult) { + availableBackendNames.add(backendName); + } + } + } + if (!backend) { + throw new Error(`no available backend found. ERR: ${errors.map((e) => `[${e.name}] ${e.err}`).join(", ")}`); + } + for (const { name, err } of errors) { + if (backendHints.includes(name)) { + console.warn(`removing requested execution provider "${name}" from session options because it is not available: ${err}`); + } + } + const filteredEps = eps.filter((i) => availableBackendNames.has(typeof i === "string" ? i : i.name)); + return [ + backend, + new Proxy(options, { + get: (target, prop) => { + if (prop === "executionProviders") { + return filteredEps; + } + return Reflect.get(target, prop); + } + }) + ]; + }; + } +}); + +// common/dist/esm/backend.js +var init_backend = __esm({ + "common/dist/esm/backend.js"() { + "use strict"; + init_backend_impl(); + } +}); + +// common/dist/esm/version.js +var version; +var init_version = __esm({ + "common/dist/esm/version.js"() { + "use strict"; + version = "1.18.0"; + } +}); + +// common/dist/esm/env-impl.js +var logLevelValue, env; +var init_env_impl = __esm({ + "common/dist/esm/env-impl.js"() { + "use strict"; + init_version(); + logLevelValue = "warning"; + env = { + wasm: {}, + webgl: {}, + webgpu: {}, + versions: { common: version }, + set logLevel(value) { + if (value === void 0) { + return; + } + if (typeof value !== "string" || ["verbose", "info", "warning", "error", "fatal"].indexOf(value) === -1) { + throw new Error(`Unsupported logging level: ${value}`); + } + logLevelValue = value; + }, + get logLevel() { + return logLevelValue; + } + }; + Object.defineProperty(env, "logLevel", { enumerable: true }); + } +}); + +// common/dist/esm/env.js +var env2; +var init_env = __esm({ + "common/dist/esm/env.js"() { + "use strict"; + init_env_impl(); + env2 = env; + } +}); + +// common/dist/esm/tensor-conversion-impl.js +var tensorToDataURL, tensorToImageData; +var init_tensor_conversion_impl = __esm({ + "common/dist/esm/tensor-conversion-impl.js"() { + "use strict"; + tensorToDataURL = (tensor, options) => { + const canvas = typeof document !== "undefined" ? document.createElement("canvas") : new OffscreenCanvas(1, 1); + canvas.width = tensor.dims[3]; + canvas.height = tensor.dims[2]; + const pixels2DContext = canvas.getContext("2d"); + if (pixels2DContext != null) { + let width; + let height; + if (options?.tensorLayout !== void 0 && options.tensorLayout === "NHWC") { + width = tensor.dims[2]; + height = tensor.dims[3]; + } else { + width = tensor.dims[3]; + height = tensor.dims[2]; + } + const inputformat = options?.format !== void 0 ? options.format : "RGB"; + const norm = options?.norm; + let normMean; + let normBias; + if (norm === void 0 || norm.mean === void 0) { + normMean = [255, 255, 255, 255]; + } else { + if (typeof norm.mean === "number") { + normMean = [norm.mean, norm.mean, norm.mean, norm.mean]; + } else { + normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 0]; + if (norm.mean[3] !== void 0) { + normMean[3] = norm.mean[3]; + } + } + } + if (norm === void 0 || norm.bias === void 0) { + normBias = [0, 0, 0, 0]; + } else { + if (typeof norm.bias === "number") { + normBias = [norm.bias, norm.bias, norm.bias, norm.bias]; + } else { + normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0]; + if (norm.bias[3] !== void 0) { + normBias[3] = norm.bias[3]; + } + } + } + const stride = height * width; + let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1; + if (inputformat === "RGBA") { + rTensorPointer = 0; + gTensorPointer = stride; + bTensorPointer = stride * 2; + aTensorPointer = stride * 3; + } else if (inputformat === "RGB") { + rTensorPointer = 0; + gTensorPointer = stride; + bTensorPointer = stride * 2; + } else if (inputformat === "RBG") { + rTensorPointer = 0; + bTensorPointer = stride; + gTensorPointer = stride * 2; + } + for (let i = 0; i < height; i++) { + for (let j = 0; j < width; j++) { + const R = (tensor.data[rTensorPointer++] - normBias[0]) * normMean[0]; + const G = (tensor.data[gTensorPointer++] - normBias[1]) * normMean[1]; + const B = (tensor.data[bTensorPointer++] - normBias[2]) * normMean[2]; + const A = aTensorPointer === -1 ? 255 : (tensor.data[aTensorPointer++] - normBias[3]) * normMean[3]; + pixels2DContext.fillStyle = "rgba(" + R + "," + G + "," + B + "," + A + ")"; + pixels2DContext.fillRect(j, i, 1, 1); + } + } + if ("toDataURL" in canvas) { + return canvas.toDataURL(); + } else { + throw new Error("toDataURL is not supported"); + } + } else { + throw new Error("Can not access image data"); + } + }; + tensorToImageData = (tensor, options) => { + const pixels2DContext = typeof document !== "undefined" ? document.createElement("canvas").getContext("2d") : new OffscreenCanvas(1, 1).getContext("2d"); + let image; + if (pixels2DContext != null) { + let width; + let height; + let channels; + if (options?.tensorLayout !== void 0 && options.tensorLayout === "NHWC") { + width = tensor.dims[2]; + height = tensor.dims[1]; + channels = tensor.dims[3]; + } else { + width = tensor.dims[3]; + height = tensor.dims[2]; + channels = tensor.dims[1]; + } + const inputformat = options !== void 0 ? options.format !== void 0 ? options.format : "RGB" : "RGB"; + const norm = options?.norm; + let normMean; + let normBias; + if (norm === void 0 || norm.mean === void 0) { + normMean = [255, 255, 255, 255]; + } else { + if (typeof norm.mean === "number") { + normMean = [norm.mean, norm.mean, norm.mean, norm.mean]; + } else { + normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 255]; + if (norm.mean[3] !== void 0) { + normMean[3] = norm.mean[3]; + } + } + } + if (norm === void 0 || norm.bias === void 0) { + normBias = [0, 0, 0, 0]; + } else { + if (typeof norm.bias === "number") { + normBias = [norm.bias, norm.bias, norm.bias, norm.bias]; + } else { + normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0]; + if (norm.bias[3] !== void 0) { + normBias[3] = norm.bias[3]; + } + } + } + const stride = height * width; + if (options !== void 0) { + if (options.format !== void 0 && (channels === 4 && options.format !== "RGBA") || channels === 3 && (options.format !== "RGB" && options.format !== "BGR")) { + throw new Error("Tensor format doesn't match input tensor dims"); + } + } + const step = 4; + let rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3; + let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1; + if (inputformat === "RGBA") { + rTensorPointer = 0; + gTensorPointer = stride; + bTensorPointer = stride * 2; + aTensorPointer = stride * 3; + } else if (inputformat === "RGB") { + rTensorPointer = 0; + gTensorPointer = stride; + bTensorPointer = stride * 2; + } else if (inputformat === "RBG") { + rTensorPointer = 0; + bTensorPointer = stride; + gTensorPointer = stride * 2; + } + image = pixels2DContext.createImageData(width, height); + for (let i = 0; i < height * width; rImagePointer += step, gImagePointer += step, bImagePointer += step, aImagePointer += step, i++) { + image.data[rImagePointer] = (tensor.data[rTensorPointer++] - normBias[0]) * normMean[0]; + image.data[gImagePointer] = (tensor.data[gTensorPointer++] - normBias[1]) * normMean[1]; + image.data[bImagePointer] = (tensor.data[bTensorPointer++] - normBias[2]) * normMean[2]; + image.data[aImagePointer] = aTensorPointer === -1 ? 255 : (tensor.data[aTensorPointer++] - normBias[3]) * normMean[3]; + } + } else { + throw new Error("Can not access image data"); + } + return image; + }; + } +}); + +// common/dist/esm/tensor-factory-impl.js +var bufferToTensor, tensorFromImage, tensorFromTexture, tensorFromGpuBuffer, tensorFromPinnedBuffer; +var init_tensor_factory_impl = __esm({ + "common/dist/esm/tensor-factory-impl.js"() { + "use strict"; + init_tensor_impl(); + bufferToTensor = (buffer, options) => { + if (buffer === void 0) { + throw new Error("Image buffer must be defined"); + } + if (options.height === void 0 || options.width === void 0) { + throw new Error("Image height and width must be defined"); + } + if (options.tensorLayout === "NHWC") { + throw new Error("NHWC Tensor layout is not supported yet"); + } + const { height, width } = options; + const norm = options.norm ?? { mean: 255, bias: 0 }; + let normMean; + let normBias; + if (typeof norm.mean === "number") { + normMean = [norm.mean, norm.mean, norm.mean, norm.mean]; + } else { + normMean = [norm.mean[0], norm.mean[1], norm.mean[2], norm.mean[3] ?? 255]; + } + if (typeof norm.bias === "number") { + normBias = [norm.bias, norm.bias, norm.bias, norm.bias]; + } else { + normBias = [norm.bias[0], norm.bias[1], norm.bias[2], norm.bias[3] ?? 0]; + } + const inputformat = options.format !== void 0 ? options.format : "RGBA"; + const outputformat = options.tensorFormat !== void 0 ? options.tensorFormat !== void 0 ? options.tensorFormat : "RGB" : "RGB"; + const stride = height * width; + const float32Data = outputformat === "RGBA" ? new Float32Array(stride * 4) : new Float32Array(stride * 3); + let step = 4, rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3; + let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1; + if (inputformat === "RGB") { + step = 3; + rImagePointer = 0; + gImagePointer = 1; + bImagePointer = 2; + aImagePointer = -1; + } + if (outputformat === "RGBA") { + aTensorPointer = stride * 3; + } else if (outputformat === "RBG") { + rTensorPointer = 0; + bTensorPointer = stride; + gTensorPointer = stride * 2; + } else if (outputformat === "BGR") { + bTensorPointer = 0; + gTensorPointer = stride; + rTensorPointer = stride * 2; + } + for (let i = 0; i < stride; i++, rImagePointer += step, bImagePointer += step, gImagePointer += step, aImagePointer += step) { + float32Data[rTensorPointer++] = (buffer[rImagePointer] + normBias[0]) / normMean[0]; + float32Data[gTensorPointer++] = (buffer[gImagePointer] + normBias[1]) / normMean[1]; + float32Data[bTensorPointer++] = (buffer[bImagePointer] + normBias[2]) / normMean[2]; + if (aTensorPointer !== -1 && aImagePointer !== -1) { + float32Data[aTensorPointer++] = (buffer[aImagePointer] + normBias[3]) / normMean[3]; + } + } + const outputTensor = outputformat === "RGBA" ? new Tensor("float32", float32Data, [1, 4, height, width]) : new Tensor("float32", float32Data, [1, 3, height, width]); + return outputTensor; + }; + tensorFromImage = async (image, options) => { + const isHTMLImageEle = typeof HTMLImageElement !== "undefined" && image instanceof HTMLImageElement; + const isImageDataEle = typeof ImageData !== "undefined" && image instanceof ImageData; + const isImageBitmap = typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap; + const isString = typeof image === "string"; + let data; + let bufferToTensorOptions = options ?? {}; + const createCanvas = () => { + if (typeof document !== "undefined") { + return document.createElement("canvas"); + } else if (typeof OffscreenCanvas !== "undefined") { + return new OffscreenCanvas(1, 1); + } else { + throw new Error("Canvas is not supported"); + } + }; + const createCanvasContext = (canvas) => { + if (canvas instanceof HTMLCanvasElement) { + return canvas.getContext("2d"); + } else if (canvas instanceof OffscreenCanvas) { + return canvas.getContext("2d"); + } else { + return null; + } + }; + if (isHTMLImageEle) { + const canvas = createCanvas(); + canvas.width = image.width; + canvas.height = image.height; + const pixels2DContext = createCanvasContext(canvas); + if (pixels2DContext != null) { + let height = image.height; + let width = image.width; + if (options !== void 0 && options.resizedHeight !== void 0 && options.resizedWidth !== void 0) { + height = options.resizedHeight; + width = options.resizedWidth; + } + if (options !== void 0) { + bufferToTensorOptions = options; + if (options.tensorFormat !== void 0) { + throw new Error("Image input config format must be RGBA for HTMLImageElement"); + } else { + bufferToTensorOptions.tensorFormat = "RGBA"; + } + bufferToTensorOptions.height = height; + bufferToTensorOptions.width = width; + } else { + bufferToTensorOptions.tensorFormat = "RGBA"; + bufferToTensorOptions.height = height; + bufferToTensorOptions.width = width; + } + pixels2DContext.drawImage(image, 0, 0); + data = pixels2DContext.getImageData(0, 0, width, height).data; + } else { + throw new Error("Can not access image data"); + } + } else if (isImageDataEle) { + let height; + let width; + if (options !== void 0 && options.resizedWidth !== void 0 && options.resizedHeight !== void 0) { + height = options.resizedHeight; + width = options.resizedWidth; + } else { + height = image.height; + width = image.width; + } + if (options !== void 0) { + bufferToTensorOptions = options; + } + bufferToTensorOptions.format = "RGBA"; + bufferToTensorOptions.height = height; + bufferToTensorOptions.width = width; + if (options !== void 0) { + const tempCanvas = createCanvas(); + tempCanvas.width = width; + tempCanvas.height = height; + const pixels2DContext = createCanvasContext(tempCanvas); + if (pixels2DContext != null) { + pixels2DContext.putImageData(image, 0, 0); + data = pixels2DContext.getImageData(0, 0, width, height).data; + } else { + throw new Error("Can not access image data"); + } + } else { + data = image.data; + } + } else if (isImageBitmap) { + if (options === void 0) { + throw new Error("Please provide image config with format for Imagebitmap"); + } + const canvas = createCanvas(); + canvas.width = image.width; + canvas.height = image.height; + const pixels2DContext = createCanvasContext(canvas); + if (pixels2DContext != null) { + const height = image.height; + const width = image.width; + pixels2DContext.drawImage(image, 0, 0, width, height); + data = pixels2DContext.getImageData(0, 0, width, height).data; + bufferToTensorOptions.height = height; + bufferToTensorOptions.width = width; + return bufferToTensor(data, bufferToTensorOptions); + } else { + throw new Error("Can not access image data"); + } + } else if (isString) { + return new Promise((resolve, reject) => { + const canvas = createCanvas(); + const context = createCanvasContext(canvas); + if (!image || !context) { + return reject(); + } + const newImage = new Image(); + newImage.crossOrigin = "Anonymous"; + newImage.src = image; + newImage.onload = () => { + canvas.width = newImage.width; + canvas.height = newImage.height; + context.drawImage(newImage, 0, 0, canvas.width, canvas.height); + const img = context.getImageData(0, 0, canvas.width, canvas.height); + bufferToTensorOptions.height = canvas.height; + bufferToTensorOptions.width = canvas.width; + resolve(bufferToTensor(img.data, bufferToTensorOptions)); + }; + }); + } else { + throw new Error("Input data provided is not supported - aborted tensor creation"); + } + if (data !== void 0) { + return bufferToTensor(data, bufferToTensorOptions); + } else { + throw new Error("Input data provided is not supported - aborted tensor creation"); + } + }; + tensorFromTexture = (texture, options) => { + const { width, height, download, dispose } = options; + const dims = [1, height, width, 4]; + return new Tensor({ location: "texture", type: "float32", texture, dims, download, dispose }); + }; + tensorFromGpuBuffer = (gpuBuffer, options) => { + const { dataType, dims, download, dispose } = options; + return new Tensor({ location: "gpu-buffer", type: dataType ?? "float32", gpuBuffer, dims, download, dispose }); + }; + tensorFromPinnedBuffer = (type, buffer, dims) => new Tensor({ location: "cpu-pinned", type, data: buffer, dims: dims ?? [buffer.length] }); + } +}); + +// common/dist/esm/tensor-impl-type-mapping.js +var NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP, NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP, isTypedArrayChecked, checkTypedArray; +var init_tensor_impl_type_mapping = __esm({ + "common/dist/esm/tensor-impl-type-mapping.js"() { + "use strict"; + NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP = /* @__PURE__ */ new Map([ + ["float32", Float32Array], + ["uint8", Uint8Array], + ["int8", Int8Array], + ["uint16", Uint16Array], + ["int16", Int16Array], + ["int32", Int32Array], + ["bool", Uint8Array], + ["float64", Float64Array], + ["uint32", Uint32Array] + ]); + NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP = /* @__PURE__ */ new Map([ + [Float32Array, "float32"], + [Uint8Array, "uint8"], + [Int8Array, "int8"], + [Uint16Array, "uint16"], + [Int16Array, "int16"], + [Int32Array, "int32"], + [Float64Array, "float64"], + [Uint32Array, "uint32"] + ]); + isTypedArrayChecked = false; + checkTypedArray = () => { + if (!isTypedArrayChecked) { + isTypedArrayChecked = true; + const isBigInt64ArrayAvailable = typeof BigInt64Array !== "undefined" && BigInt64Array.from; + const isBigUint64ArrayAvailable = typeof BigUint64Array !== "undefined" && BigUint64Array.from; + const isFloat16ArrayAvailable = typeof Float16Array !== "undefined" && Float16Array.from; + if (isBigInt64ArrayAvailable) { + NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("int64", BigInt64Array); + NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigInt64Array, "int64"); + } + if (isBigUint64ArrayAvailable) { + NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("uint64", BigUint64Array); + NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigUint64Array, "uint64"); + } + if (isFloat16ArrayAvailable) { + NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("float16", Float16Array); + NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(Float16Array, "float16"); + } else { + NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("float16", Uint16Array); + } + } + }; + } +}); + +// common/dist/esm/tensor-utils-impl.js +var calculateSize, tensorReshape; +var init_tensor_utils_impl = __esm({ + "common/dist/esm/tensor-utils-impl.js"() { + "use strict"; + init_tensor_impl(); + calculateSize = (dims) => { + let size = 1; + for (let i = 0; i < dims.length; i++) { + const dim = dims[i]; + if (typeof dim !== "number" || !Number.isSafeInteger(dim)) { + throw new TypeError(`dims[${i}] must be an integer, got: ${dim}`); + } + if (dim < 0) { + throw new RangeError(`dims[${i}] must be a non-negative integer, got: ${dim}`); + } + size *= dim; + } + return size; + }; + tensorReshape = (tensor, dims) => { + switch (tensor.location) { + case "cpu": + return new Tensor(tensor.type, tensor.data, dims); + case "cpu-pinned": + return new Tensor({ + location: "cpu-pinned", + data: tensor.data, + type: tensor.type, + dims + }); + case "texture": + return new Tensor({ + location: "texture", + texture: tensor.texture, + type: tensor.type, + dims + }); + case "gpu-buffer": + return new Tensor({ + location: "gpu-buffer", + gpuBuffer: tensor.gpuBuffer, + type: tensor.type, + dims + }); + default: + throw new Error(`tensorReshape: tensor location ${tensor.location} is not supported`); + } + }; + } +}); + +// common/dist/esm/tensor-impl.js +var Tensor; +var init_tensor_impl = __esm({ + "common/dist/esm/tensor-impl.js"() { + "use strict"; + init_tensor_conversion_impl(); + init_tensor_factory_impl(); + init_tensor_impl_type_mapping(); + init_tensor_utils_impl(); + Tensor = class { + /** + * implementation. + */ + constructor(arg0, arg1, arg2) { + checkTypedArray(); + let type; + let dims; + if (typeof arg0 === "object" && "location" in arg0) { + this.dataLocation = arg0.location; + type = arg0.type; + dims = arg0.dims; + switch (arg0.location) { + case "cpu-pinned": { + const expectedTypedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(type); + if (!expectedTypedArrayConstructor) { + throw new TypeError(`unsupported type "${type}" to create tensor from pinned buffer`); + } + if (!(arg0.data instanceof expectedTypedArrayConstructor)) { + throw new TypeError(`buffer should be of type ${expectedTypedArrayConstructor.name}`); + } + this.cpuData = arg0.data; + break; + } + case "texture": { + if (type !== "float32") { + throw new TypeError(`unsupported type "${type}" to create tensor from texture`); + } + this.gpuTextureData = arg0.texture; + this.downloader = arg0.download; + this.disposer = arg0.dispose; + break; + } + case "gpu-buffer": { + if (type !== "float32" && type !== "float16" && type !== "int32" && type !== "int64" && type !== "uint32" && type !== "uint8" && type !== "bool") { + throw new TypeError(`unsupported type "${type}" to create tensor from gpu buffer`); + } + this.gpuBufferData = arg0.gpuBuffer; + this.downloader = arg0.download; + this.disposer = arg0.dispose; + break; + } + default: + throw new Error(`Tensor constructor: unsupported location '${this.dataLocation}'`); + } + } else { + let data; + let maybeDims; + if (typeof arg0 === "string") { + type = arg0; + maybeDims = arg2; + if (arg0 === "string") { + if (!Array.isArray(arg1)) { + throw new TypeError("A string tensor's data must be a string array."); + } + data = arg1; + } else { + const typedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(arg0); + if (typedArrayConstructor === void 0) { + throw new TypeError(`Unsupported tensor type: ${arg0}.`); + } + if (Array.isArray(arg1)) { + if (arg0 === "float16" && typedArrayConstructor === Uint16Array) { + throw new TypeError("Creating a float16 tensor from number array is not supported. Please use Uint16Array as data."); + } else if (arg0 === "uint64" || arg0 === "int64") { + data = typedArrayConstructor.from(arg1, BigInt); + } else { + data = typedArrayConstructor.from(arg1); + } + } else if (arg1 instanceof typedArrayConstructor) { + data = arg1; + } else { + throw new TypeError(`A ${type} tensor's data must be type of ${typedArrayConstructor}`); + } + } + } else { + maybeDims = arg1; + if (Array.isArray(arg0)) { + if (arg0.length === 0) { + throw new TypeError("Tensor type cannot be inferred from an empty array."); + } + const firstElementType = typeof arg0[0]; + if (firstElementType === "string") { + type = "string"; + data = arg0; + } else if (firstElementType === "boolean") { + type = "bool"; + data = Uint8Array.from(arg0); + } else { + throw new TypeError(`Invalid element type of data array: ${firstElementType}.`); + } + } else { + const mappedType = NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.get(arg0.constructor); + if (mappedType === void 0) { + throw new TypeError(`Unsupported type for tensor data: ${arg0.constructor}.`); + } + type = mappedType; + data = arg0; + } + } + if (maybeDims === void 0) { + maybeDims = [data.length]; + } else if (!Array.isArray(maybeDims)) { + throw new TypeError("A tensor's dims must be a number array"); + } + dims = maybeDims; + this.cpuData = data; + this.dataLocation = "cpu"; + } + const size = calculateSize(dims); + if (this.cpuData && size !== this.cpuData.length) { + throw new Error(`Tensor's size(${size}) does not match data length(${this.cpuData.length}).`); + } + this.type = type; + this.dims = dims; + this.size = size; + } + // #endregion + // #region factory + static async fromImage(image, options) { + return tensorFromImage(image, options); + } + static fromTexture(texture, options) { + return tensorFromTexture(texture, options); + } + static fromGpuBuffer(gpuBuffer, options) { + return tensorFromGpuBuffer(gpuBuffer, options); + } + static fromPinnedBuffer(type, buffer, dims) { + return tensorFromPinnedBuffer(type, buffer, dims); + } + // #endregion + // #region conversions + toDataURL(options) { + return tensorToDataURL(this, options); + } + toImageData(options) { + return tensorToImageData(this, options); + } + // #endregion + // #region properties + get data() { + this.ensureValid(); + if (!this.cpuData) { + throw new Error("The data is not on CPU. Use `getData()` to download GPU data to CPU, or use `texture` or `gpuBuffer` property to access the GPU data directly."); + } + return this.cpuData; + } + get location() { + return this.dataLocation; + } + get texture() { + this.ensureValid(); + if (!this.gpuTextureData) { + throw new Error("The data is not stored as a WebGL texture."); + } + return this.gpuTextureData; + } + get gpuBuffer() { + this.ensureValid(); + if (!this.gpuBufferData) { + throw new Error("The data is not stored as a WebGPU buffer."); + } + return this.gpuBufferData; + } + // #endregion + // #region methods + async getData(releaseData) { + this.ensureValid(); + switch (this.dataLocation) { + case "cpu": + case "cpu-pinned": + return this.data; + case "texture": + case "gpu-buffer": { + if (!this.downloader) { + throw new Error("The current tensor is not created with a specified data downloader."); + } + if (this.isDownloading) { + throw new Error("The current tensor is being downloaded."); + } + try { + this.isDownloading = true; + const data = await this.downloader(); + this.downloader = void 0; + this.dataLocation = "cpu"; + this.cpuData = data; + if (releaseData && this.disposer) { + this.disposer(); + this.disposer = void 0; + } + return data; + } finally { + this.isDownloading = false; + } + } + default: + throw new Error(`cannot get data from location: ${this.dataLocation}`); + } + } + dispose() { + if (this.isDownloading) { + throw new Error("The current tensor is being downloaded."); + } + if (this.disposer) { + this.disposer(); + this.disposer = void 0; + } + this.cpuData = void 0; + this.gpuTextureData = void 0; + this.gpuBufferData = void 0; + this.downloader = void 0; + this.isDownloading = void 0; + this.dataLocation = "none"; + } + // #endregion + // #region tensor utilities + ensureValid() { + if (this.dataLocation === "none") { + throw new Error("The tensor is disposed."); + } + } + reshape(dims) { + this.ensureValid(); + if (this.downloader || this.disposer) { + throw new Error("Cannot reshape a tensor that owns GPU resource."); + } + return tensorReshape(this, dims); + } + }; + } +}); + +// common/dist/esm/tensor.js +var Tensor2; +var init_tensor = __esm({ + "common/dist/esm/tensor.js"() { + "use strict"; + init_tensor_impl(); + Tensor2 = Tensor; + } +}); + +// common/dist/esm/trace.js +var TRACE, TRACE_FUNC, TRACE_FUNC_BEGIN, TRACE_FUNC_END; +var init_trace = __esm({ + "common/dist/esm/trace.js"() { + "use strict"; + init_env_impl(); + TRACE = (deviceType, label) => { + if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) { + return; + } + console.timeStamp(`${deviceType}::ORT::${label}`); + }; + TRACE_FUNC = (msg, extraMsg) => { + const stack = new Error().stack?.split(/\r\n|\r|\n/g) || []; + let hasTraceFunc = false; + for (let i = 0; i < stack.length; i++) { + if (hasTraceFunc && !stack[i].includes("TRACE_FUNC")) { + let label = `FUNC_${msg}::${stack[i].trim().split(" ")[1]}`; + if (extraMsg) { + label += `::${extraMsg}`; + } + TRACE("CPU", label); + return; + } + if (stack[i].includes("TRACE_FUNC")) { + hasTraceFunc = true; + } + } + }; + TRACE_FUNC_BEGIN = (extraMsg) => { + if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) { + return; + } + TRACE_FUNC("BEGIN", extraMsg); + }; + TRACE_FUNC_END = (extraMsg) => { + if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) { + return; + } + TRACE_FUNC("END", extraMsg); + }; + } +}); + +// common/dist/esm/inference-session-impl.js +var InferenceSession; +var init_inference_session_impl = __esm({ + "common/dist/esm/inference-session-impl.js"() { + "use strict"; + init_backend_impl(); + init_tensor(); + init_trace(); + InferenceSession = class _InferenceSession { + constructor(handler) { + this.handler = handler; + } + async run(feeds, arg1, arg2) { + TRACE_FUNC_BEGIN(); + const fetches = {}; + let options = {}; + if (typeof feeds !== "object" || feeds === null || feeds instanceof Tensor2 || Array.isArray(feeds)) { + throw new TypeError("'feeds' must be an object that use input names as keys and OnnxValue as corresponding values."); + } + let isFetchesEmpty = true; + if (typeof arg1 === "object") { + if (arg1 === null) { + throw new TypeError("Unexpected argument[1]: cannot be null."); + } + if (arg1 instanceof Tensor2) { + throw new TypeError("'fetches' cannot be a Tensor"); + } + if (Array.isArray(arg1)) { + if (arg1.length === 0) { + throw new TypeError("'fetches' cannot be an empty array."); + } + isFetchesEmpty = false; + for (const name of arg1) { + if (typeof name !== "string") { + throw new TypeError("'fetches' must be a string array or an object."); + } + if (this.outputNames.indexOf(name) === -1) { + throw new RangeError(`'fetches' contains invalid output name: ${name}.`); + } + fetches[name] = null; + } + if (typeof arg2 === "object" && arg2 !== null) { + options = arg2; + } else if (typeof arg2 !== "undefined") { + throw new TypeError("'options' must be an object."); + } + } else { + let isFetches = false; + const arg1Keys = Object.getOwnPropertyNames(arg1); + for (const name of this.outputNames) { + if (arg1Keys.indexOf(name) !== -1) { + const v = arg1[name]; + if (v === null || v instanceof Tensor2) { + isFetches = true; + isFetchesEmpty = false; + fetches[name] = v; + } + } + } + if (isFetches) { + if (typeof arg2 === "object" && arg2 !== null) { + options = arg2; + } else if (typeof arg2 !== "undefined") { + throw new TypeError("'options' must be an object."); + } + } else { + options = arg1; + } + } + } else if (typeof arg1 !== "undefined") { + throw new TypeError("Unexpected argument[1]: must be 'fetches' or 'options'."); + } + for (const name of this.inputNames) { + if (typeof feeds[name] === "undefined") { + throw new Error(`input '${name}' is missing in 'feeds'.`); + } + } + if (isFetchesEmpty) { + for (const name of this.outputNames) { + fetches[name] = null; + } + } + const results = await this.handler.run(feeds, fetches, options); + const returnValue = {}; + for (const key in results) { + if (Object.hasOwnProperty.call(results, key)) { + const result = results[key]; + if (result instanceof Tensor2) { + returnValue[key] = result; + } else { + returnValue[key] = new Tensor2(result.type, result.data, result.dims); + } + } + } + TRACE_FUNC_END(); + return returnValue; + } + async release() { + return this.handler.dispose(); + } + static async create(arg0, arg1, arg2, arg3) { + TRACE_FUNC_BEGIN(); + let filePathOrUint8Array; + let options = {}; + if (typeof arg0 === "string") { + filePathOrUint8Array = arg0; + if (typeof arg1 === "object" && arg1 !== null) { + options = arg1; + } else if (typeof arg1 !== "undefined") { + throw new TypeError("'options' must be an object."); + } + } else if (arg0 instanceof Uint8Array) { + filePathOrUint8Array = arg0; + if (typeof arg1 === "object" && arg1 !== null) { + options = arg1; + } else if (typeof arg1 !== "undefined") { + throw new TypeError("'options' must be an object."); + } + } else if (arg0 instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && arg0 instanceof SharedArrayBuffer) { + const buffer = arg0; + let byteOffset = 0; + let byteLength = arg0.byteLength; + if (typeof arg1 === "object" && arg1 !== null) { + options = arg1; + } else if (typeof arg1 === "number") { + byteOffset = arg1; + if (!Number.isSafeInteger(byteOffset)) { + throw new RangeError("'byteOffset' must be an integer."); + } + if (byteOffset < 0 || byteOffset >= buffer.byteLength) { + throw new RangeError(`'byteOffset' is out of range [0, ${buffer.byteLength}).`); + } + byteLength = arg0.byteLength - byteOffset; + if (typeof arg2 === "number") { + byteLength = arg2; + if (!Number.isSafeInteger(byteLength)) { + throw new RangeError("'byteLength' must be an integer."); + } + if (byteLength <= 0 || byteOffset + byteLength > buffer.byteLength) { + throw new RangeError(`'byteLength' is out of range (0, ${buffer.byteLength - byteOffset}].`); + } + if (typeof arg3 === "object" && arg3 !== null) { + options = arg3; + } else if (typeof arg3 !== "undefined") { + throw new TypeError("'options' must be an object."); + } + } else if (typeof arg2 !== "undefined") { + throw new TypeError("'byteLength' must be a number."); + } + } else if (typeof arg1 !== "undefined") { + throw new TypeError("'options' must be an object."); + } + filePathOrUint8Array = new Uint8Array(buffer, byteOffset, byteLength); + } else { + throw new TypeError("Unexpected argument[0]: must be 'path' or 'buffer'."); + } + const [backend, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options); + const handler = await backend.createInferenceSessionHandler(filePathOrUint8Array, optionsWithValidatedEPs); + TRACE_FUNC_END(); + return new _InferenceSession(handler); + } + startProfiling() { + this.handler.startProfiling(); + } + endProfiling() { + this.handler.endProfiling(); + } + get inputNames() { + return this.handler.inputNames; + } + get outputNames() { + return this.handler.outputNames; + } + }; + } +}); + +// common/dist/esm/inference-session.js +var InferenceSession2; +var init_inference_session = __esm({ + "common/dist/esm/inference-session.js"() { + "use strict"; + init_inference_session_impl(); + InferenceSession2 = InferenceSession; + } +}); + +// common/dist/esm/tensor-conversion.js +var init_tensor_conversion = __esm({ + "common/dist/esm/tensor-conversion.js"() { + "use strict"; + } +}); + +// common/dist/esm/tensor-factory.js +var init_tensor_factory = __esm({ + "common/dist/esm/tensor-factory.js"() { + "use strict"; + } +}); + +// common/dist/esm/onnx-model.js +var init_onnx_model = __esm({ + "common/dist/esm/onnx-model.js"() { + "use strict"; + } +}); + +// common/dist/esm/onnx-value.js +var init_onnx_value = __esm({ + "common/dist/esm/onnx-value.js"() { + "use strict"; + } +}); + +// common/dist/esm/training-session-impl.js +var noBackendErrMsg, TrainingSession; +var init_training_session_impl = __esm({ + "common/dist/esm/training-session-impl.js"() { + "use strict"; + init_backend_impl(); + init_tensor(); + noBackendErrMsg = "Training backend could not be resolved. Make sure you're using the correct configuration & WebAssembly files."; + TrainingSession = class _TrainingSession { + constructor(handler, hasOptimizerModel, hasEvalModel) { + this.handler = handler; + this.hasOptimizerModel = hasOptimizerModel; + this.hasEvalModel = hasEvalModel; + } + get trainingInputNames() { + return this.handler.inputNames; + } + get trainingOutputNames() { + return this.handler.outputNames; + } + get evalInputNames() { + if (this.hasEvalModel) { + return this.handler.evalInputNames; + } else { + throw new Error("This training session has no evalModel loaded."); + } + } + get evalOutputNames() { + if (this.hasEvalModel) { + return this.handler.evalOutputNames; + } else { + throw new Error("This training session has no evalModel loaded."); + } + } + static async create(trainingOptions, sessionOptions) { + const evalModel = trainingOptions.evalModel || ""; + const optimizerModel = trainingOptions.optimizerModel || ""; + const options = sessionOptions || {}; + const [backend, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options); + if (backend.createTrainingSessionHandler) { + const handler = await backend.createTrainingSessionHandler(trainingOptions.checkpointState, trainingOptions.trainModel, evalModel, optimizerModel, optionsWithValidatedEPs); + return new _TrainingSession(handler, !!trainingOptions.optimizerModel, !!trainingOptions.evalModel); + } else { + throw new Error(noBackendErrMsg); + } + } + /** + * Helper function for runTrainStep and future runStep methods that handles the type-narrowing conversion from + * the given parameters to SessionHandler.FetchesType and RunOptions. + * + * @param inputNames the feeds object is checked that they contain all input names in the provided list of input + * names. + * @param outputNames the fetches object is checked that their keys match up with valid names in the list of output + * names. + * @param feeds the required input + * @param arg1 narrowed & converted into the SessionHandler.FetchesType or RunOptions object + * @param arg2 optional RunOptions object. + * @returns + */ + typeNarrowingForRunStep(inputNames, outputNames, feeds, arg1, arg2) { + const fetches = {}; + let options = {}; + if (typeof feeds !== "object" || feeds === null || feeds instanceof Tensor2 || Array.isArray(feeds)) { + throw new TypeError("'feeds' must be an object that use input names as keys and OnnxValue as corresponding values."); + } + let isFetchesEmpty = true; + if (typeof arg1 === "object") { + if (arg1 === null) { + throw new TypeError("Unexpected argument[1]: cannot be null."); + } + if (arg1 instanceof Tensor2) { + throw new TypeError("'fetches' cannot be a Tensor"); + } + if (Array.isArray(arg1)) { + if (arg1.length === 0) { + throw new TypeError("'fetches' cannot be an empty array."); + } + isFetchesEmpty = false; + for (const name of arg1) { + if (typeof name !== "string") { + throw new TypeError("'fetches' must be a string array or an object."); + } + if (outputNames.indexOf(name) === -1) { + throw new RangeError(`'fetches' contains invalid output name: ${name}.`); + } + fetches[name] = null; + } + if (typeof arg2 === "object" && arg2 !== null) { + options = arg2; + } else if (typeof arg2 !== "undefined") { + throw new TypeError("'options' must be an object."); + } + } else { + let isFetches = false; + const arg1Keys = Object.getOwnPropertyNames(arg1); + for (const name of outputNames) { + if (arg1Keys.indexOf(name) !== -1) { + const v = arg1[name]; + if (v === null || v instanceof Tensor2) { + isFetches = true; + isFetchesEmpty = false; + fetches[name] = v; + } + } + } + if (isFetches) { + if (typeof arg2 === "object" && arg2 !== null) { + options = arg2; + } else if (typeof arg2 !== "undefined") { + throw new TypeError("'options' must be an object."); + } + } else { + options = arg1; + } + } + } else if (typeof arg1 !== "undefined") { + throw new TypeError("Unexpected argument[1]: must be 'fetches' or 'options'."); + } + for (const name of inputNames) { + if (typeof feeds[name] === "undefined") { + throw new Error(`input '${name}' is missing in 'feeds'.`); + } + } + if (isFetchesEmpty) { + for (const name of outputNames) { + fetches[name] = null; + } + } + return [fetches, options]; + } + /** + * Helper method for runTrainStep and any other runStep methods. Takes the ReturnType result from the SessionHandler + * and changes it into a map of Tensors. + * + * @param results + * @returns + */ + convertHandlerReturnTypeToMapOfTensors(results) { + const returnValue = {}; + for (const key in results) { + if (Object.hasOwnProperty.call(results, key)) { + const result = results[key]; + if (result instanceof Tensor2) { + returnValue[key] = result; + } else { + returnValue[key] = new Tensor2(result.type, result.data, result.dims); + } + } + } + return returnValue; + } + async lazyResetGrad() { + await this.handler.lazyResetGrad(); + } + async runTrainStep(feeds, arg1, arg2) { + const [fetches, options] = this.typeNarrowingForRunStep(this.trainingInputNames, this.trainingOutputNames, feeds, arg1, arg2); + const results = await this.handler.runTrainStep(feeds, fetches, options); + return this.convertHandlerReturnTypeToMapOfTensors(results); + } + async runOptimizerStep(options) { + if (this.hasOptimizerModel) { + await this.handler.runOptimizerStep(options || {}); + } else { + throw new Error("This TrainingSession has no OptimizerModel loaded."); + } + } + async runEvalStep(feeds, arg1, arg2) { + if (this.hasEvalModel) { + const [fetches, options] = this.typeNarrowingForRunStep(this.evalInputNames, this.evalOutputNames, feeds, arg1, arg2); + const results = await this.handler.runEvalStep(feeds, fetches, options); + return this.convertHandlerReturnTypeToMapOfTensors(results); + } else { + throw new Error("This TrainingSession has no EvalModel loaded."); + } + } + async getParametersSize(trainableOnly = true) { + return this.handler.getParametersSize(trainableOnly); + } + async loadParametersBuffer(array, trainableOnly = true) { + const paramsSize = await this.getParametersSize(trainableOnly); + if (array.length !== 4 * paramsSize) { + throw new Error("Size of the buffer passed into loadParametersBuffer must match the number of parameters in the model. Please use getParametersSize method to check."); + } + return this.handler.loadParametersBuffer(array, trainableOnly); + } + async getContiguousParameters(trainableOnly = true) { + return this.handler.getContiguousParameters(trainableOnly); + } + async release() { + return this.handler.dispose(); + } + }; + } +}); + +// common/dist/esm/training-session.js +var TrainingSession2; +var init_training_session = __esm({ + "common/dist/esm/training-session.js"() { + "use strict"; + init_training_session_impl(); + TrainingSession2 = TrainingSession; + } +}); + +// common/dist/esm/index.js +var esm_exports = {}; +__export(esm_exports, { + InferenceSession: () => InferenceSession2, + TRACE: () => TRACE, + TRACE_FUNC_BEGIN: () => TRACE_FUNC_BEGIN, + TRACE_FUNC_END: () => TRACE_FUNC_END, + Tensor: () => Tensor2, + TrainingSession: () => TrainingSession2, + env: () => env2, + registerBackend: () => registerBackend +}); +var init_esm = __esm({ + "common/dist/esm/index.js"() { + "use strict"; + init_backend(); + init_env(); + init_inference_session(); + init_tensor(); + init_tensor_conversion(); + init_tensor_factory(); + init_trace(); + init_onnx_model(); + init_onnx_value(); + init_training_session(); + } +}); + +// nodejs-ignore:node:os +var cpus; +var init_node_os = __esm({ + "nodejs-ignore:node:os"() { + cpus = void 0; + } +}); + +// nodejs-ignore:node:path +var join; +var init_node_path = __esm({ + "nodejs-ignore:node:path"() { + join = void 0; + } +}); + +// nodejs-ignore:fs +var fs_exports = {}; +__export(fs_exports, { + createReadStream: () => createReadStream, + readFile: () => readFile, + readFileSync: () => readFileSync +}); +var readFile, readFileSync, createReadStream; +var init_fs = __esm({ + "nodejs-ignore:fs"() { + readFile = void 0; + readFileSync = void 0; + createReadStream = void 0; + } +}); + +// nodejs-ignore:path +var path_exports = {}; +__export(path_exports, { + join: () => join2 +}); +var join2; +var init_path = __esm({ + "nodejs-ignore:path"() { + join2 = void 0; + } +}); + +// web/lib/wasm/binding/ort-wasm-simd.jsep.js +var require_ort_wasm_simd_jsep = __commonJS({ + "web/lib/wasm/binding/ort-wasm-simd.jsep.js"(exports, module) { + "use strict"; + var ortWasm = (() => { + var _scriptDir = typeof document != "undefined" ? document.currentScript?.src : void 0; + if (typeof __filename != "undefined") + _scriptDir ||= __filename; + return function(moduleArg = {}) { + var g = moduleArg, aa, ba, readyPromise = new Promise((a, b) => { + aa = a; + ba = b; + }); + "use strict"; + g.mountExternalData = (a, b) => { + (g.Ph || (g.Ph = /* @__PURE__ */ new Map())).set(a, b); + }; + g.unmountExternalData = () => { + delete g.Ph; + }; + let da = () => { + const a = (c, d, e) => (...f) => { + const h = t, k = d?.(); + f = c(...f); + const l = d?.(); + k !== l && (c = l, e(k), d = e = null); + return t != h ? ca() : f; + }, b = (c) => async (...d) => { + try { + if (g.Oh) + throw Error("Session already started"); + const e = g.Oh = { gi: d[0], errors: [] }, f = await c(...d); + if (g.Oh !== e) + throw Error("Session mismatch"); + g.Uh?.flush(); + const h = e.errors; + if (0 < h.length) { + let k = await Promise.all(h); + k = k.filter((l) => l); + if (0 < k.length) + throw Error(k.join("\n")); + } + return f; + } finally { + g.Oh = null; + } + }; + g._OrtCreateSession = a( + g._OrtCreateSession, + () => g._OrtCreateSession, + (c) => g._OrtCreateSession = c + ); + g._OrtRun = b(a(g._OrtRun, () => g._OrtRun, (c) => g._OrtRun = c)); + g._OrtRunWithBinding = b(a(g._OrtRunWithBinding, () => g._OrtRunWithBinding, (c) => g._OrtRunWithBinding = c)); + g._OrtBindInput = a(g._OrtBindInput, () => g._OrtBindInput, (c) => g._OrtBindInput = c); + da = void 0; + }; + g.jsepInit = (a, b) => { + da?.(); + if ("webgpu" === a) { + [g.Uh, g.Zh, g.ci, g.Vh, g.bi, g.je, g.di, g.fi, g.$h, g.ai, g.ei] = b; + const c = g.Uh; + g.jsepRegisterBuffer = (d, e, f, h) => c.registerBuffer(d, e, f, h); + g.jsepGetBuffer = (d) => c.getBuffer(d); + g.jsepCreateDownloader = (d, e, f) => c.createDownloader(d, e, f); + g.jsepOnReleaseSession = (d) => { + c.onReleaseSession(d); + }; + g.jsepOnRunStart = (d) => c.onRunStart(d); + } + }; + var ea = Object.assign({}, g), fa = "./this.program", ha = (a, b) => { + throw b; + }, ia = "object" == typeof window, ja = "function" == typeof importScripts, ka = "object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node, v = "", la, ma, na; + if (ka) { + var fs = (init_fs(), __toCommonJS(fs_exports)), oa = (init_path(), __toCommonJS(path_exports)); + v = ja ? oa.dirname(v) + "/" : __dirname + "/"; + la = (a, b) => { + a = pa(a) ? new URL(a) : oa.normalize(a); + return fs.readFileSync(a, b ? void 0 : "utf8"); + }; + na = (a) => { + a = la(a, true); + a.buffer || (a = new Uint8Array(a)); + return a; + }; + ma = (a, b, c, d = true) => { + a = pa(a) ? new URL(a) : oa.normalize(a); + fs.readFile(a, d ? void 0 : "utf8", (e, f) => { + e ? c(e) : b(d ? f.buffer : f); + }); + }; + !g.thisProgram && 1 < process.argv.length && (fa = process.argv[1].replace(/\\/g, "/")); + process.argv.slice(2); + ha = (a, b) => { + process.exitCode = a; + throw b; + }; + } else if (ia || ja) + ja ? v = self.location.href : "undefined" != typeof document && document.currentScript && (v = document.currentScript.src), _scriptDir && (v = _scriptDir), v.startsWith("blob:") ? v = "" : v = v.substr(0, v.replace(/[?#].*/, "").lastIndexOf("/") + 1), la = (a) => { + var b = new XMLHttpRequest(); + b.open("GET", a, false); + b.send(null); + return b.responseText; + }, ja && (na = (a) => { + var b = new XMLHttpRequest(); + b.open("GET", a, false); + b.responseType = "arraybuffer"; + b.send(null); + return new Uint8Array(b.response); + }), ma = (a, b, c) => { + var d = new XMLHttpRequest(); + d.open("GET", a, true); + d.responseType = "arraybuffer"; + d.onload = () => { + 200 == d.status || 0 == d.status && d.response ? b(d.response) : c(); + }; + d.onerror = c; + d.send(null); + }; + var qa = console.log.bind(console), w = console.error.bind(console); + Object.assign(g, ea); + ea = null; + var ra, x = false, sa, z, E, ta, ua, G, I, va, wa, xa, ya; + function za() { + var a = ra.buffer; + g.HEAP8 = z = new Int8Array(a); + g.HEAP16 = ta = new Int16Array(a); + g.HEAPU8 = E = new Uint8Array(a); + g.HEAPU16 = ua = new Uint16Array(a); + g.HEAP32 = G = new Int32Array(a); + g.HEAPU32 = I = new Uint32Array(a); + g.HEAPF32 = va = new Float32Array(a); + g.HEAPF64 = ya = new Float64Array(a); + g.HEAP64 = wa = new BigInt64Array(a); + g.HEAPU64 = xa = new BigUint64Array(a); + } + var Aa = [], Ba = [], Ca = [], Da = 0, Ea = null, Fa = null; + function Ga(a) { + a = "Aborted(" + a + ")"; + w(a); + x = true; + sa = 1; + a = new WebAssembly.RuntimeError(a + ". Build with -sASSERTIONS for more info."); + ba(a); + throw a; + } + var Ha = (a) => a.startsWith("data:application/octet-stream;base64,"), pa = (a) => a.startsWith("file://"), Ia; + Ia = "ort-wasm-simd.wasm"; + if (!Ha(Ia)) { + var Ja = Ia; + Ia = g.locateFile ? g.locateFile(Ja, v) : v + Ja; + } + function Ka(a) { + if (na) + return na(a); + throw "both async and sync fetching of the wasm failed"; + } + function La(a) { + if (ia || ja) { + if ("function" == typeof fetch && !pa(a)) + return fetch(a, { credentials: "same-origin" }).then((b) => { + if (!b.ok) + throw `failed to load wasm binary file at '${a}'`; + return b.arrayBuffer(); + }).catch(() => Ka(a)); + if (ma) + return new Promise((b, c) => { + ma(a, (d) => b(new Uint8Array(d)), c); + }); + } + return Promise.resolve().then(() => Ka(a)); + } + function Ma(a, b, c) { + return La(a).then((d) => WebAssembly.instantiate(d, b)).then(c, (d) => { + w(`failed to asynchronously prepare wasm: ${d}`); + Ga(d); + }); + } + function Na(a, b) { + var c = Ia; + return "function" != typeof WebAssembly.instantiateStreaming || Ha(c) || pa(c) || ka || "function" != typeof fetch ? Ma(c, a, b) : fetch(c, { credentials: "same-origin" }).then((d) => WebAssembly.instantiateStreaming(d, a).then(b, function(e) { + w(`wasm streaming compile failed: ${e}`); + w("falling back to ArrayBuffer instantiation"); + return Ma(c, a, b); + })); + } + var Oa = { + 1261504: (a, b, c, d) => { + if ("undefined" == typeof g || !g.Ph) + return 1; + a = J(a >>> 0); + a.startsWith("./") && (a = a.substring(2)); + a = g.Ph.get(a); + if (!a) + return 2; + b >>>= 0; + c >>>= 0; + if (b + c > a.byteLength) + return 3; + try { + return E.set(a.subarray(b, b + c), d >>> 0 >>> 0), 0; + } catch { + return 4; + } + }, + 1262005: (a, b, c) => { + c = J(c); + const d = new Uint8Array(b); + d.set(E.subarray(a >>> 0, a + b >>> 0)); + "object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node ? (init_fs(), __toCommonJS(fs_exports)).writeFileSync(c, d) : (a = new File([d], c, { type: "application/octet-stream" }), a = URL.createObjectURL(a), window.open(a, "_blank")); + }, + 1262513: () => { + g.$h(); + }, + 1262544: () => { + g.ai(); + }, + 1262573: () => { + g.ei(); + }, + 1262598: (a) => g.Zh(a), + 1262631: (a) => g.ci(a), + 1262663: (a, b, c) => { + g.Vh(a, b, c, true); + }, + 1262702: (a, b, c) => { + g.Vh(a, b, c); + }, + 1262735: (a) => { + g.je("Abs", a, void 0); + }, + 1262786: (a) => { + g.je("Neg", a, void 0); + }, + 1262837: (a) => { + g.je("Floor", a, void 0); + }, + 1262890: (a) => { + g.je("Ceil", a, void 0); + }, + 1262942: (a) => { + g.je("Reciprocal", a, void 0); + }, + 1263e3: (a) => { + g.je("Sqrt", a, void 0); + }, + 1263052: (a) => { + g.je("Exp", a, void 0); + }, + 1263103: (a) => { + g.je("Erf", a, void 0); + }, + 1263154: (a) => { + g.je("Sigmoid", a, void 0); + }, + 1263209: (a, b, c) => { + g.je("HardSigmoid", a, { alpha: b, beta: c }); + }, + 1263288: (a) => { + g.je("Log", a, void 0); + }, + 1263339: (a) => { + g.je("Sin", a, void 0); + }, + 1263390: (a) => { + g.je("Cos", a, void 0); + }, + 1263441: (a) => { + g.je("Tan", a, void 0); + }, + 1263492: (a) => { + g.je("Asin", a, void 0); + }, + 1263544: (a) => { + g.je("Acos", a, void 0); + }, + 1263596: (a) => { + g.je("Atan", a, void 0); + }, + 1263648: (a) => { + g.je("Sinh", a, void 0); + }, + 1263700: (a) => { + g.je("Cosh", a, void 0); + }, + 1263752: (a) => { + g.je("Asinh", a, void 0); + }, + 1263805: (a) => { + g.je("Acosh", a, void 0); + }, + 1263858: (a) => { + g.je("Atanh", a, void 0); + }, + 1263911: (a) => { + g.je("Tanh", a, void 0); + }, + 1263963: (a) => { + g.je("Not", a, void 0); + }, + 1264014: (a, b, c) => { + g.je("Clip", a, { min: b, max: c }); + }, + 1264083: (a) => { + g.je("Clip", a, void 0); + }, + 1264135: (a, b) => { + g.je("Elu", a, { alpha: b }); + }, + 1264193: (a) => { + g.je("Relu", a, void 0); + }, + 1264245: (a, b) => { + g.je("LeakyRelu", a, { alpha: b }); + }, + 1264309: (a, b) => { + g.je("ThresholdedRelu", a, { alpha: b }); + }, + 1264379: (a, b) => { + g.je("Cast", a, { to: b }); + }, + 1264437: (a) => { + g.je("Add", a, void 0); + }, + 1264488: (a) => { + g.je("Sub", a, void 0); + }, + 1264539: (a) => { + g.je("Mul", a, void 0); + }, + 1264590: (a) => { + g.je("Div", a, void 0); + }, + 1264641: (a) => { + g.je("Pow", a, void 0); + }, + 1264692: (a) => { + g.je("Equal", a, void 0); + }, + 1264745: (a) => { + g.je("Greater", a, void 0); + }, + 1264800: (a) => { + g.je("GreaterOrEqual", a, void 0); + }, + 1264862: (a) => { + g.je("Less", a, void 0); + }, + 1264914: (a) => { + g.je("LessOrEqual", a, void 0); + }, + 1264973: (a, b, c, d, e) => { + g.je("ReduceMean", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] }); + }, + 1265132: (a, b, c, d, e) => { + g.je("ReduceMax", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] }); + }, + 1265290: (a, b, c, d, e) => { + g.je("ReduceMin", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] }); + }, + 1265448: (a, b, c, d, e) => { + g.je("ReduceProd", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] }); + }, + 1265607: (a, b, c, d, e) => { + g.je("ReduceSum", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] }); + }, + 1265765: (a, b, c, d, e) => { + g.je("ReduceL1", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] }); + }, + 1265922: (a, b, c, d, e) => { + g.je("ReduceL2", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] }); + }, + 1266079: (a, b, c, d, e) => { + g.je("ReduceLogSum", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] }); + }, + 1266240: (a, b, c, d, e) => { + g.je("ReduceSumSquare", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] }); + }, + 1266404: (a, b, c, d, e) => { + g.je("ReduceLogSumExp", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] }); + }, + 1266568: (a) => { + g.je("Where", a, void 0); + }, + 1266621: (a, b, c) => { + g.je("Transpose", a, { perm: b ? Array.from(G.subarray(b >>> 0, c >>> 0)) : [] }); + }, + 1266729: (a, b, c, d) => { + g.je("DepthToSpace", a, { blocksize: b, mode: J(c), format: d ? "NHWC" : "NCHW" }); + }, + 1266862: (a, b, c, d) => { + g.je("DepthToSpace", a, { blocksize: b, mode: J(c), format: d ? "NHWC" : "NCHW" }); + }, + 1266995: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => { + g.je("ConvTranspose", a, { format: l ? "NHWC" : "NCHW", autoPad: b, dilations: [c], group: d, kernelShape: [e], pads: [f, h], strides: [k], wIsConst: () => !!z[m >>> 0], outputPadding: n ? Array.from(G.subarray(n >>> 0, q >>> 0)) : [], outputShape: r ? Array.from(G.subarray(r >>> 0, p >>> 0)) : [], activation: J(u) }); + }, + 1267396: (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => { + g.je("ConvTranspose", a, { format: k ? "NHWC" : "NCHW", autoPad: b, dilations: Array.from(G.subarray(c >>> 0, (c >>> 0) + 2 >>> 0)), group: d, kernelShape: Array.from(G.subarray(e >>> 0, (e >>> 0) + 2 >>> 0)), pads: Array.from(G.subarray(f >>> 0, (f >>> 0) + 4 >>> 0)), strides: Array.from(G.subarray(h >>> 0, (h >>> 0) + 2 >>> 0)), wIsConst: () => !!z[l >>> 0], outputPadding: m ? Array.from(G.subarray(m >>> 0, n >>> 0)) : [], outputShape: q ? Array.from(G.subarray(q >>> 0, r >>> 0)) : [], activation: J(p) }); + }, + 1267961: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => { + g.je("ConvTranspose", a, { format: l ? "NHWC" : "NCHW", autoPad: b, dilations: [c], group: d, kernelShape: [e], pads: [f, h], strides: [k], wIsConst: () => !!z[m >>> 0], outputPadding: n ? Array.from(G.subarray(n >>> 0, q >>> 0)) : [], outputShape: r ? Array.from(G.subarray(r >>> 0, p >>> 0)) : [], activation: J(u) }); + }, + 1268362: (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => { + g.je("ConvTranspose", a, { + format: k ? "NHWC" : "NCHW", + autoPad: b, + dilations: Array.from(G.subarray(c >>> 0, (c >>> 0) + 2 >>> 0)), + group: d, + kernelShape: Array.from(G.subarray(e >>> 0, (e >>> 0) + 2 >>> 0)), + pads: Array.from(G.subarray(f >>> 0, (f >>> 0) + 4 >>> 0)), + strides: Array.from(G.subarray(h >>> 0, (h >>> 0) + 2 >>> 0)), + wIsConst: () => !!z[l >>> 0], + outputPadding: m ? Array.from(G.subarray(m >>> 0, n >>> 0)) : [], + outputShape: q ? Array.from(G.subarray(q >>> 0, r >>> 0)) : [], + activation: J(p) + }); + }, + 1268927: (a, b) => { + g.je("GlobalAveragePool", a, { format: b ? "NHWC" : "NCHW" }); + }, + 1269018: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => { + g.je("AveragePool", a, { + format: y ? "NHWC" : "NCHW", + auto_pad: b, + ceil_mode: c, + count_include_pad: d, + storage_order: e, + dilations: [f, h], + kernel_shape: [k, l], + pads: [m, n, q, r], + strides: [p, u] + }); + }, + 1269302: (a, b) => { + g.je("GlobalAveragePool", a, { format: b ? "NHWC" : "NCHW" }); + }, + 1269393: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => { + g.je("AveragePool", a, { format: y ? "NHWC" : "NCHW", auto_pad: b, ceil_mode: c, count_include_pad: d, storage_order: e, dilations: [f, h], kernel_shape: [k, l], pads: [m, n, q, r], strides: [p, u] }); + }, + 1269677: (a, b) => { + g.je("GlobalMaxPool", a, { format: b ? "NHWC" : "NCHW" }); + }, + 1269764: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => { + g.je("MaxPool", a, { format: y ? "NHWC" : "NCHW", auto_pad: b, ceil_mode: c, count_include_pad: d, storage_order: e, dilations: [f, h], kernel_shape: [k, l], pads: [m, n, q, r], strides: [p, u] }); + }, + 1270044: (a, b) => { + g.je("GlobalMaxPool", a, { format: b ? "NHWC" : "NCHW" }); + }, + 1270131: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => { + g.je("MaxPool", a, { format: y ? "NHWC" : "NCHW", auto_pad: b, ceil_mode: c, count_include_pad: d, storage_order: e, dilations: [f, h], kernel_shape: [k, l], pads: [m, n, q, r], strides: [p, u] }); + }, + 1270411: (a, b, c, d, e) => { + g.je("Gemm", a, { alpha: b, beta: c, transA: d, transB: e }); + }, + 1270515: (a) => { + g.je("MatMul", a, void 0); + }, + 1270569: (a, b, c, d) => { + g.je("ArgMax", a, { keepDims: !!b, selectLastIndex: !!c, axis: d }); + }, + 1270677: (a, b, c, d) => { + g.je("ArgMin", a, { keepDims: !!b, selectLastIndex: !!c, axis: d }); + }, + 1270785: (a, b) => { + g.je("Softmax", a, { axis: b }); + }, + 1270848: (a, b) => { + g.je("Concat", a, { axis: b }); + }, + 1270908: (a, b, c, d, e) => { + g.je("Split", a, { axis: b, numOutputs: c, splitSizes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] }); + }, + 1271048: (a) => { + g.je("Expand", a, void 0); + }, + 1271102: (a, b) => { + g.je("Gather", a, { axis: Number(b) }); + }, + 1271173: (a, b) => { + g.je( + "GatherElements", + a, + { axis: Number(b) } + ); + }, + 1271252: (a, b, c, d, e, f, h, k, l, m, n) => { + g.je("Resize", a, { antialias: b, axes: c ? Array.from(G.subarray(c >>> 0, d >>> 0)) : [], coordinateTransformMode: J(e), cubicCoeffA: f, excludeOutside: h, extrapolationValue: k, keepAspectRatioPolicy: J(l), mode: J(m), nearestMode: J(n) }); + }, + 1271598: (a, b, c, d, e, f, h) => { + g.je("Slice", a, { starts: b ? Array.from(G.subarray(b >>> 0, c >>> 0)) : [], ends: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [], axes: f ? Array.from(G.subarray(f >>> 0, h >>> 0)) : [] }); + }, + 1271814: (a) => { + g.je("Tile", a, void 0); + }, + 1271866: (a, b, c, d) => { + g.je("LayerNormalization", a, { axis: b, epsilon: c, simplified: !!d }); + }, + 1271977: (a, b, c) => { + g.je("InstanceNormalization", a, { epsilon: b, format: c ? "NHWC" : "NCHW" }); + }, + 1272091: (a, b, c) => { + g.je("InstanceNormalization", a, { epsilon: b, format: c ? "NHWC" : "NCHW" }); + }, + 1272205: (a) => { + g.je("Range", a, void 0); + }, + 1272258: (a, b) => { + g.je("Einsum", a, { equation: J(b) }); + }, + 1272339: (a, b, c, d, e) => { + g.je("Pad", a, { mode: b, value: c, pads: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] }); + }, + 1272466: (a, b, c, d, e, f) => { + g.je("BatchNormalization", a, { + epsilon: b, + momentum: c, + spatial: !!e, + trainingMode: !!d, + format: f ? "NHWC" : "NCHW" + }); + }, + 1272635: (a, b, c, d, e, f) => { + g.je("BatchNormalization", a, { epsilon: b, momentum: c, spatial: !!e, trainingMode: !!d, format: f ? "NHWC" : "NCHW" }); + }, + 1272804: (a, b, c) => { + g.je("CumSum", a, { exclusive: Number(b), reverse: Number(c) }); + }, + 1272901: (a, b, c, d, e, f, h, k, l) => { + g.je("Attention", a, { numHeads: b, isUnidirectional: c, maskFilterValue: d, scale: e, doRotary: f, qkvHiddenSizes: h ? Array.from(G.subarray(Number(k) >>> 0, Number(k) + h >>> 0)) : [], pastPresentShareBuffer: !!l }); + }, + 1273173: (a) => { + g.je( + "BiasAdd", + a, + void 0 + ); + }, + 1273228: (a) => { + g.je("BiasSplitGelu", a, void 0); + }, + 1273289: (a) => { + g.je("FastGelu", a, void 0); + }, + 1273345: (a, b, c, d, e, f, h, k, l, m, n, q, r) => { + g.je("Conv", a, { format: l ? "NHWC" : "NCHW", auto_pad: b, dilations: [c], group: d, kernel_shape: [e], pads: f ? Array.from(G.subarray(f >>> 0, h >>> 0)) : [], strides: [k], w_is_const: () => !!z[m >>> 0], activation: J(n), activation_params: q ? Array.from(va.subarray(q >>> 0, r >>> 0)) : [] }); + }, + 1273715: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => { + g.je("Conv", a, { format: q ? "NHWC" : "NCHW", auto_pad: b, dilations: [c, d], group: e, kernel_shape: [ + f, + h + ], pads: k ? Array.from(G.subarray(k >>> 0, l >>> 0)) : [], strides: [m, n], w_is_const: () => !!z[r >>> 0], activation: J(p), activation_params: u ? Array.from(va.subarray(u >>> 0, y >>> 0)) : [] }); + }, + 1274106: (a) => { + g.je("Gelu", a, void 0); + }, + 1274158: (a, b, c, d, e, f) => { + g.je("MatMulNBits", a, { k: b, n: c, accuracyLevel: d, bits: e, blockSize: f }); + }, + 1274285: (a, b, c, d, e, f) => { + g.je("MultiHeadAttention", a, { numHeads: b, isUnidirectional: c, maskFilterValue: d, scale: e, doRotary: f }); + }, + 1274444: (a, b, c, d, e) => { + g.je("RotaryEmbedding", a, { + interleaved: !!b, + numHeads: c, + rotaryEmbeddingDim: d, + scale: e + }); + }, + 1274583: (a, b, c) => { + g.je("SkipLayerNormalization", a, { epsilon: b, simplified: !!c }); + }, + 1274685: (a, b, c) => { + g.je("SkipLayerNormalization", a, { epsilon: b, simplified: !!c }); + }, + 1274787: (a, b, c, d) => { + g.je("LayerNormalization", a, { axis: b, epsilon: c, simplified: !!d }); + }, + 1274898: (a) => { + g.di(a); + }, + 1274932: (a, b) => g.fi(a, b, g.Oh.gi, g.Oh.errors) + }; + function Pa(a) { + this.name = "ExitStatus"; + this.message = `Program terminated with exit(${a})`; + this.status = a; + } + var Qa = [], Ra = 0, L = 0; + class Sa { + constructor(a) { + this.Nh = a; + this.Ih = a - 24; + } + } + var Za = (a) => { + var b = L; + if (!b) + return Ta(0), 0; + var c = new Sa(b); + I[c.Ih + 16 >>> 2 >>> 0] = b; + var d = I[c.Ih + 4 >>> 2 >>> 0]; + if (!d) + return Ta(0), b; + for (var e in a) { + var f = a[e]; + if (0 === f || f === d) + break; + if (Ua(f, d, c.Ih + 16)) + return Ta(f), b; + } + Ta(d); + return b; + }, $a = "undefined" != typeof TextDecoder ? new TextDecoder("utf8") : void 0, ab = (a, b, c) => { + b >>>= 0; + var d = b + c; + for (c = b; a[c] && !(c >= d); ) + ++c; + if (16 < c - b && a.buffer && $a) + return $a.decode(a.subarray(b, c)); + for (d = ""; b < c; ) { + var e = a[b++]; + if (e & 128) { + var f = a[b++] & 63; + if (192 == (e & 224)) + d += String.fromCharCode((e & 31) << 6 | f); + else { + var h = a[b++] & 63; + e = 224 == (e & 240) ? (e & 15) << 12 | f << 6 | h : (e & 7) << 18 | f << 12 | h << 6 | a[b++] & 63; + 65536 > e ? d += String.fromCharCode(e) : (e -= 65536, d += String.fromCharCode(55296 | e >> 10, 56320 | e & 1023)); + } + } else + d += String.fromCharCode(e); + } + return d; + }, J = (a, b) => (a >>>= 0) ? ab(E, a, b) : "", bb = (a) => { + for (var b = 0, c = 0; c < a.length; ++c) { + var d = a.charCodeAt(c); + 127 >= d ? b++ : 2047 >= d ? b += 2 : 55296 <= d && 57343 >= d ? (b += 4, ++c) : b += 3; + } + return b; + }, M = (a, b, c, d) => { + c >>>= 0; + if (!(0 < d)) + return 0; + var e = c; + d = c + d - 1; + for (var f = 0; f < a.length; ++f) { + var h = a.charCodeAt(f); + if (55296 <= h && 57343 >= h) { + var k = a.charCodeAt(++f); + h = 65536 + ((h & 1023) << 10) | k & 1023; + } + if (127 >= h) { + if (c >= d) + break; + b[c++ >>> 0] = h; + } else { + if (2047 >= h) { + if (c + 1 >= d) + break; + b[c++ >>> 0] = 192 | h >> 6; + } else { + if (65535 >= h) { + if (c + 2 >= d) + break; + b[c++ >>> 0] = 224 | h >> 12; + } else { + if (c + 3 >= d) + break; + b[c++ >>> 0] = 240 | h >> 18; + b[c++ >>> 0] = 128 | h >> 12 & 63; + } + b[c++ >>> 0] = 128 | h >> 6 & 63; + } + b[c++ >>> 0] = 128 | h & 63; + } + } + b[c >>> 0] = 0; + return c - e; + }, cb, N = (a) => { + for (var b = ""; E[a >>> 0]; ) + b += cb[E[a++ >>> 0]]; + return b; + }, db = {}, eb = {}, fb = {}, O; + function gb(a, b, c = {}) { + var d = b.name; + if (!a) + throw new O(`type "${d}" must have a positive integer typeid pointer`); + if (eb.hasOwnProperty(a)) { + if (c.Xh) + return; + throw new O(`Cannot register type '${d}' twice`); + } + eb[a] = b; + delete fb[a]; + db.hasOwnProperty(a) && (b = db[a], delete db[a], b.forEach((e) => e())); + } + function P(a, b, c = {}) { + if (!("argPackAdvance" in b)) + throw new TypeError("registerType registeredInstance requires argPackAdvance"); + return gb(a, b, c); + } + var hb = (a, b, c) => { + switch (b) { + case 1: + return c ? (d) => z[d >>> 0] : (d) => E[d >>> 0]; + case 2: + return c ? (d) => ta[d >>> 1 >>> 0] : (d) => ua[d >>> 1 >>> 0]; + case 4: + return c ? (d) => G[d >>> 2 >>> 0] : (d) => I[d >>> 2 >>> 0]; + case 8: + return c ? (d) => wa[d >>> 3] : (d) => xa[d >>> 3]; + default: + throw new TypeError(`invalid integer width (${b}): ${a}`); + } + }, ib = [], Q = []; + function jb(a) { + a >>>= 0; + 9 < a && 0 === --Q[a + 1] && (Q[a] = void 0, ib.push(a)); + } + var R = (a) => { + if (!a) + throw new O("Cannot use deleted val. handle = " + a); + return Q[a]; + }, S = (a) => { + switch (a) { + case void 0: + return 2; + case null: + return 4; + case true: + return 6; + case false: + return 8; + default: + const b = ib.pop() || Q.length; + Q[b] = a; + Q[b + 1] = 1; + return b; + } + }; + function kb(a) { + return this.fromWireType(I[a >>> 2 >>> 0]); + } + var lb = { name: "emscripten::val", fromWireType: (a) => { + var b = R(a); + jb(a); + return b; + }, toWireType: (a, b) => S(b), argPackAdvance: 8, readValueFromPointer: kb, Mh: null }, mb = (a, b) => { + switch (b) { + case 4: + return function(c) { + return this.fromWireType(va[c >>> 2 >>> 0]); + }; + case 8: + return function(c) { + return this.fromWireType(ya[c >>> 3 >>> 0]); + }; + default: + throw new TypeError(`invalid float width (${b}): ${a}`); + } + }, nb = "undefined" != typeof TextDecoder ? new TextDecoder("utf-16le") : void 0, ob = (a, b) => { + var c = a >> 1; + for (var d = c + b / 2; !(c >= d) && ua[c >>> 0]; ) + ++c; + c <<= 1; + if (32 < c - a && nb) + return nb.decode(E.subarray(a >>> 0, c >>> 0)); + c = ""; + for (d = 0; !(d >= b / 2); ++d) { + var e = ta[a + 2 * d >>> 1 >>> 0]; + if (0 == e) + break; + c += String.fromCharCode(e); + } + return c; + }, pb = (a, b, c) => { + c ??= 2147483647; + if (2 > c) + return 0; + c -= 2; + var d = b; + c = c < 2 * a.length ? c / 2 : a.length; + for (var e = 0; e < c; ++e) + ta[b >>> 1 >>> 0] = a.charCodeAt(e), b += 2; + ta[b >>> 1 >>> 0] = 0; + return b - d; + }, qb = (a) => 2 * a.length, rb = (a, b) => { + for (var c = 0, d = ""; !(c >= b / 4); ) { + var e = G[a + 4 * c >>> 2 >>> 0]; + if (0 == e) + break; + ++c; + 65536 <= e ? (e -= 65536, d += String.fromCharCode(55296 | e >> 10, 56320 | e & 1023)) : d += String.fromCharCode(e); + } + return d; + }, sb = (a, b, c) => { + b >>>= 0; + c ??= 2147483647; + if (4 > c) + return 0; + var d = b; + c = d + c - 4; + for (var e = 0; e < a.length; ++e) { + var f = a.charCodeAt(e); + if (55296 <= f && 57343 >= f) { + var h = a.charCodeAt(++e); + f = 65536 + ((f & 1023) << 10) | h & 1023; + } + G[b >>> 2 >>> 0] = f; + b += 4; + if (b + 4 > c) + break; + } + G[b >>> 2 >>> 0] = 0; + return b - d; + }, tb = (a) => { + for (var b = 0, c = 0; c < a.length; ++c) { + var d = a.charCodeAt(c); + 55296 <= d && 57343 >= d && ++c; + b += 4; + } + return b; + }, vb = (a, b) => { + var c = eb[a]; + if (void 0 === c) + throw a = ub(a), c = N(a), T(a), new O(`${b} has unknown type ${c}`); + return c; + }, wb = (a, b, c) => { + var d = []; + a = a.toWireType(d, c); + d.length && (I[b >>> 2 >>> 0] = S(d)); + return a; + }, xb = (a) => { + try { + a(); + } catch (b) { + Ga(b); + } + }, yb = (a) => { + if (!x) + try { + a(); + try { + sa = sa = a = sa, g.onExit?.(a), x = true, ha(a, new Pa(a)); + } catch (b) { + b instanceof Pa || "unwind" == b || ha(1, b); + } + } catch (b) { + b instanceof Pa || "unwind" == b || ha(1, b); + } + }; + function zb() { + var a = U, b = {}; + for (let [c, d] of Object.entries(a)) + b[c] = "function" == typeof d ? (...e) => { + Ab.push(c); + try { + return d(...e); + } finally { + x || (Ab.pop(), t && 1 === V && 0 === Ab.length && (V = 0, xb(Bb), "undefined" != typeof Fibers && Fibers.mi())); + } + } : d; + return b; + } + var V = 0, t = null, Cb = 0, Ab = [], Db = {}, Eb = {}, Fb = 0, Gb = null, Hb = []; + function ca() { + return new Promise((a, b) => { + Gb = { resolve: a, reject: b }; + }); + } + function Ib() { + var a = Jb(65548), b = a + 12; + I[a >>> 2 >>> 0] = b; + I[a + 4 >>> 2 >>> 0] = b + 65536; + b = Ab[0]; + var c = Db[b]; + void 0 === c && (c = Fb++, Db[b] = c, Eb[c] = b); + G[a + 8 >>> 2 >>> 0] = c; + return a; + } + function Kb(a) { + if (!x) { + if (0 === V) { + var b = false, c = false; + a((d = 0) => { + if (!x && (Cb = d, b = true, c)) { + V = 2; + xb(() => Lb(t)); + "undefined" != typeof Browser && Browser.Sh.Wh && Browser.Sh.resume(); + d = false; + try { + var e = (0, U[Eb[G[t + 8 >>> 2 >>> 0]]])(); + } catch (k) { + e = k, d = true; + } + var f = false; + if (!t) { + var h = Gb; + h && (Gb = null, (d ? h.reject : h.resolve)(e), f = true); + } + if (d && !f) + throw e; + } + }); + c = true; + b || (V = 1, t = Ib(), "undefined" != typeof Browser && Browser.Sh.Wh && Browser.Sh.pause(), xb(() => Mb(t))); + } else + 2 === V ? (V = 0, xb(Nb), T(t), t = null, Hb.forEach(yb)) : Ga(`invalid state: ${V}`); + return Cb; + } + } + function Ob(a) { + return Kb((b) => { + a().then(b); + }); + } + var Pb = [], Qb = {}, Rb = (a) => { + var b = Qb[a]; + return void 0 === b ? N(a) : b; + }, Sb = () => "object" == typeof globalThis ? globalThis : Function("return this")(), Tb = (a) => { + var b = Pb.length; + Pb.push(a); + return b; + }, Ub = (a, b) => { + for (var c = Array(a), d = 0; d < a; ++d) + c[d] = vb(I[b + 4 * d >>> 2 >>> 0], "parameter " + d); + return c; + }, Vb = (a, b) => Object.defineProperty(b, "name", { value: a }); + function Wb(a) { + var b = Function; + if (!(b instanceof Function)) + throw new TypeError(`new_ called with constructor type ${typeof b} which is not a function`); + var c = Vb(b.name || "unknownFunctionName", function() { + }); + c.prototype = b.prototype; + c = new c(); + a = b.apply(c, a); + return a instanceof Object ? a : c; + } + var W = (a) => 0 === a % 4 && (0 !== a % 100 || 0 === a % 400), Xb = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335], Yb = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334], Zb = [], $b = (a, b) => { + Zb.length = 0; + for (var c; c = E[a++ >>> 0]; ) { + var d = 105 != c; + d &= 112 != c; + b += d && b % 8 ? 4 : 0; + Zb.push(112 == c ? I[b >>> 2 >>> 0] : 106 == c ? wa[b >>> 3] : 105 == c ? G[b >>> 2 >>> 0] : ya[b >>> 3 >>> 0]); + b += d ? 8 : 4; + } + return Zb; + }, ac = {}, cc = () => { + if (!bc) { + var a = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: ("object" == typeof navigator && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8", _: fa || "./this.program" }, b; + for (b in ac) + void 0 === ac[b] ? delete a[b] : a[b] = ac[b]; + var c = []; + for (b in a) + c.push(`${b}=${a[b]}`); + bc = c; + } + return bc; + }, bc, dc = [null, [], []], ec = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], fc = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + function gc(a) { + var b = Array(bb(a) + 1); + M(a, b, 0, b.length); + return b; + } + function hc(a, b, c, d) { + function e(p, u, y) { + for (p = "number" == typeof p ? p.toString() : p || ""; p.length < u; ) + p = y[0] + p; + return p; + } + function f(p, u) { + return e(p, u, "0"); + } + function h(p, u) { + function y(B) { + return 0 > B ? -1 : 0 < B ? 1 : 0; + } + var A; + 0 === (A = y(p.getFullYear() - u.getFullYear())) && 0 === (A = y(p.getMonth() - u.getMonth())) && (A = y(p.getDate() - u.getDate())); + return A; + } + function k(p) { + switch (p.getDay()) { + case 0: + return new Date(p.getFullYear() - 1, 11, 29); + case 1: + return p; + case 2: + return new Date(p.getFullYear(), 0, 3); + case 3: + return new Date( + p.getFullYear(), + 0, + 2 + ); + case 4: + return new Date(p.getFullYear(), 0, 1); + case 5: + return new Date(p.getFullYear() - 1, 11, 31); + case 6: + return new Date(p.getFullYear() - 1, 11, 30); + } + } + function l(p) { + var u = p.Kh; + for (p = new Date(new Date(p.Lh + 1900, 0, 1).getTime()); 0 < u; ) { + var y = p.getMonth(), A = (W(p.getFullYear()) ? ec : fc)[y]; + if (u > A - p.getDate()) + u -= A - p.getDate() + 1, p.setDate(1), 11 > y ? p.setMonth(y + 1) : (p.setMonth(0), p.setFullYear(p.getFullYear() + 1)); + else { + p.setDate(p.getDate() + u); + break; + } + } + y = new Date(p.getFullYear() + 1, 0, 4); + u = k(new Date( + p.getFullYear(), + 0, + 4 + )); + y = k(y); + return 0 >= h(u, p) ? 0 >= h(y, p) ? p.getFullYear() + 1 : p.getFullYear() : p.getFullYear() - 1; + } + a >>>= 0; + b >>>= 0; + c >>>= 0; + d >>>= 0; + var m = I[d + 40 >>> 2 >>> 0]; + d = { ji: G[d >>> 2 >>> 0], ii: G[d + 4 >>> 2 >>> 0], Qh: G[d + 8 >>> 2 >>> 0], Th: G[d + 12 >>> 2 >>> 0], Rh: G[d + 16 >>> 2 >>> 0], Lh: G[d + 20 >>> 2 >>> 0], Jh: G[d + 24 >>> 2 >>> 0], Kh: G[d + 28 >>> 2 >>> 0], li: G[d + 32 >>> 2 >>> 0], hi: G[d + 36 >>> 2 >>> 0], ki: m ? J(m) : "" }; + c = J(c); + m = { + "%c": "%a %b %d %H:%M:%S %Y", + "%D": "%m/%d/%y", + "%F": "%Y-%m-%d", + "%h": "%b", + "%r": "%I:%M:%S %p", + "%R": "%H:%M", + "%T": "%H:%M:%S", + "%x": "%m/%d/%y", + "%X": "%H:%M:%S", + "%Ec": "%c", + "%EC": "%C", + "%Ex": "%m/%d/%y", + "%EX": "%H:%M:%S", + "%Ey": "%y", + "%EY": "%Y", + "%Od": "%d", + "%Oe": "%e", + "%OH": "%H", + "%OI": "%I", + "%Om": "%m", + "%OM": "%M", + "%OS": "%S", + "%Ou": "%u", + "%OU": "%U", + "%OV": "%V", + "%Ow": "%w", + "%OW": "%W", + "%Oy": "%y" + }; + for (var n in m) + c = c.replace(new RegExp(n, "g"), m[n]); + var q = "Sunday Monday Tuesday Wednesday Thursday Friday Saturday".split(" "), r = "January February March April May June July August September October November December".split(" "); + m = { "%a": (p) => q[p.Jh].substring(0, 3), "%A": (p) => q[p.Jh], "%b": (p) => r[p.Rh].substring(0, 3), "%B": (p) => r[p.Rh], "%C": (p) => f((p.Lh + 1900) / 100 | 0, 2), "%d": (p) => f(p.Th, 2), "%e": (p) => e(p.Th, 2, " "), "%g": (p) => l(p).toString().substring(2), "%G": l, "%H": (p) => f(p.Qh, 2), "%I": (p) => { + p = p.Qh; + 0 == p ? p = 12 : 12 < p && (p -= 12); + return f(p, 2); + }, "%j": (p) => { + for (var u = 0, y = 0; y <= p.Rh - 1; u += (W(p.Lh + 1900) ? ec : fc)[y++]) + ; + return f(p.Th + u, 3); + }, "%m": (p) => f(p.Rh + 1, 2), "%M": (p) => f(p.ii, 2), "%n": () => "\n", "%p": (p) => 0 <= p.Qh && 12 > p.Qh ? "AM" : "PM", "%S": (p) => f(p.ji, 2), "%t": () => " ", "%u": (p) => p.Jh || 7, "%U": (p) => f(Math.floor((p.Kh + 7 - p.Jh) / 7), 2), "%V": (p) => { + var u = Math.floor((p.Kh + 7 - (p.Jh + 6) % 7) / 7); + 2 >= (p.Jh + 371 - p.Kh - 2) % 7 && u++; + if (u) + 53 == u && (y = (p.Jh + 371 - p.Kh) % 7, 4 == y || 3 == y && W(p.Lh) || (u = 1)); + else { + u = 52; + var y = (p.Jh + 7 - p.Kh - 1) % 7; + (4 == y || 5 == y && W(p.Lh % 400 - 1)) && u++; + } + return f(u, 2); + }, "%w": (p) => p.Jh, "%W": (p) => f(Math.floor((p.Kh + 7 - (p.Jh + 6) % 7) / 7), 2), "%y": (p) => (p.Lh + 1900).toString().substring(2), "%Y": (p) => p.Lh + 1900, "%z": (p) => { + p = p.hi; + var u = 0 <= p; + p = Math.abs(p) / 60; + return (u ? "+" : "-") + String("0000" + (p / 60 * 100 + p % 60)).slice(-4); + }, "%Z": (p) => p.ki, "%%": () => "%" }; + c = c.replace(/%%/g, "\0\0"); + for (n in m) + c.includes(n) && (c = c.replace(new RegExp(n, "g"), m[n](d))); + c = c.replace(/\0\0/g, "%"); + n = gc(c); + if (n.length > b) + return 0; + z.set(n, a >>> 0); + return n.length - 1; + } + for (var ic = Array(256), jc = 0; 256 > jc; ++jc) + ic[jc] = String.fromCharCode(jc); + cb = ic; + O = g.BindingError = class extends Error { + constructor(a) { + super(a); + this.name = "BindingError"; + } + }; + g.InternalError = class extends Error { + constructor(a) { + super(a); + this.name = "InternalError"; + } + }; + Q.push(0, 1, void 0, 1, null, 1, true, 1, false, 1); + g.count_emval_handles = () => Q.length / 2 - 5 - ib.length; + var Cf = { + bd: function(a, b, c) { + return Ob(async () => { + await g.bi(a, b, c); + }); + }, + v: function(a) { + a = new Sa(a >>> 0); + 0 == z[a.Ih + 12 >>> 0] && (z[a.Ih + 12 >>> 0] = 1, Ra--); + z[a.Ih + 13 >>> 0] = 0; + Qa.push(a); + kc(a.Nh); + if (lc(I[a.Ih + 4 >>> 2 >>> 0])) + a = I[a.Nh >>> 2 >>> 0]; + else { + var b = I[a.Ih + 16 >>> 2 >>> 0]; + a = 0 !== b ? b : a.Nh; + } + return a; + }, + N: () => { + X(0, 0); + var a = Qa.pop(); + mc(a.Nh); + L = 0; + }, + a: function() { + return Za([]); + }, + m: function(a) { + return Za([a >>> 0]); + }, + x: function(a, b) { + return Za([a >>> 0, b >>> 0]); + }, + q: function(a, b, c) { + return Za([a >>> 0, b >>> 0, c >>> 0]); + }, + Bb: () => { + var a = Qa.pop(); + a || Ga("no exception to throw"); + var b = a.Nh; + 0 == z[a.Ih + 13 >>> 0] && (Qa.push(a), z[a.Ih + 13 >>> 0] = 1, z[a.Ih + 12 >>> 0] = 0, Ra++); + L = b; + throw L; + }, + s: function(a, b, c) { + a >>>= 0; + var d = new Sa(a); + I[d.Ih + 16 >>> 2 >>> 0] = 0; + I[d.Ih + 4 >>> 2 >>> 0] = b >>> 0; + I[d.Ih + 8 >>> 2 >>> 0] = c >>> 0; + L = a; + Ra++; + throw L; + }, + fb: () => Ra, + g: function(a) { + L ||= a >>> 0; + throw L; + }, + Cb: function() { + return 0; + }, + $c: function() { + }, + Mc: function() { + }, + Oc: function() { + }, + Gc: function() { + return 0; + }, + Zc: function() { + }, + Uc: function() { + }, + Yc: function() { + }, + _b: function() { + }, + Nc: function() { + }, + Kc: function() { + }, + _c: function() { + }, + Lc: function() { + }, + Wb: function(a, b, c) { + b = N(b >>> 0); + P(a >>> 0, { name: b, fromWireType: (d) => d, toWireType: function(d, e) { + if ("bigint" != typeof e && "number" != typeof e) + throw null === e ? e = "null" : (d = typeof e, e = "object" === d || "array" === d || "function" === d ? e.toString() : "" + e), new TypeError(`Cannot convert "${e}" to ${this.name}`); + "number" == typeof e && (e = BigInt(e)); + return e; + }, argPackAdvance: 8, readValueFromPointer: hb(b, c >>> 0, -1 == b.indexOf("u")), Mh: null }); + }, + Ec: function(a, b, c, d) { + b = N(b >>> 0); + P(a >>> 0, { name: b, fromWireType: function(e) { + return !!e; + }, toWireType: function(e, f) { + return f ? c : d; + }, argPackAdvance: 8, readValueFromPointer: function(e) { + return this.fromWireType(E[e >>> 0]); + }, Mh: null }); + }, + Cc: function(a) { + return P(a >>> 0, lb); + }, + Vb: function(a, b, c) { + b = N(b >>> 0); + P(a >>> 0, { name: b, fromWireType: (d) => d, toWireType: (d, e) => e, argPackAdvance: 8, readValueFromPointer: mb(b, c >>> 0), Mh: null }); + }, + Aa: function(a, b, c, d, e) { + a >>>= 0; + c >>>= 0; + b = N(b >>> 0); + -1 === e && (e = 4294967295); + e = (k) => k; + if (0 === d) { + var f = 32 - 8 * c; + e = (k) => k << f >>> f; + } + var h = b.includes("unsigned") ? function(k, l) { + return l >>> 0; + } : function(k, l) { + return l; + }; + P(a, { + name: b, + fromWireType: e, + toWireType: h, + argPackAdvance: 8, + readValueFromPointer: hb(b, c, 0 !== d), + Mh: null + }); + }, + _: function(a, b, c) { + function d(f) { + return new e(z.buffer, I[f + 4 >>> 2 >>> 0], I[f >>> 2 >>> 0]); + } + var e = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array][b]; + c = N(c >>> 0); + P(a >>> 0, { name: c, fromWireType: d, argPackAdvance: 8, readValueFromPointer: d }, { Xh: true }); + }, + Xb: function(a, b) { + b = N(b >>> 0); + var c = "std::string" === b; + P(a >>> 0, { name: b, fromWireType: function(d) { + var e = I[d >>> 2 >>> 0], f = d + 4; + if (c) + for (var h = f, k = 0; k <= e; ++k) { + var l = f + k; + if (k == e || 0 == E[l >>> 0]) { + h = J(h, l - h); + if (void 0 === m) + var m = h; + else + m += String.fromCharCode(0), m += h; + h = l + 1; + } + } + else { + m = Array(e); + for (k = 0; k < e; ++k) + m[k] = String.fromCharCode(E[f + k >>> 0]); + m = m.join(""); + } + T(d); + return m; + }, toWireType: function(d, e) { + e instanceof ArrayBuffer && (e = new Uint8Array(e)); + var f = "string" == typeof e; + if (!(f || e instanceof Uint8Array || e instanceof Uint8ClampedArray || e instanceof Int8Array)) + throw new O("Cannot pass non-string to std::string"); + var h = c && f ? bb(e) : e.length; + var k = Jb(4 + h + 1), l = k + 4; + I[k >>> 2 >>> 0] = h; + if (c && f) + M(e, E, l, h + 1); + else if (f) + for (f = 0; f < h; ++f) { + var m = e.charCodeAt(f); + if (255 < m) + throw T(l), new O("String has UTF-16 code units that do not fit in 8 bits"); + E[l + f >>> 0] = m; + } + else + for (f = 0; f < h; ++f) + E[l + f >>> 0] = e[f]; + null !== d && d.push(T, k); + return k; + }, argPackAdvance: 8, readValueFromPointer: kb, Mh(d) { + T(d); + } }); + }, + Ab: function(a, b, c) { + b >>>= 0; + c >>>= 0; + c = N(c); + if (2 === b) { + var d = ob; + var e = pb; + var f = qb; + var h = (k) => ua[k >>> 1 >>> 0]; + } else + 4 === b && (d = rb, e = sb, f = tb, h = (k) => I[k >>> 2 >>> 0]); + P(a >>> 0, { + name: c, + fromWireType: (k) => { + for (var l = I[k >>> 2 >>> 0], m, n = k + 4, q = 0; q <= l; ++q) { + var r = k + 4 + q * b; + if (q == l || 0 == h(r)) + n = d(n, r - n), void 0 === m ? m = n : (m += String.fromCharCode(0), m += n), n = r + b; + } + T(k); + return m; + }, + toWireType: (k, l) => { + if ("string" != typeof l) + throw new O(`Cannot pass non-string to C++ string type ${c}`); + var m = f(l), n = Jb(4 + m + b); + I[n >>> 2 >>> 0] = m / b; + e(l, n + 4, m + b); + null !== k && k.push(T, n); + return n; + }, + argPackAdvance: 8, + readValueFromPointer: kb, + Mh(k) { + T(k); + } + }); + }, + Fc: function(a, b) { + b = N(b >>> 0); + P(a >>> 0, { Yh: true, name: b, argPackAdvance: 0, fromWireType: () => { + }, toWireType: () => { + } }); + }, + ad: () => 1, + kd: function(a, b, c) { + b >>>= 0; + c >>>= 0; + a = R(a >>> 0); + b = vb(b, "emval::as"); + return wb(b, c, a); + }, + Cd: function(a) { + a >>>= 0; + return Ob(() => { + a = R(a); + return a.then(S); + }); + }, + ud: function(a, b, c, d) { + c >>>= 0; + d >>>= 0; + a = Pb[a >>> 0]; + b = R(b >>> 0); + return a(null, b, c, d); + }, + ia: function(a, b, c, d, e) { + c >>>= 0; + d >>>= 0; + e >>>= 0; + a = Pb[a >>> 0]; + b = R(b >>> 0); + c = Rb(c); + return a(b, b[c], d, e); + }, + Bc: jb, + qd: function(a, b) { + b >>>= 0; + a = R(a >>> 0); + b = R(b); + return a == b; + }, + zd: function(a) { + a >>>= 0; + if (0 === a) + return S(Sb()); + a = Rb(a); + return S(Sb()[a]); + }, + ha: function(a, b, c) { + b = Ub(a, b >>> 0); + var d = b.shift(); + a--; + var e = "return function (obj, func, destructorsRef, args) {\n", f = 0, h = []; + 0 === c && h.push("obj"); + for (var k = ["retType"], l = [d], m = 0; m < a; ++m) + h.push("arg" + m), k.push("argType" + m), l.push(b[m]), e += ` var arg${m} = argType${m}.readValueFromPointer(args${f ? "+" + f : ""}); +`, f += b[m].argPackAdvance; + e += ` var rv = ${1 === c ? "new func" : "func.call"}(${h.join(", ")}); +`; + d.Yh || (k.push("emval_returnValue"), l.push(wb), e += " return emval_returnValue(retType, destructorsRef, rv);\n"); + k.push(e + "};\n"); + a = Wb(k)(...l); + c = `methodCaller<(${b.map((n) => n.name).join(", ")}) => ${d.name}>`; + return Tb(Vb(c, a)); + }, + yd: function(a, b) { + b >>>= 0; + a = R(a >>> 0); + b = R(b); + return S(a[b]); + }, + ba: function(a) { + a >>>= 0; + 9 < a && (Q[a + 1] += 1); + }, + md: function() { + return S([]); + }, + hd: function(a) { + a = R(a >>> 0); + for (var b = Array(a.length), c = 0; c < a.length; c++) + b[c] = a[c]; + return S(b); + }, + U: function(a) { + return S(Rb(a >>> 0)); + }, + Xa: function() { + return S({}); + }, + vd: function(a) { + a >>>= 0; + for (var b = R(a); b.length; ) { + var c = b.pop(); + b.pop()(c); + } + jb(a); + }, + sd: function(a, b, c) { + b >>>= 0; + c >>>= 0; + a = R(a >>> 0); + b = R(b); + c = R(c); + a[b] = c; + }, + zb: function(a, b) { + b >>>= 0; + a = vb(a >>> 0, "_emval_take_value"); + a = a.readValueFromPointer(b); + return S(a); + }, + Rc: function(a, b) { + a = -9007199254740992 > a || 9007199254740992 < a ? NaN : Number(a); + b >>>= 0; + a = new Date(1e3 * a); + G[b >>> 2 >>> 0] = a.getUTCSeconds(); + G[b + 4 >>> 2 >>> 0] = a.getUTCMinutes(); + G[b + 8 >>> 2 >>> 0] = a.getUTCHours(); + G[b + 12 >>> 2 >>> 0] = a.getUTCDate(); + G[b + 16 >>> 2 >>> 0] = a.getUTCMonth(); + G[b + 20 >>> 2 >>> 0] = a.getUTCFullYear() - 1900; + G[b + 24 >>> 2 >>> 0] = a.getUTCDay(); + G[b + 28 >>> 2 >>> 0] = (a.getTime() - Date.UTC( + a.getUTCFullYear(), + 0, + 1, + 0, + 0, + 0, + 0 + )) / 864e5 | 0; + }, + Sc: function(a, b) { + a = -9007199254740992 > a || 9007199254740992 < a ? NaN : Number(a); + b >>>= 0; + a = new Date(1e3 * a); + G[b >>> 2 >>> 0] = a.getSeconds(); + G[b + 4 >>> 2 >>> 0] = a.getMinutes(); + G[b + 8 >>> 2 >>> 0] = a.getHours(); + G[b + 12 >>> 2 >>> 0] = a.getDate(); + G[b + 16 >>> 2 >>> 0] = a.getMonth(); + G[b + 20 >>> 2 >>> 0] = a.getFullYear() - 1900; + G[b + 24 >>> 2 >>> 0] = a.getDay(); + G[b + 28 >>> 2 >>> 0] = (W(a.getFullYear()) ? Xb : Yb)[a.getMonth()] + a.getDate() - 1 | 0; + G[b + 36 >>> 2 >>> 0] = -(60 * a.getTimezoneOffset()); + var c = new Date(a.getFullYear(), 6, 1).getTimezoneOffset(), d = new Date(a.getFullYear(), 0, 1).getTimezoneOffset(); + G[b + 32 >>> 2 >>> 0] = (c != d && a.getTimezoneOffset() == Math.min(d, c)) | 0; + }, + Tc: function(a) { + a >>>= 0; + var b = new Date(G[a + 20 >>> 2 >>> 0] + 1900, G[a + 16 >>> 2 >>> 0], G[a + 12 >>> 2 >>> 0], G[a + 8 >>> 2 >>> 0], G[a + 4 >>> 2 >>> 0], G[a >>> 2 >>> 0], 0), c = G[a + 32 >>> 2 >>> 0], d = b.getTimezoneOffset(), e = new Date(b.getFullYear(), 6, 1).getTimezoneOffset(), f = new Date(b.getFullYear(), 0, 1).getTimezoneOffset(), h = Math.min(f, e); + 0 > c ? G[a + 32 >>> 2 >>> 0] = Number(e != f && h == d) : 0 < c != (h == d) && (e = Math.max(f, e), b.setTime(b.getTime() + 6e4 * ((0 < c ? h : e) - d))); + G[a + 24 >>> 2 >>> 0] = b.getDay(); + G[a + 28 >>> 2 >>> 0] = (W(b.getFullYear()) ? Xb : Yb)[b.getMonth()] + b.getDate() - 1 | 0; + G[a >>> 2 >>> 0] = b.getSeconds(); + G[a + 4 >>> 2 >>> 0] = b.getMinutes(); + G[a + 8 >>> 2 >>> 0] = b.getHours(); + G[a + 12 >>> 2 >>> 0] = b.getDate(); + G[a + 16 >>> 2 >>> 0] = b.getMonth(); + G[a + 20 >>> 2 >>> 0] = b.getYear(); + a = b.getTime(); + return BigInt(isNaN(a) ? -1 : a / 1e3); + }, + Pc: function() { + return -52; + }, + Qc: function() { + }, + Ic: function(a, b, c, d) { + c >>>= 0; + d >>>= 0; + var e = (/* @__PURE__ */ new Date()).getFullYear(), f = new Date(e, 0, 1), h = new Date(e, 6, 1); + e = f.getTimezoneOffset(); + var k = h.getTimezoneOffset(); + I[a >>> 0 >>> 2 >>> 0] = 60 * Math.max(e, k); + G[b >>> 0 >>> 2 >>> 0] = Number(e != k); + a = (l) => l.toLocaleTimeString(void 0, { hour12: false, timeZoneName: "short" }).split(" ")[1]; + f = a(f); + h = a(h); + k < e ? (M(f, E, c, 17), M(h, E, d, 17)) : (M(f, E, d, 17), M(h, E, c, 17)); + }, + bb: () => { + Ga(""); + }, + A: function(a, b, c) { + a >>>= 0; + b = $b(b >>> 0, c >>> 0); + return Oa[a](...b); + }, + bc: function(a, b, c) { + a >>>= 0; + b = $b(b >>> 0, c >>> 0); + return Oa[a](...b); + }, + $b: () => Date.now(), + Jc: function() { + return 4294901760; + }, + ga: () => performance.now(), + Hc: function(a) { + a >>>= 0; + var b = E.length; + if (4294901760 < a) + return false; + for (var c = 1; 4 >= c; c *= 2) { + var d = b * (1 + 0.2 / c); + d = Math.min(d, a + 100663296); + var e = Math; + d = Math.max(a, d); + a: { + e = (e.min.call(e, 4294901760, d + (65536 - d % 65536) % 65536) - ra.buffer.byteLength + 65535) / 65536; + try { + ra.grow(e); + za(); + var f = 1; + break a; + } catch (h) { + } + f = void 0; + } + if (f) + return true; + } + return false; + }, + Wc: function(a, b) { + a >>>= 0; + b >>>= 0; + var c = 0; + cc().forEach((d, e) => { + var f = b + c; + e = I[a + 4 * e >>> 2 >>> 0] = f; + for (f = 0; f < d.length; ++f) + z[e++ >>> 0] = d.charCodeAt(f); + z[e >>> 0] = 0; + c += d.length + 1; + }); + return 0; + }, + Xc: function(a, b) { + a >>>= 0; + b >>>= 0; + var c = cc(); + I[a >>> 2 >>> 0] = c.length; + var d = 0; + c.forEach((e) => d += e.length + 1); + I[b >>> 2 >>> 0] = d; + return 0; + }, + Db: () => 52, + Zb: function() { + return 52; + }, + Vc: function() { + return 70; + }, + Yb: function(a, b, c, d) { + b >>>= 0; + c >>>= 0; + d >>>= 0; + for (var e = 0, f = 0; f < c; f++) { + var h = I[b >>> 2 >>> 0], k = I[b + 4 >>> 2 >>> 0]; + b += 8; + for (var l = 0; l < k; l++) { + var m = E[h + l >>> 0], n = dc[a]; + 0 === m || 10 === m ? ((1 === a ? qa : w)(ab(n, 0)), n.length = 0) : n.push(m); + } + e += k; + } + I[d >>> 2 >>> 0] = e; + return 0; + }, + xb: nc, + cd: oc, + ua: pc, + W: qc, + $: rc, + ra: sc, + ta: tc, + dd: uc, + ob: vc, + P: wc, + z: xc, + b: yc, + Ub: zc, + ya: Ac, + e: Bc, + kb: Cc, + h: Dc, + X: Ec, + i: Fc, + ed: Gc, + j: Hc, + t: Ic, + r: Jc, + o: Kc, + Wa: Lc, + Ca: Mc, + ma: Nc, + Qb: Oc, + db: Pc, + Ib: Qc, + mb: Rc, + kc: Sc, + xc: Tc, + hc: Uc, + ic: Vc, + ac: Wc, + oa: Xc, + yb: Yc, + Ba: Zc, + Eb: $c, + ea: ad, + jc: bd, + Ta: cd, + F: dd, + G: ed, + Gb: fd, + jd: gd, + qa: hd, + O: jd, + V: kd, + T: ld, + y: md, + Fb: nd, + gc: od, + D: pd, + Hb: qd, + id: rd, + Ua: sd, + wa: td, + lc: ud, + cc: vd, + Nb: wd, + aa: xd, + I: yd, + C: zd, + _a: Ad, + fc: Bd, + Q: Cd, + d: Dd, + ab: Ed, + n: Fd, + Ya: Gd, + va: Hd, + wb: Id, + f: Jd, + yc: Kd, + da: Ld, + gb: Md, + Da: Nd, + lb: Od, + hb: Pd, + c: Qd, + vc: Rd, + od: Sd, + k: Td, + tc: Ud, + l: Vd, + wc: Wd, + sc: Xd, + rd: Yd, + p: Zd, + Ra: $d, + tb: ae, + Qa: be, + Kb: ce, + B: de, + K: ee, + S: fe, + $a: ge, + pc: he, + ub: ie, + za: je, + ka: ke, + xa: le, + Sb: me, + La: ne, + jb: oe, + Ga: pe, + nc: qe, + Ha: re, + Ia: se, + fd: te, + xd: ue, + Z: ve, + pa: we, + pd: xe, + wd: ye, + Mb: ze, + Ma: Ae, + Ka: Be, + Tb: Ce, + rc: De, + Ja: Ee, + Na: Fe, + pb: Ge, + la: He, + Ea: Ie, + mc: Je, + qc: Ke, + Jb: Le, + Fa: Me, + ja: Ne, + Ad: Oe, + nd: Pe, + R: Qe, + eb: Re, + Za: Se, + ec: Te, + ib: Ue, + E: Ve, + M: We, + Va: Xe, + ld: Ye, + ca: Ze, + nb: $e, + na: af, + dc: bf, + Ac: cf, + u: df, + L: ef, + td: ff, + Pb: gf, + oc: hf, + Bd: jf, + Ob: kf, + Lb: lf, + cb: mf, + zc: nf, + Rb: of, + Oa: pf, + Y: qf, + uc: rf, + J: sf, + gd: tf, + vb: uf, + sa: vf, + H: wf, + rb: xf, + Pa: yf, + Sa: zf, + sb: Af, + qb: Bf, + w: function(a) { + return a >>> 0; + }, + Dc: hc, + fa: function(a, b, c, d) { + return hc(a >>> 0, b >>> 0, c >>> 0, d >>> 0); + } + }, U = function() { + function a(c) { + U = c.exports; + U = zb(); + U = Df(); + ra = U.Dd; + za(); + Ba.unshift(U.Ed); + Da--; + 0 == Da && (null !== Ea && (clearInterval(Ea), Ea = null), Fa && (c = Fa, Fa = null, c())); + return U; + } + var b = { a: Cf }; + Da++; + if (g.instantiateWasm) + try { + return g.instantiateWasm(b, a); + } catch (c) { + w(`Module.instantiateWasm callback failed with error: ${c}`), ba(c); + } + Na(b, function(c) { + a(c.instance); + }).catch(ba); + return {}; + }(), ub = (a) => (ub = U.Fd)(a); + g._OrtInit = (a, b) => (g._OrtInit = U.Gd)(a, b); + g._OrtGetLastError = (a, b) => (g._OrtGetLastError = U.Hd)(a, b); + g._OrtCreateSessionOptions = (a, b, c, d, e, f, h, k, l, m) => (g._OrtCreateSessionOptions = U.Id)(a, b, c, d, e, f, h, k, l, m); + g._OrtAppendExecutionProvider = (a, b) => (g._OrtAppendExecutionProvider = U.Jd)(a, b); + g._OrtAddFreeDimensionOverride = (a, b, c) => (g._OrtAddFreeDimensionOverride = U.Kd)(a, b, c); + g._OrtAddSessionConfigEntry = (a, b, c) => (g._OrtAddSessionConfigEntry = U.Ld)(a, b, c); + g._OrtReleaseSessionOptions = (a) => (g._OrtReleaseSessionOptions = U.Md)(a); + g._OrtCreateSession = (a, b, c) => (g._OrtCreateSession = U.Nd)(a, b, c); + g._OrtReleaseSession = (a) => (g._OrtReleaseSession = U.Od)(a); + g._OrtGetInputOutputCount = (a, b, c) => (g._OrtGetInputOutputCount = U.Pd)(a, b, c); + g._OrtGetInputName = (a, b) => (g._OrtGetInputName = U.Qd)(a, b); + g._OrtGetOutputName = (a, b) => (g._OrtGetOutputName = U.Rd)(a, b); + g._OrtFree = (a) => (g._OrtFree = U.Sd)(a); + g._OrtCreateTensor = (a, b, c, d, e, f) => (g._OrtCreateTensor = U.Td)(a, b, c, d, e, f); + g._OrtGetTensorData = (a, b, c, d, e) => (g._OrtGetTensorData = U.Ud)(a, b, c, d, e); + g._OrtReleaseTensor = (a) => (g._OrtReleaseTensor = U.Vd)(a); + g._OrtCreateRunOptions = (a, b, c, d) => (g._OrtCreateRunOptions = U.Wd)(a, b, c, d); + g._OrtAddRunConfigEntry = (a, b, c) => (g._OrtAddRunConfigEntry = U.Xd)(a, b, c); + g._OrtReleaseRunOptions = (a) => (g._OrtReleaseRunOptions = U.Yd)(a); + g._OrtCreateBinding = (a) => (g._OrtCreateBinding = U.Zd)(a); + g._OrtBindInput = (a, b, c) => (g._OrtBindInput = U._d)(a, b, c); + g._OrtBindOutput = (a, b, c, d) => (g._OrtBindOutput = U.$d)(a, b, c, d); + g._OrtClearBoundOutputs = (a) => (g._OrtClearBoundOutputs = U.ae)(a); + g._OrtReleaseBinding = (a) => (g._OrtReleaseBinding = U.be)(a); + g._OrtRunWithBinding = (a, b, c, d, e) => (g._OrtRunWithBinding = U.ce)(a, b, c, d, e); + g._OrtRun = (a, b, c, d, e, f, h, k) => (g._OrtRun = U.de)(a, b, c, d, e, f, h, k); + g._OrtEndProfiling = (a) => (g._OrtEndProfiling = U.ee)(a); + g._JsepOutput = (a, b, c) => (g._JsepOutput = U.fe)(a, b, c); + g._JsepGetNodeName = (a) => (g._JsepGetNodeName = U.ge)(a); + var Jb = g._malloc = (a) => (Jb = g._malloc = U.he)(a), T = g._free = (a) => (T = g._free = U.ie)(a), X = (a, b) => (X = U.ke)(a, b), Ta = (a) => (Ta = U.le)(a), Y = (a) => (Y = U.me)(a), Ef = (a) => (Ef = U.ne)(a), Z = () => (Z = U.oe)(), mc = (a) => (mc = U.pe)(a), kc = (a) => (kc = U.qe)(a), Ua = (a, b, c) => (Ua = U.re)(a, b, c), lc = (a) => (lc = U.se)(a), dynCall_vii = g.dynCall_vii = (a, b, c) => (dynCall_vii = g.dynCall_vii = U.te)(a, b, c), Ff = g.dynCall_iiii = (a, b, c, d) => (Ff = g.dynCall_iiii = U.ue)(a, b, c, d), dynCall_iii = g.dynCall_iii = (a, b, c) => (dynCall_iii = g.dynCall_iii = U.ve)(a, b, c), Gf = g.dynCall_ii = (a, b) => (Gf = g.dynCall_ii = U.we)(a, b), Hf = g.dynCall_iiiiiii = (a, b, c, d, e, f, h) => (Hf = g.dynCall_iiiiiii = U.xe)(a, b, c, d, e, f, h), dynCall_vi = g.dynCall_vi = (a, b) => (dynCall_vi = g.dynCall_vi = U.ye)(a, b), dynCall_v = g.dynCall_v = (a) => (dynCall_v = g.dynCall_v = U.ze)(a), If = g.dynCall_iiiiii = (a, b, c, d, e, f) => (If = g.dynCall_iiiiii = U.Ae)(a, b, c, d, e, f), Jf = g.dynCall_iiij = (a, b, c, d) => (Jf = g.dynCall_iiij = U.Be)(a, b, c, d), Kf = g.dynCall_iiiii = (a, b, c, d, e) => (Kf = g.dynCall_iiiii = U.Ce)(a, b, c, d, e), Lf = g.dynCall_viii = (a, b, c, d) => (Lf = g.dynCall_viii = U.De)(a, b, c, d), Mf = g.dynCall_viiiii = (a, b, c, d, e, f) => (Mf = g.dynCall_viiiii = U.Ee)(a, b, c, d, e, f), Nf = g.dynCall_viiii = (a, b, c, d, e) => (Nf = g.dynCall_viiii = U.Fe)(a, b, c, d, e), Of = g.dynCall_viiiiii = (a, b, c, d, e, f, h) => (Of = g.dynCall_viiiiii = U.Ge)(a, b, c, d, e, f, h), Pf = g.dynCall_viiji = (a, b, c, d, e) => (Pf = g.dynCall_viiji = U.He)(a, b, c, d, e), Qf = g.dynCall_viiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q) => (Qf = g.dynCall_viiiiiiiiiii = U.Ie)(a, b, c, d, e, f, h, k, l, m, n, q), Rf = g.dynCall_viiijjjii = (a, b, c, d, e, f, h, k, l) => (Rf = g.dynCall_viiijjjii = U.Je)(a, b, c, d, e, f, h, k, l), Sf = g.dynCall_iid = (a, b, c) => (Sf = g.dynCall_iid = U.Ke)(a, b, c), Tf = g.dynCall_iif = (a, b, c) => (Tf = g.dynCall_iif = U.Le)(a, b, c), Uf = g.dynCall_iij = (a, b, c) => (Uf = g.dynCall_iij = U.Me)(a, b, c), Vf = g.dynCall_jii = (a, b, c) => (Vf = g.dynCall_jii = U.Ne)(a, b, c), Wf = g.dynCall_i = (a) => (Wf = g.dynCall_i = U.Oe)(a), Xf = g.dynCall_viiiiiiii = (a, b, c, d, e, f, h, k, l) => (Xf = g.dynCall_viiiiiiii = U.Pe)(a, b, c, d, e, f, h, k, l), Yf = g.dynCall_viiiiij = (a, b, c, d, e, f, h) => (Yf = g.dynCall_viiiiij = U.Qe)(a, b, c, d, e, f, h), Zf = g.dynCall_ji = (a, b) => (Zf = g.dynCall_ji = U.Re)(a, b), $f = g.dynCall_viij = (a, b, c, d) => ($f = g.dynCall_viij = U.Se)(a, b, c, d), ag = g.dynCall_iiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q) => (ag = g.dynCall_iiiiiiiiiiii = U.Te)(a, b, c, d, e, f, h, k, l, m, n, q), bg = g.dynCall_viiiiiiiii = (a, b, c, d, e, f, h, k, l, m) => (bg = g.dynCall_viiiiiiiii = U.Ue)(a, b, c, d, e, f, h, k, l, m), cg = g.dynCall_ij = (a, b) => (cg = g.dynCall_ij = U.Ve)(a, b), dg = g.dynCall_iiiiij = (a, b, c, d, e, f) => (dg = g.dynCall_iiiiij = U.We)(a, b, c, d, e, f), eg = g.dynCall_j = (a) => (eg = g.dynCall_j = U.Xe)(a), fg = g.dynCall_vij = (a, b, c) => (fg = g.dynCall_vij = U.Ye)(a, b, c), gg = g.dynCall_viijjjiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q) => (gg = g.dynCall_viijjjiiiiii = U.Ze)(a, b, c, d, e, f, h, k, l, m, n, q), hg = g.dynCall_viiijiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q) => (hg = g.dynCall_viiijiiiiiii = U._e)(a, b, c, d, e, f, h, k, l, m, n, q), ig = g.dynCall_iiiiiiii = (a, b, c, d, e, f, h, k) => (ig = g.dynCall_iiiiiiii = U.$e)(a, b, c, d, e, f, h, k), jg = g.dynCall_viiiiiii = (a, b, c, d, e, f, h, k) => (jg = g.dynCall_viiiiiii = U.af)(a, b, c, d, e, f, h, k), kg = g.dynCall_iiiiiiiij = (a, b, c, d, e, f, h, k, l) => (kg = g.dynCall_iiiiiiiij = U.bf)(a, b, c, d, e, f, h, k, l), lg = g.dynCall_viiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (lg = g.dynCall_viiiiiiiiiiiii = U.cf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), mg = g.dynCall_iiiiiiiii = (a, b, c, d, e, f, h, k, l) => (mg = g.dynCall_iiiiiiiii = U.df)(a, b, c, d, e, f, h, k, l), ng = g.dynCall_iiiiijiiiii = (a, b, c, d, e, f, h, k, l, m, n) => (ng = g.dynCall_iiiiijiiiii = U.ef)(a, b, c, d, e, f, h, k, l, m, n), og = g.dynCall_vijjjiiij = (a, b, c, d, e, f, h, k, l) => (og = g.dynCall_vijjjiiij = U.ff)(a, b, c, d, e, f, h, k, l), pg = g.dynCall_fi = (a, b) => (pg = g.dynCall_fi = U.gf)(a, b), qg = g.dynCall_fii = (a, b, c) => (qg = g.dynCall_fii = U.hf)(a, b, c), rg = g.dynCall_di = (a, b) => (rg = g.dynCall_di = U.jf)(a, b), sg = g.dynCall_dii = (a, b, c) => (sg = g.dynCall_dii = U.kf)(a, b, c), tg = g.dynCall_vijj = (a, b, c, d) => (tg = g.dynCall_vijj = U.lf)(a, b, c, d), ug = g.dynCall_iiiiiiiiii = (a, b, c, d, e, f, h, k, l, m) => (ug = g.dynCall_iiiiiiiiii = U.mf)(a, b, c, d, e, f, h, k, l, m), vg = g.dynCall_viijiii = (a, b, c, d, e, f, h) => (vg = g.dynCall_viijiii = U.nf)(a, b, c, d, e, f, h), wg = g.dynCall_viid = (a, b, c, d) => (wg = g.dynCall_viid = U.of)(a, b, c, d), xg = g.dynCall_viffiii = (a, b, c, d, e, f, h) => (xg = g.dynCall_viffiii = U.pf)(a, b, c, d, e, f, h), yg = g.dynCall_viifiii = (a, b, c, d, e, f, h) => (yg = g.dynCall_viifiii = U.qf)(a, b, c, d, e, f, h), zg = g.dynCall_viiiiidiidi = (a, b, c, d, e, f, h, k, l, m, n) => (zg = g.dynCall_viiiiidiidi = U.rf)(a, b, c, d, e, f, h, k, l, m, n), Ag = g.dynCall_viiiiiiiiidi = (a, b, c, d, e, f, h, k, l, m, n, q) => (Ag = g.dynCall_viiiiiiiiidi = U.sf)(a, b, c, d, e, f, h, k, l, m, n, q), Bg = g.dynCall_jiii = (a, b, c, d) => (Bg = g.dynCall_jiii = U.tf)(a, b, c, d), Cg = g.dynCall_vjiiiiii = (a, b, c, d, e, f, h, k) => (Cg = g.dynCall_vjiiiiii = U.uf)(a, b, c, d, e, f, h, k), Dg = g.dynCall_viiid = (a, b, c, d, e) => (Dg = g.dynCall_viiid = U.vf)(a, b, c, d, e), Eg = g.dynCall_viiiiiiiiiji = (a, b, c, d, e, f, h, k, l, m, n, q) => (Eg = g.dynCall_viiiiiiiiiji = U.wf)(a, b, c, d, e, f, h, k, l, m, n, q), Fg = g.dynCall_viji = (a, b, c, d) => (Fg = g.dynCall_viji = U.xf)(a, b, c, d), Gg = g.dynCall_vijjjjjjjjjjjjji = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => (Gg = g.dynCall_vijjjjjjjjjjjjji = U.yf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y), Hg = g.dynCall_viiiji = (a, b, c, d, e, f) => (Hg = g.dynCall_viiiji = U.zf)(a, b, c, d, e, f), Ig = g.dynCall_vijjjiiji = (a, b, c, d, e, f, h, k, l) => (Ig = g.dynCall_vijjjiiji = U.Af)(a, b, c, d, e, f, h, k, l), Jg = g.dynCall_iiiji = (a, b, c, d, e) => (Jg = g.dynCall_iiiji = U.Bf)(a, b, c, d, e), Kg = g.dynCall_iiijiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (Kg = g.dynCall_iiijiiiiiiiiii = U.Cf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), Lg = g.dynCall_vj = (a, b) => (Lg = g.dynCall_vj = U.Df)(a, b), Mg = g.dynCall_jjj = (a, b, c) => (Mg = g.dynCall_jjj = U.Ef)(a, b, c), Ng = g.dynCall_iiijiiiiii = (a, b, c, d, e, f, h, k, l, m) => (Ng = g.dynCall_iiijiiiiii = U.Ff)(a, b, c, d, e, f, h, k, l, m), Og = g.dynCall_vfiii = (a, b, c, d, e) => (Og = g.dynCall_vfiii = U.Gf)(a, b, c, d, e), Pg = g.dynCall_viiiiff = (a, b, c, d, e, f, h) => (Pg = g.dynCall_viiiiff = U.Hf)(a, b, c, d, e, f, h), Qg = g.dynCall_viiiiiff = (a, b, c, d, e, f, h, k) => (Qg = g.dynCall_viiiiiff = U.If)(a, b, c, d, e, f, h, k), Rg = g.dynCall_viiff = (a, b, c, d, e) => (Rg = g.dynCall_viiff = U.Jf)(a, b, c, d, e), Sg = g.dynCall_viiiiiiiiifiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (Sg = g.dynCall_viiiiiiiiifiii = U.Kf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), Tg = g.dynCall_viiiiiiiijj = (a, b, c, d, e, f, h, k, l, m, n) => (Tg = g.dynCall_viiiiiiiijj = U.Lf)(a, b, c, d, e, f, h, k, l, m, n), Ug = g.dynCall_iiiiiiiiiiiiiifii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) => (Ug = g.dynCall_iiiiiiiiiiiiiifii = U.Mf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A), Vg = g.dynCall_viiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Vg = g.dynCall_viiiiiiiiiiii = U.Nf)(a, b, c, d, e, f, h, k, l, m, n, q, r), Wg = g.dynCall_iiiiiiiiiiiiiiiiifii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) => (Wg = g.dynCall_iiiiiiiiiiiiiiiiifii = U.Of)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D), Xg = g.dynCall_vijjiiiiii = (a, b, c, d, e, f, h, k, l, m) => (Xg = g.dynCall_vijjiiiiii = U.Pf)(a, b, c, d, e, f, h, k, l, m), Yg = g.dynCall_iiiijjj = (a, b, c, d, e, f, h) => (Yg = g.dynCall_iiiijjj = U.Qf)(a, b, c, d, e, f, h), Zg = g.dynCall_viiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n) => (Zg = g.dynCall_viiiiiiiiii = U.Rf)(a, b, c, d, e, f, h, k, l, m, n), $g = g.dynCall_iiijjj = (a, b, c, d, e, f) => ($g = g.dynCall_iiijjj = U.Sf)(a, b, c, d, e, f), ah = g.dynCall_fffffff = (a, b, c, d, e, f, h) => (ah = g.dynCall_fffffff = U.Tf)(a, b, c, d, e, f, h), bh = g.dynCall_viiiij = (a, b, c, d, e, f) => (bh = g.dynCall_viiiij = U.Uf)(a, b, c, d, e, f), ch = g.dynCall_viiiiiijiifiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (ch = g.dynCall_viiiiiijiifiii = U.Vf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), dh = g.dynCall_vjjjjjjffjifiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B) => (dh = g.dynCall_vjjjjjjffjifiiiiii = U.Wf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B), eh = g.dynCall_viiiiiiffjifiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) => (eh = g.dynCall_viiiiiiffjifiiiii = U.Xf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A), fh = g.dynCall_viiiiiiffjfiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => (fh = g.dynCall_viiiiiiffjfiiiii = U.Yf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y), gh = g.dynCall_viiiiiiffjiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => (gh = g.dynCall_viiiiiiffjiiiii = U.Zf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u), hh = g.dynCall_vjjjjjjjjfffiiifiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) => (hh = g.dynCall_vjjjjjjjjfffiiifiiiii = U._f)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F), ih = g.dynCall_vjjjjjjfffifijiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C) => (ih = g.dynCall_vjjjjjjfffifijiiiii = U.$f)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C), jh = g.dynCall_vjjjjjjfffifiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B) => (jh = g.dynCall_vjjjjjjfffifiiiiii = U.ag)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B), kh = g.dynCall_vjjjjjjjjfffjifiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) => (kh = g.dynCall_vjjjjjjjjfffjifiiiiii = U.bg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F), lh = g.dynCall_vijiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (lh = g.dynCall_vijiiiiiiiiii = U.cg)(a, b, c, d, e, f, h, k, l, m, n, q, r), mh = g.dynCall_vijjfffiii = (a, b, c, d, e, f, h, k, l, m) => (mh = g.dynCall_vijjfffiii = U.dg)(a, b, c, d, e, f, h, k, l, m), nh = g.dynCall_viiiiiiijiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (nh = g.dynCall_viiiiiiijiiii = U.eg)(a, b, c, d, e, f, h, k, l, m, n, q, r), oh = g.dynCall_vijjjjjjifiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => (oh = g.dynCall_vijjjjjjifiiiii = U.fg)( + a, + b, + c, + d, + e, + f, + h, + k, + l, + m, + n, + q, + r, + p, + u + ), ph = g.dynCall_viifi = (a, b, c, d, e) => (ph = g.dynCall_viifi = U.gg)(a, b, c, d, e), qh = g.dynCall_vjjjjjiiii = (a, b, c, d, e, f, h, k, l, m) => (qh = g.dynCall_vjjjjjiiii = U.hg)(a, b, c, d, e, f, h, k, l, m), rh = g.dynCall_vjjjjfiii = (a, b, c, d, e, f, h, k, l) => (rh = g.dynCall_vjjjjfiii = U.ig)(a, b, c, d, e, f, h, k, l), sh = g.dynCall_viiiiiijiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (sh = g.dynCall_viiiiiijiiiiii = U.jg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), th = g.dynCall_vijjii = (a, b, c, d, e, f) => (th = g.dynCall_vijjii = U.kg)(a, b, c, d, e, f), uh = g.dynCall_viiiiijjiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (uh = g.dynCall_viiiiijjiiiii = U.lg)(a, b, c, d, e, f, h, k, l, m, n, q, r), vh = g.dynCall_iiiiiji = (a, b, c, d, e, f, h) => (vh = g.dynCall_iiiiiji = U.mg)(a, b, c, d, e, f, h), wh = g.dynCall_iiiiji = (a, b, c, d, e, f) => (wh = g.dynCall_iiiiji = U.ng)(a, b, c, d, e, f), xh = g.dynCall_viiiiijiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (xh = g.dynCall_viiiiijiiiiii = U.og)(a, b, c, d, e, f, h, k, l, m, n, q, r), yh = g.dynCall_viiijiiiiii = (a, b, c, d, e, f, h, k, l, m, n) => (yh = g.dynCall_viiijiiiiii = U.pg)(a, b, c, d, e, f, h, k, l, m, n), zh = g.dynCall_viijj = (a, b, c, d, e) => (zh = g.dynCall_viijj = U.qg)(a, b, c, d, e), Ah = g.dynCall_viiiijii = (a, b, c, d, e, f, h, k) => (Ah = g.dynCall_viiiijii = U.rg)(a, b, c, d, e, f, h, k), Bh = g.dynCall_viijjiii = (a, b, c, d, e, f, h, k) => (Bh = g.dynCall_viijjiii = U.sg)(a, b, c, d, e, f, h, k), Ch = g.dynCall_ijii = (a, b, c, d) => (Ch = g.dynCall_ijii = U.tg)(a, b, c, d), Dh = g.dynCall_viiiiijjji = (a, b, c, d, e, f, h, k, l, m) => (Dh = g.dynCall_viiiiijjji = U.ug)(a, b, c, d, e, f, h, k, l, m), Eh = g.dynCall_vijjjjiij = (a, b, c, d, e, f, h, k, l) => (Eh = g.dynCall_vijjjjiij = U.vg)(a, b, c, d, e, f, h, k, l), Fh = g.dynCall_viiiiijij = (a, b, c, d, e, f, h, k, l) => (Fh = g.dynCall_viiiiijij = U.wg)(a, b, c, d, e, f, h, k, l), Gh = g.dynCall_viiiiiijij = (a, b, c, d, e, f, h, k, l, m) => (Gh = g.dynCall_viiiiiijij = U.xg)(a, b, c, d, e, f, h, k, l, m), Hh = g.dynCall_vijiii = (a, b, c, d, e, f) => (Hh = g.dynCall_vijiii = U.yg)(a, b, c, d, e, f), Ih = g.dynCall_viiiiiiiiifi = (a, b, c, d, e, f, h, k, l, m, n, q) => (Ih = g.dynCall_viiiiiiiiifi = U.zg)(a, b, c, d, e, f, h, k, l, m, n, q), Jh = g.dynCall_iiijiiii = (a, b, c, d, e, f, h, k) => (Jh = g.dynCall_iiijiiii = U.Ag)(a, b, c, d, e, f, h, k), Kh = g.dynCall_viiiiiijjiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (Kh = g.dynCall_viiiiiijjiiiii = U.Bg)( + a, + b, + c, + d, + e, + f, + h, + k, + l, + m, + n, + q, + r, + p + ), Lh = g.dynCall_viiiiiiijiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => (Lh = g.dynCall_viiiiiiijiiiiii = U.Cg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u), Mh = g.dynCall_vif = (a, b, c) => (Mh = g.dynCall_vif = U.Dg)(a, b, c), Nh = g.dynCall_viif = (a, b, c, d) => (Nh = g.dynCall_viif = U.Eg)(a, b, c, d), Oh = g.dynCall_fiii = (a, b, c, d) => (Oh = g.dynCall_fiii = U.Fg)(a, b, c, d), Ph = g.dynCall_diii = (a, b, c, d) => (Ph = g.dynCall_diii = U.Gg)(a, b, c, d), Qh = g.dynCall_viiiiiifii = (a, b, c, d, e, f, h, k, l, m) => (Qh = g.dynCall_viiiiiifii = U.Hg)(a, b, c, d, e, f, h, k, l, m), Rh = g.dynCall_viiiiijiiiiiiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F, H, K, Va, Wa, Xa) => (Rh = g.dynCall_viiiiijiiiiiiiiiiiiiiiiiii = U.Ig)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F, H, K, Va, Wa, Xa), Sh = g.dynCall_viijji = (a, b, c, d, e, f) => (Sh = g.dynCall_viijji = U.Jg)(a, b, c, d, e, f), Th = g.dynCall_iiiiiiiiiiiji = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Th = g.dynCall_iiiiiiiiiiiji = U.Kg)(a, b, c, d, e, f, h, k, l, m, n, q, r), Uh = g.dynCall_viifiifijjjii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Uh = g.dynCall_viifiifijjjii = U.Lg)(a, b, c, d, e, f, h, k, l, m, n, q, r), Vh = g.dynCall_viiiiiiiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) => (Vh = g.dynCall_viiiiiiiiiiiiiiiiiiii = U.Mg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F), Wh = g.dynCall_viiiiifiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Wh = g.dynCall_viiiiifiiiiii = U.Ng)(a, b, c, d, e, f, h, k, l, m, n, q, r), Xh = g.dynCall_vijiiiiiiijjii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (Xh = g.dynCall_vijiiiiiiijjii = U.Og)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), Yh = g.dynCall_viiiiiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C) => (Yh = g.dynCall_viiiiiiiiiiiiiiiiii = U.Pg)( + a, + b, + c, + d, + e, + f, + h, + k, + l, + m, + n, + q, + r, + p, + u, + y, + A, + B, + C + ), Zh = g.dynCall_viiiiiiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) => (Zh = g.dynCall_viiiiiiiiiiiiiiiiiii = U.Qg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D), $h = g.dynCall_viiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => ($h = g.dynCall_viiiiiiiiiiiiiii = U.Rg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y), ai = g.dynCall_viiiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) => (ai = g.dynCall_viiiiiiiiiiiiiiii = U.Sg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A), bi = g.dynCall_viiiijjj = (a, b, c, d, e, f, h, k) => (bi = g.dynCall_viiiijjj = U.Tg)(a, b, c, d, e, f, h, k), ci = g.dynCall_iiiiid = (a, b, c, d, e, f) => (ci = g.dynCall_iiiiid = U.Ug)(a, b, c, d, e, f), di = g.dynCall_viiiiiiijjj = (a, b, c, d, e, f, h, k, l, m, n) => (di = g.dynCall_viiiiiiijjj = U.Vg)(a, b, c, d, e, f, h, k, l, m, n), ei = g.dynCall_iiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n) => (ei = g.dynCall_iiiiiiiiiii = U.Wg)(a, b, c, d, e, f, h, k, l, m, n), fi = g.dynCall_iiiiiiiiiiiiiiiiiifi = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) => (fi = g.dynCall_iiiiiiiiiiiiiiiiiifi = U.Xg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D), gi = g.dynCall_viiif = (a, b, c, d, e) => (gi = g.dynCall_viiif = U.Yg)(a, b, c, d, e), hi = g.dynCall_viiijiiiii = (a, b, c, d, e, f, h, k, l, m) => (hi = g.dynCall_viiijiiiii = U.Zg)(a, b, c, d, e, f, h, k, l, m), ii = g.dynCall_viiij = (a, b, c, d, e) => (ii = g.dynCall_viiij = U._g)(a, b, c, d, e), ji = g.dynCall_iijjj = (a, b, c, d, e) => (ji = g.dynCall_iijjj = U.$g)(a, b, c, d, e), ki = g.dynCall_viiiiji = (a, b, c, d, e, f, h) => (ki = g.dynCall_viiiiji = U.ah)(a, b, c, d, e, f, h), li = g.dynCall_iijjji = (a, b, c, d, e, f) => (li = g.dynCall_iijjji = U.bh)(a, b, c, d, e, f), mi = g.dynCall_ijijji = (a, b, c, d, e, f) => (mi = g.dynCall_ijijji = U.ch)( + a, + b, + c, + d, + e, + f + ), ni = g.dynCall_viiijjiii = (a, b, c, d, e, f, h, k, l) => (ni = g.dynCall_viiijjiii = U.dh)(a, b, c, d, e, f, h, k, l), oi = g.dynCall_iiiiijji = (a, b, c, d, e, f, h, k) => (oi = g.dynCall_iiiiijji = U.eh)(a, b, c, d, e, f, h, k), pi = g.dynCall_iiiifi = (a, b, c, d, e, f) => (pi = g.dynCall_iiiifi = U.fh)(a, b, c, d, e, f), qi = g.dynCall_iiijii = (a, b, c, d, e, f) => (qi = g.dynCall_iiijii = U.gh)(a, b, c, d, e, f), ri = g.dynCall_iiiiiiiiijii = (a, b, c, d, e, f, h, k, l, m, n, q) => (ri = g.dynCall_iiiiiiiiijii = U.hh)(a, b, c, d, e, f, h, k, l, m, n, q), si = g.dynCall_iiiijjii = (a, b, c, d, e, f, h, k) => (si = g.dynCall_iiiijjii = U.ih)(a, b, c, d, e, f, h, k), ti = g.dynCall_iiiiiijjjii = (a, b, c, d, e, f, h, k, l, m, n) => (ti = g.dynCall_iiiiiijjjii = U.jh)(a, b, c, d, e, f, h, k, l, m, n), ui = g.dynCall_iiijiii = (a, b, c, d, e, f, h) => (ui = g.dynCall_iiijiii = U.kh)(a, b, c, d, e, f, h), vi = g.dynCall_iiiiiiiijjjfi = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (vi = g.dynCall_iiiiiiiijjjfi = U.lh)(a, b, c, d, e, f, h, k, l, m, n, q, r), wi = g.dynCall_iijiiii = (a, b, c, d, e, f, h) => (wi = g.dynCall_iijiiii = U.mh)(a, b, c, d, e, f, h), xi = g.dynCall_iijjjii = (a, b, c, d, e, f, h) => (xi = g.dynCall_iijjjii = U.nh)(a, b, c, d, e, f, h), yi = g.dynCall_jij = (a, b, c) => (yi = g.dynCall_jij = U.oh)(a, b, c), zi = g.dynCall_iiji = (a, b, c, d) => (zi = g.dynCall_iiji = U.ph)(a, b, c, d), Ai = g.dynCall_iiif = (a, b, c, d) => (Ai = g.dynCall_iiif = U.qh)(a, b, c, d), Bi = g.dynCall_vidi = (a, b, c, d) => (Bi = g.dynCall_vidi = U.rh)(a, b, c, d), Ci = g.dynCall_vjiii = (a, b, c, d, e) => (Ci = g.dynCall_vjiii = U.sh)(a, b, c, d, e), Di = g.dynCall_diiii = (a, b, c, d, e) => (Di = g.dynCall_diiii = U.th)(a, b, c, d, e), Ei = g.dynCall_diiiii = (a, b, c, d, e, f) => (Ei = g.dynCall_diiiii = U.uh)(a, b, c, d, e, f), Fi = g.dynCall_viiijjiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q) => (Fi = g.dynCall_viiijjiiiiii = U.vh)(a, b, c, d, e, f, h, k, l, m, n, q), Gi = g.dynCall_viijjijjjjiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Gi = g.dynCall_viijjijjjjiii = U.wh)(a, b, c, d, e, f, h, k, l, m, n, q, r), Hi = g.dynCall_iiiij = (a, b, c, d, e) => (Hi = g.dynCall_iiiij = U.xh)(a, b, c, d, e), Ii = g.dynCall_viiijii = (a, b, c, d, e, f, h) => (Ii = g.dynCall_viiijii = U.yh)(a, b, c, d, e, f, h), Ji = g.dynCall_viijiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Ji = g.dynCall_viijiiiiiiiii = U.zh)(a, b, c, d, e, f, h, k, l, m, n, q, r), Ki = g.dynCall_fiiii = (a, b, c, d, e) => (Ki = g.dynCall_fiiii = U.Ah)(a, b, c, d, e), Li = g.dynCall_jfi = (a, b, c) => (Li = g.dynCall_jfi = U.Bh)(a, b, c), Mi = g.dynCall_viiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => (Mi = g.dynCall_viiiiiiiiiiiiii = U.Ch)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u), Ni = g.dynCall_jiij = (a, b, c, d) => (Ni = g.dynCall_jiij = U.Dh)(a, b, c, d), Mb = (a) => (Mb = U.Eh)(a), Bb = () => (Bb = U.Fh)(), Lb = (a) => (Lb = U.Gh)(a), Nb = () => (Nb = U.Hh)(); + g.___start_em_js = 1275044; + g.___stop_em_js = 1275205; + function Dc(a, b, c, d) { + var e = Z(); + try { + return Ff(a, b, c, d); + } catch (f) { + Y(e); + if (f !== f + 0) + throw f; + X(1, 0); + } + } + function Bc(a, b, c) { + var d = Z(); + try { + return dynCall_iii(a, b, c); + } catch (e) { + Y(d); + if (e !== e + 0) + throw e; + X(1, 0); + } + } + function Jd(a, b, c) { + var d = Z(); + try { + dynCall_vii(a, b, c); + } catch (e) { + Y(d); + if (e !== e + 0) + throw e; + X(1, 0); + } + } + function yc(a, b) { + var c = Z(); + try { + return Gf(a, b); + } catch (d) { + Y(c); + if (d !== d + 0) + throw d; + X(1, 0); + } + } + function Fd(a, b) { + var c = Z(); + try { + dynCall_vi(a, b); + } catch (d) { + Y(c); + if (d !== d + 0) + throw d; + X(1, 0); + } + } + function dd(a, b, c, d) { + var e = Z(); + try { + return Jf(a, b, c, d); + } catch (f) { + Y(e); + if (f !== f + 0) + throw f; + X(1, 0); + } + } + function Dd(a) { + var b = Z(); + try { + dynCall_v(a); + } catch (c) { + Y(b); + if (c !== c + 0) + throw c; + X(1, 0); + } + } + function Ic(a, b, c, d, e, f, h) { + var k = Z(); + try { + return Hf(a, b, c, d, e, f, h); + } catch (l) { + Y(k); + if (l !== l + 0) + throw l; + X(1, 0); + } + } + function Hc(a, b, c, d, e, f) { + var h = Z(); + try { + return If(a, b, c, d, e, f); + } catch (k) { + Y(h); + if (k !== k + 0) + throw k; + X(1, 0); + } + } + function Fc(a, b, c, d, e) { + var f = Z(); + try { + return Kf(a, b, c, d, e); + } catch (h) { + Y(f); + if (h !== h + 0) + throw h; + X(1, 0); + } + } + function Qd(a, b, c, d) { + var e = Z(); + try { + Lf(a, b, c, d); + } catch (f) { + Y(e); + if (f !== f + 0) + throw f; + X(1, 0); + } + } + function Td(a, b, c, d, e) { + var f = Z(); + try { + Nf(a, b, c, d, e); + } catch (h) { + Y(f); + if (h !== h + 0) + throw h; + X(1, 0); + } + } + function Vd(a, b, c, d, e, f) { + var h = Z(); + try { + Mf(a, b, c, d, e, f); + } catch (k) { + Y(h); + if (k !== k + 0) + throw k; + X(1, 0); + } + } + function Zd(a, b, c, d, e, f, h) { + var k = Z(); + try { + Of(a, b, c, d, e, f, h); + } catch (l) { + Y(k); + if (l !== l + 0) + throw l; + X(1, 0); + } + } + function ke(a, b, c, d, e, f, h, k, l, m, n, q) { + var r = Z(); + try { + Qf(a, b, c, d, e, f, h, k, l, m, n, q); + } catch (p) { + Y(r); + if (p !== p + 0) + throw p; + X(1, 0); + } + } + function zc(a, b, c) { + var d = Z(); + try { + return Sf(a, b, c); + } catch (e) { + Y(d); + if (e !== e + 0) + throw e; + X(1, 0); + } + } + function Ac(a, b, c) { + var d = Z(); + try { + return Tf(a, b, c); + } catch (e) { + Y(d); + if (e !== e + 0) + throw e; + X(1, 0); + } + } + function md(a, b, c) { + var d = Z(); + try { + return Uf(a, b, c); + } catch (e) { + Y(d); + if (e !== e + 0) + throw e; + X(1, 0); + } + } + function yd(a, b, c) { + var d = Z(); + try { + return Vf(a, b, c); + } catch (e) { + Y(d); + if (e !== e + 0) + throw e; + X(1, 0); + return 0n; + } + } + function ee(a, b, c, d, e, f, h, k, l) { + var m = Z(); + try { + Xf(a, b, c, d, e, f, h, k, l); + } catch (n) { + Y(m); + if (n !== n + 0) + throw n; + X(1, 0); + } + } + function xc(a) { + var b = Z(); + try { + return Wf(a); + } catch (c) { + Y(b); + if (c !== c + 0) + throw c; + X(1, 0); + } + } + function df(a, b, c) { + var d = Z(); + try { + fg(a, b, c); + } catch (e) { + Y(d); + if (e !== e + 0) + throw e; + X(1, 0); + } + } + function We(a, b, c, d, e) { + var f = Z(); + try { + Pf(a, b, c, d, e); + } catch (h) { + Y(f); + if (h !== h + 0) + throw h; + X(1, 0); + } + } + function Ce(a, b, c, d, e, f, h) { + var k = Z(); + try { + Yf(a, b, c, d, e, f, h); + } catch (l) { + Y(k); + if (l !== l + 0) + throw l; + X(1, 0); + } + } + function cf(a, b, c, d, e, f, h, k, l, m, n, q) { + var r = Z(); + try { + gg(a, b, c, d, e, f, h, k, l, m, n, q); + } catch (p) { + Y(r); + if (p !== p + 0) + throw p; + X(1, 0); + } + } + function Re(a, b, c, d, e, f, h, k, l, m, n, q) { + var r = Z(); + try { + hg(a, b, c, d, e, f, h, k, l, m, n, q); + } catch (p) { + Y(r); + if (p !== p + 0) + throw p; + X(1, 0); + } + } + function Jc(a, b, c, d, e, f, h, k) { + var l = Z(); + try { + return ig(a, b, c, d, e, f, h, k); + } catch (m) { + Y(l); + if (m !== m + 0) + throw m; + X(1, 0); + } + } + function de(a, b, c, d, e, f, h, k) { + var l = Z(); + try { + jg(a, b, c, d, e, f, h, k); + } catch (m) { + Y(l); + if (m !== m + 0) + throw m; + X(1, 0); + } + } + function Nc(a, b, c, d, e, f, h, k, l, m, n, q) { + var r = Z(); + try { + return ag(a, b, c, d, e, f, h, k, l, m, n, q); + } catch (p) { + Y(r); + if (p !== p + 0) + throw p; + X(1, 0); + } + } + function fe(a, b, c, d, e, f, h, k, l, m) { + var n = Z(); + try { + bg(a, b, c, d, e, f, h, k, l, m); + } catch (q) { + Y(n); + if (q !== q + 0) + throw q; + X(1, 0); + } + } + function me(a, b, c, d, e, f, h, k, l, m, n, q, r, p) { + var u = Z(); + try { + lg(a, b, c, d, e, f, h, k, l, m, n, q, r, p); + } catch (y) { + Y(u); + if (y !== y + 0) + throw y; + X(1, 0); + } + } + function Yc(a, b, c, d, e, f, h, k, l, m, n) { + var q = Z(); + try { + return ng(a, b, c, d, e, f, h, k, l, m, n); + } catch (r) { + Y(q); + if (r !== r + 0) + throw r; + X(1, 0); + } + } + function Kc(a, b, c, d, e, f, h, k, l) { + var m = Z(); + try { + return mg(a, b, c, d, e, f, h, k, l); + } catch (n) { + Y(m); + if (n !== n + 0) + throw n; + X(1, 0); + } + } + function nf(a, b, c, d, e, f, h, k, l) { + var m = Z(); + try { + og(a, b, c, d, e, f, h, k, l); + } catch (n) { + Y(m); + if (n !== n + 0) + throw n; + X(1, 0); + } + } + function Ve(a, b, c, d) { + var e = Z(); + try { + $f(a, b, c, d); + } catch (f) { + Y(e); + if (f !== f + 0) + throw f; + X(1, 0); + } + } + function tc(a, b) { + var c = Z(); + try { + return pg(a, b); + } catch (d) { + Y(c); + if (d !== d + 0) + throw d; + X(1, 0); + } + } + function xd(a, b) { + var c = Z(); + try { + return Zf(a, b); + } catch (d) { + Y(c); + if (d !== d + 0) + throw d; + X(1, 0); + return 0n; + } + } + function nc(a, b) { + var c = Z(); + try { + return rg(a, b); + } catch (d) { + Y(c); + if (d !== d + 0) + throw d; + X(1, 0); + } + } + function jf(a, b, c, d) { + var e = Z(); + try { + tg(a, b, c, d); + } catch (f) { + Y(e); + if (f !== f + 0) + throw f; + X(1, 0); + } + } + function Oe(a, b, c, d, e, f, h) { + var k = Z(); + try { + Ii(a, b, c, d, e, f, h); + } catch (l) { + Y(k); + if (l !== l + 0) + throw l; + X(1, 0); + } + } + function Ze(a, b, c, d, e) { + var f = Z(); + try { + zh(a, b, c, d, e); + } catch (h) { + Y(f); + if (h !== h + 0) + throw h; + X(1, 0); + } + } + function Lc(a, b, c, d, e, f, h, k, l, m) { + var n = Z(); + try { + return ug(a, b, c, d, e, f, h, k, l, m); + } catch (q) { + Y(n); + if (q !== q + 0) + throw q; + X(1, 0); + } + } + function Xe(a, b, c, d, e, f, h) { + var k = Z(); + try { + vg(a, b, c, d, e, f, h); + } catch (l) { + Y(k); + if (l !== l + 0) + throw l; + X(1, 0); + } + } + function Kd(a, b, c, d) { + var e = Z(); + try { + wg(a, b, c, d); + } catch (f) { + Y(e); + if (f !== f + 0) + throw f; + X(1, 0); + } + } + function Tc(a, b, c, d, e, f, h, k, l) { + var m = Z(); + try { + return kg(a, b, c, d, e, f, h, k, l); + } catch (n) { + Y(m); + if (n !== n + 0) + throw n; + X(1, 0); + } + } + function Id(a, b, c, d, e, f, h) { + var k = Z(); + try { + xg(a, b, c, d, e, f, h); + } catch (l) { + Y(k); + if (l !== l + 0) + throw l; + X(1, 0); + } + } + function Ue(a, b, c, d, e, f, h, k, l) { + var m = Z(); + try { + Rf(a, b, c, d, e, f, h, k, l); + } catch (n) { + Y(m); + if (n !== n + 0) + throw n; + X(1, 0); + } + } + function Pd(a, b, c, d, e, f, h) { + var k = Z(); + try { + yg(a, b, c, d, e, f, h); + } catch (l) { + Y(k); + if (l !== l + 0) + throw l; + X(1, 0); + } + } + function Wd(a, b, c, d, e, f, h, k, l, m, n) { + var q = Z(); + try { + zg(a, b, c, d, e, f, h, k, l, m, n); + } catch (r) { + Y(q); + if (r !== r + 0) + throw r; + X(1, 0); + } + } + function zd(a, b, c, d) { + var e = Z(); + try { + return Bg(a, b, c, d); + } catch (f) { + Y(e); + if (f !== f + 0) + throw f; + X(1, 0); + return 0n; + } + } + function uf(a, b, c, d, e, f, h, k) { + var l = Z(); + try { + Cg(a, b, c, d, e, f, h, k); + } catch (m) { + Y(l); + if (m !== m + 0) + throw m; + X(1, 0); + } + } + function Rd(a, b, c, d, e) { + var f = Z(); + try { + Dg(a, b, c, d, e); + } catch (h) { + Y(f); + if (h !== h + 0) + throw h; + X(1, 0); + } + } + function ef(a, b, c, d) { + var e = Z(); + try { + Fg(a, b, c, d); + } catch (f) { + Y(e); + if (f !== f + 0) + throw f; + X(1, 0); + } + } + function rf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) { + var A = Z(); + try { + Gg(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y); + } catch (B) { + Y(A); + if (B !== B + 0) + throw B; + X(1, 0); + } + } + function Ne(a, b, c, d, e, f) { + var h = Z(); + try { + Hg(a, b, c, d, e, f); + } catch (k) { + Y(h); + if (k !== k + 0) + throw k; + X(1, 0); + } + } + function of(a, b, c, d, e, f, h, k, l) { + var m = Z(); + try { + Ig(a, b, c, d, e, f, h, k, l); + } catch (n) { + Y(m); + if (n !== n + 0) + throw n; + X(1, 0); + } + } + function ed(a, b, c, d, e) { + var f = Z(); + try { + return Jg(a, b, c, d, e); + } catch (h) { + Y(f); + if (h !== h + 0) + throw h; + X(1, 0); + } + } + function kd(a, b, c, d, e, f, h, k, l, m, n, q, r, p) { + var u = Z(); + try { + return Kg(a, b, c, d, e, f, h, k, l, m, n, q, r, p); + } catch (y) { + Y(u); + if (y !== y + 0) + throw y; + X(1, 0); + } + } + function sf(a, b) { + var c = Z(); + try { + Lg(a, b); + } catch (d) { + Y(c); + if (d !== d + 0) + throw d; + X(1, 0); + } + } + function Cd(a, b, c) { + var d = Z(); + try { + return Mg(a, b, c); + } catch (e) { + Y(d); + if (e !== e + 0) + throw e; + X(1, 0); + return 0n; + } + } + function jd(a, b, c, d, e, f, h, k, l, m) { + var n = Z(); + try { + return Ng(a, b, c, d, e, f, h, k, l, m); + } catch (q) { + Y(n); + if (q !== q + 0) + throw q; + X(1, 0); + } + } + function ie(a, b, c, d, e, f, h, k, l, m, n, q, r, p) { + var u = Z(); + try { + Sg(a, b, c, d, e, f, h, k, l, m, n, q, r, p); + } catch (y) { + Y(u); + if (y !== y + 0) + throw y; + X(1, 0); + } + } + function Ed(a, b, c, d, e) { + var f = Z(); + try { + Og(a, b, c, d, e); + } catch (h) { + Y(f); + if (h !== h + 0) + throw h; + X(1, 0); + } + } + function Ud(a, b, c, d, e, f, h) { + var k = Z(); + try { + Pg(a, b, c, d, e, f, h); + } catch (l) { + Y(k); + if (l !== l + 0) + throw l; + X(1, 0); + } + } + function Md(a, b, c, d, e) { + var f = Z(); + try { + Rg(a, b, c, d, e); + } catch (h) { + Y(f); + if (h !== h + 0) + throw h; + X(1, 0); + } + } + function Xd(a, b, c, d, e, f, h, k) { + var l = Z(); + try { + Qg(a, b, c, d, e, f, h, k); + } catch (m) { + Y(l); + if (m !== m + 0) + throw m; + X(1, 0); + } + } + function ue(a, b, c, d, e, f, h, k, l, m, n) { + var q = Z(); + try { + Tg(a, b, c, d, e, f, h, k, l, m, n); + } catch (r) { + Y(q); + if (r !== r + 0) + throw r; + X(1, 0); + } + } + function Oc(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) { + var B = Z(); + try { + return Ug(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A); + } catch (C) { + Y(B); + if (C !== C + 0) + throw C; + X(1, 0); + } + } + function le(a, b, c, d, e, f, h, k, l, m, n, q, r) { + var p = Z(); + try { + Vg(a, b, c, d, e, f, h, k, l, m, n, q, r); + } catch (u) { + Y(p); + if (u !== u + 0) + throw u; + X(1, 0); + } + } + function sd(a, b) { + var c = Z(); + try { + return cg(a, b); + } catch (d) { + Y(c); + if (d !== d + 0) + throw d; + X(1, 0); + } + } + function wc(a, b, c, d, e) { + var f = Z(); + try { + return Ki(a, b, c, d, e); + } catch (h) { + Y(f); + if (h !== h + 0) + throw h; + X(1, 0); + } + } + function Pc(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) { + var F = Z(); + try { + return Wg(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D); + } catch (H) { + Y(F); + if (H !== H + 0) + throw H; + X(1, 0); + } + } + function mf(a, b, c, d, e, f, h, k, l, m) { + var n = Z(); + try { + Xg(a, b, c, d, e, f, h, k, l, m); + } catch (q) { + Y(n); + if (q !== q + 0) + throw q; + X(1, 0); + } + } + function cd(a, b, c, d, e, f, h) { + var k = Z(); + try { + return Yg(a, b, c, d, e, f, h); + } catch (l) { + Y(k); + if (l !== l + 0) + throw l; + X(1, 0); + } + } + function je(a, b, c, d, e, f, h, k, l, m, n) { + var q = Z(); + try { + Zg(a, b, c, d, e, f, h, k, l, m, n); + } catch (r) { + Y(q); + if (r !== r + 0) + throw r; + X(1, 0); + } + } + function ld(a, b, c, d, e, f) { + var h = Z(); + try { + return $g(a, b, c, d, e, f); + } catch (k) { + Y(h); + if (k !== k + 0) + throw k; + X(1, 0); + } + } + function Ie(a, b, c, d, e, f) { + var h = Z(); + try { + bh(a, b, c, d, e, f); + } catch (k) { + Y(h); + if (k !== k + 0) + throw k; + X(1, 0); + } + } + function ye(a, b, c, d, e, f, h, k, l, m, n, q, r, p) { + var u = Z(); + try { + ch(a, b, c, d, e, f, h, k, l, m, n, q, r, p); + } catch (y) { + Y(u); + if (y !== y + 0) + throw y; + X(1, 0); + } + } + function zf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B) { + var C = Z(); + try { + dh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B); + } catch (D) { + Y(C); + if (D !== D + 0) + throw D; + X(1, 0); + } + } + function ae(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) { + var B = Z(); + try { + eh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A); + } catch (C) { + Y(B); + if (C !== C + 0) + throw C; + X(1, 0); + } + } + function $d(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) { + var A = Z(); + try { + fh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y); + } catch (B) { + Y(A); + if (B !== B + 0) + throw B; + X(1, 0); + } + } + function be(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) { + var y = Z(); + try { + gh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u); + } catch (A) { + Y(y); + if (A !== A + 0) + throw A; + X(1, 0); + } + } + function Af(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) { + var H = Z(); + try { + hh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F); + } catch (K) { + Y(H); + if (K !== K + 0) + throw K; + X(1, 0); + } + } + function yf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C) { + var D = Z(); + try { + ih(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C); + } catch (F) { + Y(D); + if (F !== F + 0) + throw F; + X(1, 0); + } + } + function xf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B) { + var C = Z(); + try { + jh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B); + } catch (D) { + Y(C); + if (D !== D + 0) + throw D; + X(1, 0); + } + } + function Bf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) { + var H = Z(); + try { + kh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F); + } catch (K) { + Y(H); + if (K !== K + 0) + throw K; + X(1, 0); + } + } + function gf(a, b, c, d, e, f, h, k, l, m, n, q, r) { + var p = Z(); + try { + lh(a, b, c, d, e, f, h, k, l, m, n, q, r); + } catch (u) { + Y(p); + if (u !== u + 0) + throw u; + X(1, 0); + } + } + function kf(a, b, c, d, e, f, h, k, l, m) { + var n = Z(); + try { + mh(a, b, c, d, e, f, h, k, l, m); + } catch (q) { + Y(n); + if (q !== q + 0) + throw q; + X(1, 0); + } + } + function ve(a, b, c, d, e, f, h, k, l, m, n, q, r) { + var p = Z(); + try { + nh(a, b, c, d, e, f, h, k, l, m, n, q, r); + } catch (u) { + Y(p); + if (u !== u + 0) + throw u; + X(1, 0); + } + } + function qf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) { + var y = Z(); + try { + oh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u); + } catch (A) { + Y(y); + if (A !== A + 0) + throw A; + X(1, 0); + } + } + function wf(a, b, c, d, e, f, h, k, l, m) { + var n = Z(); + try { + qh(a, b, c, d, e, f, h, k, l, m); + } catch (q) { + Y(n); + if (q !== q + 0) + throw q; + X(1, 0); + } + } + function vf(a, b, c, d, e, f, h, k, l) { + var m = Z(); + try { + rh(a, b, c, d, e, f, h, k, l); + } catch (n) { + Y(m); + if (n !== n + 0) + throw n; + X(1, 0); + } + } + function sc(a, b, c, d, e, f, h) { + var k = Z(); + try { + return ah(a, b, c, d, e, f, h); + } catch (l) { + Y(k); + if (l !== l + 0) + throw l; + X(1, 0); + } + } + function Nd(a, b, c, d, e) { + var f = Z(); + try { + ph(a, b, c, d, e); + } catch (h) { + Y(f); + if (h !== h + 0) + throw h; + X(1, 0); + } + } + function wd(a, b, c) { + var d = Z(); + try { + return Li(a, b, c); + } catch (e) { + Y(d); + if (e !== e + 0) + throw e; + X(1, 0); + return 0n; + } + } + function ze(a, b, c, d, e, f, h, k, l, m, n, q, r, p) { + var u = Z(); + try { + sh(a, b, c, d, e, f, h, k, l, m, n, q, r, p); + } catch (y) { + Y(u); + if (y !== y + 0) + throw y; + X(1, 0); + } + } + function Ge(a, b, c, d, e, f, h, k, l, m, n, q, r) { + var p = Z(); + try { + uh(a, b, c, d, e, f, h, k, l, m, n, q, r); + } catch (u) { + Y(p); + if (u !== u + 0) + throw u; + X(1, 0); + } + } + function Xc(a, b, c, d, e, f, h) { + var k = Z(); + try { + return vh(a, b, c, d, e, f, h); + } catch (l) { + Y(k); + if (l !== l + 0) + throw l; + X(1, 0); + } + } + function ad(a, b, c, d, e, f) { + var h = Z(); + try { + return wh(a, b, c, d, e, f); + } catch (k) { + Y(h); + if (k !== k + 0) + throw k; + X(1, 0); + } + } + function De(a, b, c, d, e, f, h, k, l, m, n, q, r) { + var p = Z(); + try { + xh(a, b, c, d, e, f, h, k, l, m, n, q, r); + } catch (u) { + Y(p); + if (u !== u + 0) + throw u; + X(1, 0); + } + } + function lf(a, b, c, d, e, f) { + var h = Z(); + try { + th(a, b, c, d, e, f); + } catch (k) { + Y(h); + if (k !== k + 0) + throw k; + X(1, 0); + } + } + function Qe(a, b, c, d, e, f, h, k, l, m, n) { + var q = Z(); + try { + yh(a, b, c, d, e, f, h, k, l, m, n); + } catch (r) { + Y(q); + if (r !== r + 0) + throw r; + X(1, 0); + } + } + function Ke(a, b, c, d, e, f, h, k) { + var l = Z(); + try { + Ah(a, b, c, d, e, f, h, k); + } catch (m) { + Y(l); + if (m !== m + 0) + throw m; + X(1, 0); + } + } + function af(a, b, c, d, e, f, h, k) { + var l = Z(); + try { + Bh(a, b, c, d, e, f, h, k); + } catch (m) { + Y(l); + if (m !== m + 0) + throw m; + X(1, 0); + } + } + function td(a, b, c, d) { + var e = Z(); + try { + return Ch(a, b, c, d); + } catch (f) { + Y(e); + if (f !== f + 0) + throw f; + X(1, 0); + } + } + function He(a, b, c, d, e, f, h, k, l, m) { + var n = Z(); + try { + Dh(a, b, c, d, e, f, h, k, l, m); + } catch (q) { + Y(n); + if (q !== q + 0) + throw q; + X(1, 0); + } + } + function pf(a, b, c, d, e, f, h, k, l) { + var m = Z(); + try { + Eh(a, b, c, d, e, f, h, k, l); + } catch (n) { + Y(m); + if (n !== n + 0) + throw n; + X(1, 0); + } + } + function Fe(a, b, c, d, e, f, h, k, l) { + var m = Z(); + try { + Fh(a, b, c, d, e, f, h, k, l); + } catch (n) { + Y(m); + if (n !== n + 0) + throw n; + X(1, 0); + } + } + function Ae(a, b, c, d, e, f, h, k, l, m) { + var n = Z(); + try { + Gh(a, b, c, d, e, f, h, k, l, m); + } catch (q) { + Y(n); + if (q !== q + 0) + throw q; + X(1, 0); + } + } + function ff(a, b, c, d, e, f) { + var h = Z(); + try { + Hh(a, b, c, d, e, f); + } catch (k) { + Y(h); + if (k !== k + 0) + throw k; + X(1, 0); + } + } + function he(a, b, c, d, e, f, h, k, l, m, n, q) { + var r = Z(); + try { + Ih(a, b, c, d, e, f, h, k, l, m, n, q); + } catch (p) { + Y(r); + if (p !== p + 0) + throw p; + X(1, 0); + } + } + function hd(a, b, c, d, e, f, h, k) { + var l = Z(); + try { + return Jh(a, b, c, d, e, f, h, k); + } catch (m) { + Y(l); + if (m !== m + 0) + throw m; + X(1, 0); + } + } + function ne(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) { + var y = Z(); + try { + Mi(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u); + } catch (A) { + Y(y); + if (A !== A + 0) + throw A; + X(1, 0); + } + } + function Be(a, b, c, d, e, f, h, k, l, m, n, q, r, p) { + var u = Z(); + try { + Kh(a, b, c, d, e, f, h, k, l, m, n, q, r, p); + } catch (y) { + Y(u); + if (y !== y + 0) + throw y; + X(1, 0); + } + } + function we(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) { + var y = Z(); + try { + Lh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u); + } catch (A) { + Y(y); + if (A !== A + 0) + throw A; + X(1, 0); + } + } + function Hd(a, b, c) { + var d = Z(); + try { + Mh(a, b, c); + } catch (e) { + Y(d); + if (e !== e + 0) + throw e; + X(1, 0); + } + } + function vc(a, b, c, d) { + var e = Z(); + try { + return Oh(a, b, c, d); + } catch (f) { + Y(e); + if (f !== f + 0) + throw f; + X(1, 0); + } + } + function pc(a, b, c, d) { + var e = Z(); + try { + return Ph(a, b, c, d); + } catch (f) { + Y(e); + if (f !== f + 0) + throw f; + X(1, 0); + } + } + function ce(a, b, c, d, e, f, h, k, l, m) { + var n = Z(); + try { + Qh(a, b, c, d, e, f, h, k, l, m); + } catch (q) { + Y(n); + if (q !== q + 0) + throw q; + X(1, 0); + } + } + function Ee(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F, H, K, Va, Wa, Xa) { + var Qi = Z(); + try { + Rh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F, H, K, Va, Wa, Xa); + } catch (Ya) { + Y(Qi); + if (Ya !== Ya + 0) + throw Ya; + X(1, 0); + } + } + function $e(a, b, c, d, e, f) { + var h = Z(); + try { + Sh(a, b, c, d, e, f); + } catch (k) { + Y(h); + if (k !== k + 0) + throw k; + X(1, 0); + } + } + function Rc(a, b, c, d, e, f, h, k, l, m, n, q, r) { + var p = Z(); + try { + return Th(a, b, c, d, e, f, h, k, l, m, n, q, r); + } catch (u) { + Y(p); + if (u !== u + 0) + throw u; + X(1, 0); + } + } + function Od(a, b, c, d, e, f, h, k, l, m, n, q, r) { + var p = Z(); + try { + Uh(a, b, c, d, e, f, h, k, l, m, n, q, r); + } catch (u) { + Y(p); + if (u !== u + 0) + throw u; + X(1, 0); + } + } + function se(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) { + var H = Z(); + try { + Vh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F); + } catch (K) { + Y(H); + if (K !== K + 0) + throw K; + X(1, 0); + } + } + function Yd(a, b, c, d, e, f, h, k, l, m, n, q, r) { + var p = Z(); + try { + Wh(a, b, c, d, e, f, h, k, l, m, n, q, r); + } catch (u) { + Y(p); + if (u !== u + 0) + throw u; + X(1, 0); + } + } + function hf(a, b, c, d, e, f, h, k, l, m, n, q, r, p) { + var u = Z(); + try { + Xh(a, b, c, d, e, f, h, k, l, m, n, q, r, p); + } catch (y) { + Y(u); + if (y !== y + 0) + throw y; + X(1, 0); + } + } + function re(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) { + var F = Z(); + try { + Zh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D); + } catch (H) { + Y(F); + if (H !== H + 0) + throw H; + X(1, 0); + } + } + function pe(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) { + var B = Z(); + try { + ai(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A); + } catch (C) { + Y(B); + if (C !== C + 0) + throw C; + X(1, 0); + } + } + function qe(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C) { + var D = Z(); + try { + Yh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C); + } catch (F) { + Y(D); + if (F !== F + 0) + throw F; + X(1, 0); + } + } + function Le(a, b, c, d, e, f, h, k) { + var l = Z(); + try { + bi(a, b, c, d, e, f, h, k); + } catch (m) { + Y(l); + if (m !== m + 0) + throw m; + X(1, 0); + } + } + function xe(a, b, c, d, e, f, h, k, l, m, n) { + var q = Z(); + try { + di(a, b, c, d, e, f, h, k, l, m, n); + } catch (r) { + Y(q); + if (r !== r + 0) + throw r; + X(1, 0); + } + } + function Mc(a, b, c, d, e, f, h, k, l, m, n) { + var q = Z(); + try { + return ei(a, b, c, d, e, f, h, k, l, m, n); + } catch (r) { + Y(q); + if (r !== r + 0) + throw r; + X(1, 0); + } + } + function Qc(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) { + var F = Z(); + try { + return fi(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D); + } catch (H) { + Y(F); + if (H !== H + 0) + throw H; + X(1, 0); + } + } + function Sd(a, b, c, d, e) { + var f = Z(); + try { + gi(a, b, c, d, e); + } catch (h) { + Y(f); + if (h !== h + 0) + throw h; + X(1, 0); + } + } + function ge(a, b, c, d, e, f, h, k, l, m, n, q) { + var r = Z(); + try { + Ag(a, b, c, d, e, f, h, k, l, m, n, q); + } catch (p) { + Y(r); + if (p !== p + 0) + throw p; + X(1, 0); + } + } + function Pe(a, b, c, d, e, f, h, k, l, m) { + var n = Z(); + try { + hi(a, b, c, d, e, f, h, k, l, m); + } catch (q) { + Y(n); + if (q !== q + 0) + throw q; + X(1, 0); + } + } + function Me(a, b, c, d, e) { + var f = Z(); + try { + ii(a, b, c, d, e); + } catch (h) { + Y(f); + if (h !== h + 0) + throw h; + X(1, 0); + } + } + function Ye(a, b, c, d, e, f, h, k, l, m, n, q, r) { + var p = Z(); + try { + Ji(a, b, c, d, e, f, h, k, l, m, n, q, r); + } catch (u) { + Y(p); + if (u !== u + 0) + throw u; + X(1, 0); + } + } + function pd(a, b, c, d, e) { + var f = Z(); + try { + return ji(a, b, c, d, e); + } catch (h) { + Y(f); + if (h !== h + 0) + throw h; + X(1, 0); + } + } + function Ad(a, b, c, d) { + var e = Z(); + try { + return Ni(a, b, c, d); + } catch (f) { + Y(e); + if (f !== f + 0) + throw f; + X(1, 0); + return 0n; + } + } + function Je(a, b, c, d, e, f, h) { + var k = Z(); + try { + ki(a, b, c, d, e, f, h); + } catch (l) { + Y(k); + if (l !== l + 0) + throw l; + X(1, 0); + } + } + function qd(a, b, c, d, e, f) { + var h = Z(); + try { + return li(a, b, c, d, e, f); + } catch (k) { + Y(h); + if (k !== k + 0) + throw k; + X(1, 0); + } + } + function ud(a, b, c, d, e, f) { + var h = Z(); + try { + return mi(a, b, c, d, e, f); + } catch (k) { + Y(h); + if (k !== k + 0) + throw k; + X(1, 0); + } + } + function Se(a, b, c, d, e, f, h, k, l) { + var m = Z(); + try { + ni(a, b, c, d, e, f, h, k, l); + } catch (n) { + Y(m); + if (n !== n + 0) + throw n; + X(1, 0); + } + } + function Ld(a, b, c, d) { + var e = Z(); + try { + Nh(a, b, c, d); + } catch (f) { + Y(e); + if (f !== f + 0) + throw f; + X(1, 0); + } + } + function Zc(a, b, c, d, e, f, h, k) { + var l = Z(); + try { + return oi(a, b, c, d, e, f, h, k); + } catch (m) { + Y(l); + if (m !== m + 0) + throw m; + X(1, 0); + } + } + function Ec(a, b, c, d, e, f) { + var h = Z(); + try { + return pi(a, b, c, d, e, f); + } catch (k) { + Y(h); + if (k !== k + 0) + throw k; + X(1, 0); + } + } + function fd(a, b, c, d, e, f) { + var h = Z(); + try { + return qi(a, b, c, d, e, f); + } catch (k) { + Y(h); + if (k !== k + 0) + throw k; + X(1, 0); + } + } + function Sc(a, b, c, d, e, f, h, k, l, m, n, q) { + var r = Z(); + try { + return ri(a, b, c, d, e, f, h, k, l, m, n, q); + } catch (p) { + Y(r); + if (p !== p + 0) + throw p; + X(1, 0); + } + } + function bd(a, b, c, d, e, f, h, k) { + var l = Z(); + try { + return si(a, b, c, d, e, f, h, k); + } catch (m) { + Y(l); + if (m !== m + 0) + throw m; + X(1, 0); + } + } + function Vc(a, b, c, d, e, f, h, k, l, m, n) { + var q = Z(); + try { + return ti(a, b, c, d, e, f, h, k, l, m, n); + } catch (r) { + Y(q); + if (r !== r + 0) + throw r; + X(1, 0); + } + } + function gd(a, b, c, d, e, f, h) { + var k = Z(); + try { + return ui(a, b, c, d, e, f, h); + } catch (l) { + Y(k); + if (l !== l + 0) + throw l; + X(1, 0); + } + } + function Uc(a, b, c, d, e, f, h, k, l, m, n, q, r) { + var p = Z(); + try { + return vi(a, b, c, d, e, f, h, k, l, m, n, q, r); + } catch (u) { + Y(p); + if (u !== u + 0) + throw u; + X(1, 0); + } + } + function od(a, b, c, d, e, f, h) { + var k = Z(); + try { + return wi(a, b, c, d, e, f, h); + } catch (l) { + Y(k); + if (l !== l + 0) + throw l; + X(1, 0); + } + } + function rd(a, b, c, d, e, f, h) { + var k = Z(); + try { + return xi(a, b, c, d, e, f, h); + } catch (l) { + Y(k); + if (l !== l + 0) + throw l; + X(1, 0); + } + } + function Bd(a, b, c) { + var d = Z(); + try { + return yi(a, b, c); + } catch (e) { + Y(d); + if (e !== e + 0) + throw e; + X(1, 0); + return 0n; + } + } + function nd(a, b, c, d) { + var e = Z(); + try { + return zi(a, b, c, d); + } catch (f) { + Y(e); + if (f !== f + 0) + throw f; + X(1, 0); + } + } + function Gd(a, b, c, d) { + var e = Z(); + try { + Bi(a, b, c, d); + } catch (f) { + Y(e); + if (f !== f + 0) + throw f; + X(1, 0); + } + } + function Cc(a, b, c, d) { + var e = Z(); + try { + return Ai(a, b, c, d); + } catch (f) { + Y(e); + if (f !== f + 0) + throw f; + X(1, 0); + } + } + function tf(a, b, c, d, e) { + var f = Z(); + try { + Ci(a, b, c, d, e); + } catch (h) { + Y(f); + if (h !== h + 0) + throw h; + X(1, 0); + } + } + function qc(a, b, c, d, e) { + var f = Z(); + try { + return Di(a, b, c, d, e); + } catch (h) { + Y(f); + if (h !== h + 0) + throw h; + X(1, 0); + } + } + function rc(a, b, c, d, e, f) { + var h = Z(); + try { + return Ei(a, b, c, d, e, f); + } catch (k) { + Y(h); + if (k !== k + 0) + throw k; + X(1, 0); + } + } + function Te(a, b, c, d, e, f, h, k, l, m, n, q) { + var r = Z(); + try { + Fi(a, b, c, d, e, f, h, k, l, m, n, q); + } catch (p) { + Y(r); + if (p !== p + 0) + throw p; + X(1, 0); + } + } + function bf(a, b, c, d, e, f, h, k, l, m, n, q, r) { + var p = Z(); + try { + Gi(a, b, c, d, e, f, h, k, l, m, n, q, r); + } catch (u) { + Y(p); + if (u !== u + 0) + throw u; + X(1, 0); + } + } + function te(a, b, c, d, e, f, h, k, l, m, n, q) { + var r = Z(); + try { + Eg(a, b, c, d, e, f, h, k, l, m, n, q); + } catch (p) { + Y(r); + if (p !== p + 0) + throw p; + X(1, 0); + } + } + function $c(a, b, c, d, e) { + var f = Z(); + try { + return Hi(a, b, c, d, e); + } catch (h) { + Y(f); + if (h !== h + 0) + throw h; + X(1, 0); + } + } + function vd(a) { + var b = Z(); + try { + return eg(a); + } catch (c) { + Y(b); + if (c !== c + 0) + throw c; + X(1, 0); + return 0n; + } + } + function Wc(a, b, c, d, e, f) { + var h = Z(); + try { + return dg(a, b, c, d, e, f); + } catch (k) { + Y(h); + if (k !== k + 0) + throw k; + X(1, 0); + } + } + function Gc(a, b, c, d, e, f) { + var h = Z(); + try { + return ci(a, b, c, d, e, f); + } catch (k) { + Y(h); + if (k !== k + 0) + throw k; + X(1, 0); + } + } + function oe(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) { + var A = Z(); + try { + $h(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y); + } catch (B) { + Y(A); + if (B !== B + 0) + throw B; + X(1, 0); + } + } + function uc(a, b, c) { + var d = Z(); + try { + return qg(a, b, c); + } catch (e) { + Y(d); + if (e !== e + 0) + throw e; + X(1, 0); + } + } + function oc(a, b, c) { + var d = Z(); + try { + return sg(a, b, c); + } catch (e) { + Y(d); + if (e !== e + 0) + throw e; + X(1, 0); + } + } + function Df() { + var a = U; + a = Object.assign({}, a); + var b = (c) => (d) => c(d) >>> 0; + a.Fd = b(a.Fd); + a.he = b(a.he); + a.ne = b(a.ne); + a.oe = ((c) => () => c() >>> 0)(a.oe); + return a; + } + g.stackSave = () => Z(); + g.stackRestore = (a) => Y(a); + g.stackAlloc = (a) => Ef(a); + g.UTF8ToString = J; + g.stringToUTF8 = (a, b, c) => M(a, E, b, c); + g.lengthBytesUTF8 = bb; + var Oi; + Fa = function Pi() { + Oi || Ri(); + Oi || (Fa = Pi); + }; + function Ri() { + if (!(0 < Da)) { + if (g.preRun) + for ("function" == typeof g.preRun && (g.preRun = [g.preRun]); g.preRun.length; ) { + var a = g.preRun.shift(); + Aa.unshift(a); + } + for (; 0 < Aa.length; ) + Aa.shift()(g); + if (!(0 < Da || Oi || (Oi = true, g.calledRun = true, x))) { + for (; 0 < Ba.length; ) + Ba.shift()(g); + for (aa(g); 0 < Ca.length; ) + Ca.shift()(g); + } + } + } + Ri(); + return readyPromise; + }; + })(); + if (typeof exports === "object" && typeof module === "object") + module.exports = ortWasm; + else if (typeof define === "function" && define["amd"]) + define([], () => ortWasm); + } +}); + +// nodejs-ignore:worker_threads +var require_worker_threads = __commonJS({ + "nodejs-ignore:worker_threads"() { + } +}); + +// nodejs-ignore:perf_hooks +var require_perf_hooks = __commonJS({ + "nodejs-ignore:perf_hooks"() { + } +}); + +// nodejs-ignore:os +var os_exports = {}; +__export(os_exports, { + cpus: () => cpus2 +}); +var cpus2; +var init_os = __esm({ + "nodejs-ignore:os"() { + cpus2 = void 0; + } +}); + +// web/lib/wasm/binding/ort-wasm-simd-threaded.jsep.js +var require_ort_wasm_simd_threaded_jsep = __commonJS({ + "web/lib/wasm/binding/ort-wasm-simd-threaded.jsep.js"(exports, module) { + "use strict"; + var ortWasmThreaded = (() => { + var _scriptDir = typeof document !== "undefined" && document.currentScript ? document.currentScript.src : void 0; + if (typeof __filename !== "undefined") + _scriptDir = _scriptDir || __filename; + return function(moduleArg = {}) { + function d() { + l.buffer != p.buffer && t(); + return p; + } + function v() { + l.buffer != p.buffer && t(); + return aa; + } + function z() { + l.buffer != p.buffer && t(); + return ba; + } + function A() { + l.buffer != p.buffer && t(); + return ca; + } + function da() { + l.buffer != p.buffer && t(); + return ea; + } + var B = moduleArg, fa, C; + B.ready = new Promise((a, b) => { + fa = a; + C = b; + }); + "use strict"; + B.jsepInit = (a, b, c, e, f, h, k, q) => { + B.Qb = a; + B.wb = b; + B.yb = c; + B.jb = e; + B.xb = f; + B.Ea = h; + B.zb = k; + B.Ab = q; + b = (n, m, r) => (...w) => { + const x = D, g = m?.(); + w = n(...w); + const u = m?.(); + g !== u && (n = u, r(g), m = r = null); + return D != x ? ha() : w; + }; + c = (n) => async (...m) => { + try { + if (B.bb) + throw Error("Session already started"); + const r = B.bb = { Fb: m[0], errors: [] }, w = await n(...m); + if (B.bb !== r) + throw Error("Session mismatch"); + a.flush(); + const x = r.errors; + if (0 < x.length) { + let g = await Promise.all(x); + g = g.filter((u) => u); + if (0 < g.length) + throw Error(g.join("\n")); + } + return w; + } finally { + B.bb = null; + } + }; + B._OrtRun = c(b(B._OrtRun, () => B._OrtRun, (n) => B._OrtRun = n)); + B._OrtRunWithBinding = c(b(B._OrtRunWithBinding, () => B._OrtRunWithBinding, (n) => B._OrtRunWithBinding = n)); + B._OrtBindInput = b(B._OrtBindInput, () => B._OrtBindInput, (n) => B._OrtBindInput = n); + B.jsepRegisterBuffer = (n, m, r, w) => a.registerBuffer(n, m, r, w); + B.jsepUnregisterBuffers = (n) => { + a.unregisterBuffers(n); + }; + B.jsepGetBuffer = (n) => a.getBuffer(n); + B.jsepCreateDownloader = (n, m, r) => a.createDownloader(n, m, r); + }; + var ia = Object.assign({}, B), ja = "./this.program", E = (a, b) => { + throw b; + }, ka = "object" == typeof window, F = "function" == typeof importScripts, G = "object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node, H = B.ENVIRONMENT_IS_PTHREAD || false, I = ""; + function la(a) { + return B.locateFile ? B.locateFile(a, I) : I + a; + } + var ma, J, na; + if (G) { + var fs = (init_fs(), __toCommonJS(fs_exports)), oa = (init_path(), __toCommonJS(path_exports)); + I = F ? oa.dirname(I) + "/" : __dirname + "/"; + ma = (b, c) => { + b = b.startsWith("file://") ? new URL(b) : oa.normalize(b); + return fs.readFileSync(b, c ? void 0 : "utf8"); + }; + na = (b) => { + b = ma(b, true); + b.buffer || (b = new Uint8Array(b)); + return b; + }; + J = (b, c, e, f = true) => { + b = b.startsWith("file://") ? new URL(b) : oa.normalize(b); + fs.readFile(b, f ? void 0 : "utf8", (h, k) => { + h ? e(h) : c(f ? k.buffer : k); + }); + }; + !B.thisProgram && 1 < process.argv.length && (ja = process.argv[1].replace(/\\/g, "/")); + process.argv.slice(2); + E = (b, c) => { + process.exitCode = b; + throw c; + }; + B.inspect = () => "[Emscripten Module object]"; + let a; + try { + a = require_worker_threads(); + } catch (b) { + throw console.error('The "worker_threads" module is not supported in this node.js build - perhaps a newer version is needed?'), b; + } + global.Worker = a.Worker; + } else if (ka || F) + F ? I = self.location.href : "undefined" != typeof document && document.currentScript && (I = document.currentScript.src), typeof _scriptDir !== "undefined" && _scriptDir && (I = _scriptDir), 0 !== I.indexOf("blob:") ? I = I.substr(0, I.replace(/[?#].*/, "").lastIndexOf("/") + 1) : I = "", G || (ma = (a) => { + var b = new XMLHttpRequest(); + b.open("GET", a, false); + b.send(null); + return b.responseText; + }, F && (na = (a) => { + var b = new XMLHttpRequest(); + b.open("GET", a, false); + b.responseType = "arraybuffer"; + b.send(null); + return new Uint8Array(b.response); + }), J = (a, b, c) => { + var e = new XMLHttpRequest(); + e.open("GET", a, true); + e.responseType = "arraybuffer"; + e.onload = () => { + 200 == e.status || 0 == e.status && e.response ? b(e.response) : c(); + }; + e.onerror = c; + e.send(null); + }); + G && "undefined" == typeof performance && (global.performance = require_perf_hooks().performance); + var pa = console.log.bind(console), qa = console.error.bind(console); + G && (pa = (...a) => fs.writeSync(1, a.join(" ") + "\n"), qa = (...a) => fs.writeSync(2, a.join(" ") + "\n")); + var ra = B.print || pa, K = B.printErr || qa; + Object.assign(B, ia); + ia = null; + B.thisProgram && (ja = B.thisProgram); + B.quit && (E = B.quit); + var L; + B.wasmBinary && (L = B.wasmBinary); + var noExitRuntime = B.noExitRuntime || true; + "object" != typeof WebAssembly && M("no native wasm support detected"); + var l, N, sa, P = false, Q, p, aa, ba, ca, ea; + function t() { + var a = l.buffer; + B.HEAP8 = p = new Int8Array(a); + B.HEAP16 = new Int16Array(a); + B.HEAP32 = ba = new Int32Array(a); + B.HEAPU8 = aa = new Uint8Array(a); + B.HEAPU16 = new Uint16Array(a); + B.HEAPU32 = ca = new Uint32Array(a); + B.HEAPF32 = new Float32Array(a); + B.HEAPF64 = ea = new Float64Array(a); + } + var ta = B.INITIAL_MEMORY || 16777216; + 5242880 <= ta || M("INITIAL_MEMORY should be larger than STACK_SIZE, was " + ta + "! (STACK_SIZE=5242880)"); + if (H) + l = B.wasmMemory; + else if (B.wasmMemory) + l = B.wasmMemory; + else if (l = new WebAssembly.Memory({ initial: ta / 65536, maximum: 65536, shared: true }), !(l.buffer instanceof SharedArrayBuffer)) + throw K("requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag"), G && K("(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and/or recent version)"), Error("bad memory"); + t(); + ta = l.buffer.byteLength; + var ua = [], va = [], wa = [], xa = 0; + function ya() { + return noExitRuntime || 0 < xa; + } + var R = 0, za = null, S = null; + function Aa() { + R++; + B.monitorRunDependencies && B.monitorRunDependencies(R); + } + function Ba() { + R--; + B.monitorRunDependencies && B.monitorRunDependencies(R); + if (0 == R && (null !== za && (clearInterval(za), za = null), S)) { + var a = S; + S = null; + a(); + } + } + function M(a) { + if (B.onAbort) + B.onAbort(a); + a = "Aborted(" + a + ")"; + K(a); + P = true; + Q = 1; + a = new WebAssembly.RuntimeError(a + ". Build with -sASSERTIONS for more info."); + C(a); + throw a; + } + function Ca(a) { + return a.startsWith("data:application/octet-stream;base64,"); + } + var T; + T = "ort-wasm-simd-threaded.wasm"; + Ca(T) || (T = la(T)); + function Da(a) { + if (a == T && L) + return new Uint8Array(L); + if (na) + return na(a); + throw "both async and sync fetching of the wasm failed"; + } + function Ea(a) { + if (!L && (ka || F)) { + if ("function" == typeof fetch && !a.startsWith("file://")) + return fetch(a, { credentials: "same-origin" }).then((b) => { + if (!b.ok) + throw "failed to load wasm binary file at '" + a + "'"; + return b.arrayBuffer(); + }).catch(() => Da(a)); + if (J) + return new Promise((b, c) => { + J(a, (e) => b(new Uint8Array(e)), c); + }); + } + return Promise.resolve().then(() => Da(a)); + } + function Fa(a, b, c) { + return Ea(a).then((e) => WebAssembly.instantiate(e, b)).then((e) => e).then(c, (e) => { + K("failed to asynchronously prepare wasm: " + e); + M(e); + }); + } + function Ga(a, b) { + var c = T; + return L || "function" != typeof WebAssembly.instantiateStreaming || Ca(c) || c.startsWith("file://") || G || "function" != typeof fetch ? Fa(c, a, b) : fetch(c, { credentials: "same-origin" }).then((e) => WebAssembly.instantiateStreaming(e, a).then(b, function(f) { + K("wasm streaming compile failed: " + f); + K("falling back to ArrayBuffer instantiation"); + return Fa(c, a, b); + })); + } + var U, Ha = { + 906828: (a) => { + B.Ea("Abs", a, void 0); + }, + 906879: (a) => { + B.Ea("Neg", a, void 0); + }, + 906930: (a) => { + B.Ea("Floor", a, void 0); + }, + 906983: (a) => { + B.Ea("Ceil", a, void 0); + }, + 907035: (a) => { + B.Ea("Reciprocal", a, void 0); + }, + 907093: (a) => { + B.Ea("Sqrt", a, void 0); + }, + 907145: (a) => { + B.Ea("Exp", a, void 0); + }, + 907196: (a) => { + B.Ea("Erf", a, void 0); + }, + 907247: (a) => { + B.Ea("Sigmoid", a, void 0); + }, + 907302: (a) => { + B.Ea("Log", a, void 0); + }, + 907353: (a) => { + B.Ea("Sin", a, void 0); + }, + 907404: (a) => { + B.Ea("Cos", a, void 0); + }, + 907455: (a) => { + B.Ea("Tan", a, void 0); + }, + 907506: (a) => { + B.Ea("Asin", a, void 0); + }, + 907558: (a) => { + B.Ea( + "Acos", + a, + void 0 + ); + }, + 907610: (a) => { + B.Ea("Atan", a, void 0); + }, + 907662: (a) => { + B.Ea("Sinh", a, void 0); + }, + 907714: (a) => { + B.Ea("Cosh", a, void 0); + }, + 907766: (a) => { + B.Ea("Asinh", a, void 0); + }, + 907819: (a) => { + B.Ea("Acosh", a, void 0); + }, + 907872: (a) => { + B.Ea("Atanh", a, void 0); + }, + 907925: (a) => { + B.Ea("Tanh", a, void 0); + }, + 907977: (a) => { + B.Ea("Not", a, void 0); + }, + 908028: (a, b, c) => { + B.Ea("ClipV10", a, { min: b, max: c }); + }, + 908100: (a) => { + B.Ea("Clip", a, void 0); + }, + 908152: (a, b) => { + B.Ea("Elu", a, { alpha: b }); + }, + 908210: (a) => { + B.Ea("Relu", a, void 0); + }, + 908262: (a, b) => { + B.Ea("LeakyRelu", a, { alpha: b }); + }, + 908326: (a, b) => { + B.Ea("ThresholdedRelu", a, { alpha: b }); + }, + 908396: (a, b) => { + B.Ea("Cast", a, { to: b }); + }, + 908454: (a) => { + B.Ea("Add", a, void 0); + }, + 908505: (a) => { + B.Ea("Sub", a, void 0); + }, + 908556: (a) => { + B.Ea("Mul", a, void 0); + }, + 908607: (a) => { + B.Ea("Div", a, void 0); + }, + 908658: (a) => { + B.Ea("Pow", a, void 0); + }, + 908709: (a) => { + B.Ea("Equal", a, void 0); + }, + 908762: (a) => { + B.Ea("Greater", a, void 0); + }, + 908817: (a) => { + B.Ea("GreaterOrEqual", a, void 0); + }, + 908879: (a) => { + B.Ea("Less", a, void 0); + }, + 908931: (a) => { + B.Ea("LessOrEqual", a, void 0); + }, + 908990: (a, b, c, e, f) => { + B.Ea("ReduceMean", a, { + keepDims: !!b, + noopWithEmptyAxes: !!c, + axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] + }); + }, + 909154: (a, b, c, e, f) => { + B.Ea("ReduceMax", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] }); + }, + 909317: (a, b, c, e, f) => { + B.Ea("ReduceMin", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] }); + }, + 909480: (a, b, c, e, f) => { + B.Ea("ReduceProd", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] }); + }, + 909644: (a, b, c, e, f) => { + B.Ea("ReduceSum", a, { + keepDims: !!b, + noopWithEmptyAxes: !!c, + axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] + }); + }, + 909807: (a, b, c, e, f) => { + B.Ea("ReduceL1", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] }); + }, + 909969: (a, b, c, e, f) => { + B.Ea("ReduceL2", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] }); + }, + 910131: (a, b, c, e, f) => { + B.Ea("ReduceLogSum", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] }); + }, + 910297: (a, b, c, e, f) => { + B.Ea("ReduceSumSquare", a, { + keepDims: !!b, + noopWithEmptyAxes: !!c, + axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] + }); + }, + 910466: (a, b, c, e, f) => { + B.Ea("ReduceLogSumExp", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] }); + }, + 910635: (a) => { + B.Ea("Where", a, void 0); + }, + 910688: (a, b, c) => { + B.Ea("Transpose", a, { perm: b ? Array.from(z().subarray(c >>> 0, c + b >>> 0)) : [] }); + }, + 910801: (a, b, c, e, f, h, k, q, n, m) => { + B.Ea("Conv", a, { format: n ? "NHWC" : "NCHW", auto_pad: b, dilations: [c], group: e, kernel_shape: [f], pads: [h, k], strides: [q], w_is_const: () => !!d()[m >>> 0] }); + }, + 911029: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u) => { + B.Ea("Conv", a, { format: g ? "NHWC" : "NCHW", auto_pad: b, dilations: [c, e], group: f, kernel_shape: [h, k], pads: [q, n, m, r], strides: [w, x], w_is_const: () => !!d()[u >>> 0] }); + }, + 911288: (a, b, c, e, f, h, k, q, n, m) => { + B.Ea("Conv", a, { format: n ? "NHWC" : "NCHW", auto_pad: b, dilations: [c], group: e, kernel_shape: [f], pads: [h, k], strides: [q], w_is_const: () => !!d()[m >>> 0] }); + }, + 911516: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u) => { + B.Ea("Conv", a, { format: g ? "NHWC" : "NCHW", auto_pad: b, dilations: [c, e], group: f, kernel_shape: [ + h, + k + ], pads: [q, n, m, r], strides: [w, x], w_is_const: () => !!d()[u >>> 0] }); + }, + 911775: (a, b, c, e, f, h, k, q, n, m, r, w, x, g) => { + B.Ea("ConvTranspose", a, { format: n ? "NHWC" : "NCHW", autoPad: b, dilations: [c], group: e, kernel_shape: [f], pads: [h, k], strides: [q], wIsConst: () => !!d()[m >>> 0], outputPadding: r ? Array.from(z().subarray(w >>> 0, w + r >>> 0)) : [], outputShape: x ? Array.from(z().subarray(g >>> 0, g + x >>> 0)) : [] }); + }, + 912155: (a, b, c, e, f, h, k, q, n, m, r, w, x) => { + B.Ea("ConvTranspose", a, { format: q ? "NHWC" : "NCHW", autoPad: b, dilations: Array.from(z().subarray(c >>> 0, c + 2 >>> 0)), group: e, kernelShape: Array.from(z().subarray(f >>> 0, f + 2 >>> 0)), pads: Array.from(z().subarray(h >>> 0, h + 4 >>> 0)), strides: Array.from(z().subarray(k >>> 0, k + 2 >>> 0)), wIsConst: () => !!d()[n >>> 0], outputPadding: 0 < m ? Array.from(z().subarray(r >>> 0, r + m >>> 0)) : [], outputShape: 0 < w ? Array.from(z().subarray(x >>> 0, x + w >>> 0)) : [] }); + }, + 912678: (a, b, c, e, f, h, k, q, n, m, r, w, x, g) => { + B.Ea("ConvTranspose", a, { format: n ? "NHWC" : "NCHW", autoPad: b, dilations: [c], group: e, kernel_shape: [f], pads: [h, k], strides: [q], wIsConst: () => !!d()[m >>> 0], outputPadding: r ? Array.from(z().subarray(w >>> 0, w + r >>> 0)) : [], outputShape: x ? Array.from(z().subarray(g >>> 0, g + x >>> 0)) : [] }); + }, + 913058: (a, b, c, e, f, h, k, q, n, m, r, w, x) => { + B.Ea("ConvTranspose", a, { format: q ? "NHWC" : "NCHW", autoPad: b, dilations: Array.from(z().subarray(c >>> 0, c + 2 >>> 0)), group: e, kernelShape: Array.from(z().subarray(f >>> 0, f + 2 >>> 0)), pads: Array.from(z().subarray(h >>> 0, h + 4 >>> 0)), strides: Array.from(z().subarray(k >>> 0, k + 2 >>> 0)), wIsConst: () => !!d()[n >>> 0], outputPadding: 0 < m ? Array.from(z().subarray(r >>> 0, r + m >>> 0)) : [], outputShape: 0 < w ? Array.from(z().subarray(x >>> 0, x + w >>> 0)) : [] }); + }, + 913581: (a, b) => { + B.Ea("GlobalAveragePool", a, { format: b ? "NHWC" : "NCHW" }); + }, + 913672: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u, y) => { + B.Ea("AveragePool", a, { format: y ? "NHWC" : "NCHW", auto_pad: b, ceil_mode: c, count_include_pad: e, storage_order: f, dilations: [h, k], kernel_shape: [q, n], pads: [m, r, w, x], strides: [g, u] }); + }, + 913956: (a, b) => { + B.Ea("GlobalAveragePool", a, { format: b ? "NHWC" : "NCHW" }); + }, + 914047: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u, y) => { + B.Ea("AveragePool", a, { + format: y ? "NHWC" : "NCHW", + auto_pad: b, + ceil_mode: c, + count_include_pad: e, + storage_order: f, + dilations: [h, k], + kernel_shape: [q, n], + pads: [m, r, w, x], + strides: [g, u] + }); + }, + 914331: (a, b) => { + B.Ea("GlobalMaxPool", a, { format: b ? "NHWC" : "NCHW" }); + }, + 914418: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u, y) => { + B.Ea("MaxPool", a, { format: y ? "NHWC" : "NCHW", auto_pad: b, ceil_mode: c, count_include_pad: e, storage_order: f, dilations: [h, k], kernel_shape: [q, n], pads: [m, r, w, x], strides: [g, u] }); + }, + 914698: (a, b) => { + B.Ea("GlobalMaxPool", a, { format: b ? "NHWC" : "NCHW" }); + }, + 914785: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u, y) => { + B.Ea( + "MaxPool", + a, + { format: y ? "NHWC" : "NCHW", auto_pad: b, ceil_mode: c, count_include_pad: e, storage_order: f, dilations: [h, k], kernel_shape: [q, n], pads: [m, r, w, x], strides: [g, u] } + ); + }, + 915065: (a, b, c, e, f) => { + B.Ea("Gemm", a, { alpha: b, beta: c, transA: e, transB: f }); + }, + 915169: (a) => { + B.Ea("MatMul", a, void 0); + }, + 915223: (a, b, c, e) => { + B.Ea("ArgMax", a, { keepDims: !!b, selectLastIndex: !!c, axis: e }); + }, + 915331: (a, b, c, e) => { + B.Ea("ArgMin", a, { keepDims: !!b, selectLastIndex: !!c, axis: e }); + }, + 915439: (a, b) => { + B.Ea("Softmax", a, { axis: b }); + }, + 915502: (a, b) => { + B.Ea("Concat", a, { axis: b }); + }, + 915562: (a, b, c, e, f) => { + B.Ea("Split", a, { axis: b, numOutputs: c, splitSizes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] }); + }, + 915707: (a) => { + B.Ea("Expand", a, void 0); + }, + 915761: (a, b) => { + B.Ea("Gather", a, { axis: Number(b) }); + }, + 915832: (a, b) => { + B.Ea("GatherElements", a, { axis: Number(b) }); + }, + 915911: (a, b, c, e, f, h, k, q, n, m, r) => { + B.Ea("Resize", a, { antialias: b, axes: c ? Array.from(z().subarray(e >>> 0, e + c >>> 0)) : [], coordinateTransformMode: V(f), cubicCoeffA: h, excludeOutside: k, extrapolationValue: q, keepAspectRatioPolicy: V(n), mode: V(m), nearestMode: V(r) }); + }, + 916262: (a, b, c, e, f, h, k) => { + B.Ea("Slice", a, { starts: b ? Array.from(z().subarray(c >>> 0, c + b >>> 0)) : [], ends: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [], axes: h ? Array.from(z().subarray(k >>> 0, k + h >>> 0)) : [] }); + }, + 916493: (a) => { + B.Ea("Tile", a, void 0); + }, + 916545: (a, b, c) => { + B.Ea("LayerNormalization", a, { axis: Number(b), epsilon: Number(c) }); + }, + 916652: (a, b, c) => { + B.Ea("InstanceNormalization", a, { epsilon: b, format: c ? "NHWC" : "NCHW" }); + }, + 916766: (a, b, c) => { + B.Ea("InstanceNormalization", a, { epsilon: b, format: c ? "NHWC" : "NCHW" }); + }, + 916880: (a) => { + B.Ea( + "Range", + a, + void 0 + ); + }, + 916933: (a, b) => { + B.Ea("Einsum", a, { equation: V(b) }); + }, + 917014: (a, b, c, e, f) => { + B.Ea("Pad", a, { mode: b, value: c, pads: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] }); + }, + 917146: (a) => { + B.Ea("Gelu", a, void 0); + }, + 917198: (a) => { + B.Ea("BiasAdd", a, void 0); + }, + 917253: (a) => { + B.Ea("BiasSplitGelu", a, void 0); + }, + 917314: (a, b) => { + B.Ea("SkipLayerNormalization", a, { epsilon: b }); + }, + 917395: (a) => { + B.zb(a); + }, + 917429: (a, b) => B.Ab(a, b, B.bb.Fb, B.bb.errors), + 917541: (a) => B.wb(a), + 917574: (a) => B.yb(a), + 917606: (a, b, c) => { + B.jb(a, b, c, true); + }, + 917645: (a, b, c) => { + B.jb(a, b, c); + } + }; + function Ia(a) { + this.name = "ExitStatus"; + this.message = `Program terminated with exit(${a})`; + this.status = a; + } + function Ja(a) { + a.terminate(); + a.onmessage = () => { + }; + } + function Ka(a) { + (a = W.Qa[a]) || M(); + W.Eb(a); + } + function La(a) { + var b = W.tb(); + if (!b) + return 6; + W.Ya.push(b); + W.Qa[a.Xa] = b; + b.Xa = a.Xa; + var c = { cmd: "run", start_routine: a.Gb, arg: a.rb, pthread_ptr: a.Xa }; + G && b.unref(); + b.postMessage(c, a.Mb); + return 0; + } + var Ma = "undefined" != typeof TextDecoder ? new TextDecoder("utf8") : void 0, Na = (a, b, c) => { + b >>>= 0; + var e = b + c; + for (c = b; a[c] && !(c >= e); ) + ++c; + if (16 < c - b && a.buffer && Ma) + return Ma.decode(a.buffer instanceof SharedArrayBuffer ? a.slice(b, c) : a.subarray(b, c)); + for (e = ""; b < c; ) { + var f = a[b++]; + if (f & 128) { + var h = a[b++] & 63; + if (192 == (f & 224)) + e += String.fromCharCode((f & 31) << 6 | h); + else { + var k = a[b++] & 63; + f = 224 == (f & 240) ? (f & 15) << 12 | h << 6 | k : (f & 7) << 18 | h << 12 | k << 6 | a[b++] & 63; + 65536 > f ? e += String.fromCharCode(f) : (f -= 65536, e += String.fromCharCode(55296 | f >> 10, 56320 | f & 1023)); + } + } else + e += String.fromCharCode(f); + } + return e; + }, V = (a, b) => (a >>>= 0) ? Na(v(), a, b) : ""; + function Oa(a) { + if (H) + return X(1, 1, a); + Q = a; + if (!ya()) { + W.Hb(); + if (B.onExit) + B.onExit(a); + P = true; + } + E(a, new Ia(a)); + } + var Qa = (a) => { + Q = a; + if (H) + throw Pa(a), "unwind"; + Oa(a); + }, W = { + ab: [], + Ya: [], + mb: [], + Qa: {}, + gb: function() { + H ? W.vb() : W.ub(); + }, + ub: function() { + ua.unshift(() => { + Aa(); + W.Bb(() => Ba()); + }); + }, + vb: function() { + W.receiveObjectTransfer = W.Db; + W.threadInitTLS = W.lb; + W.setExitStatus = W.kb; + noExitRuntime = false; + }, + kb: function(a) { + Q = a; + }, + Sb: ["$terminateWorker"], + Hb: function() { + for (var a of W.Ya) + Ja(a); + for (a of W.ab) + Ja(a); + W.ab = []; + W.Ya = []; + W.Qa = []; + }, + Eb: function(a) { + var b = a.Xa; + delete W.Qa[b]; + W.ab.push(a); + W.Ya.splice(W.Ya.indexOf(a), 1); + a.Xa = 0; + Ra(b); + }, + Db: function() { + }, + lb: function() { + W.mb.forEach((a) => a()); + }, + Cb: (a) => new Promise((b) => { + a.onmessage = (h) => { + h = h.data; + var k = h.cmd; + if (h.targetThread && h.targetThread != Sa()) { + var q = W.Qa[h.Rb]; + q ? q.postMessage(h, h.transferList) : K('Internal error! Worker sent a message "' + k + '" to target pthread ' + h.targetThread + ", but that thread no longer exists!"); + } else if ("checkMailbox" === k) + Ta(); + else if ("spawnThread" === k) + La(h); + else if ("cleanupThread" === k) + Ka(h.thread); + else if ("killThread" === k) + h = h.thread, k = W.Qa[h], delete W.Qa[h], Ja(k), Ra(h), W.Ya.splice( + W.Ya.indexOf(k), + 1 + ), k.Xa = 0; + else if ("cancelThread" === k) + W.Qa[h.thread].postMessage({ cmd: "cancel" }); + else if ("loaded" === k) + a.loaded = true, b(a); + else if ("alert" === k) + alert("Thread " + h.threadId + ": " + h.text); + else if ("setimmediate" === h.target) + a.postMessage(h); + else if ("callHandler" === k) + B[h.handler](...h.args); + else + k && K("worker sent an unknown command " + k); + }; + a.onerror = (h) => { + K("worker sent an error! " + h.filename + ":" + h.lineno + ": " + h.message); + throw h; + }; + G && (a.on("message", function(h) { + a.onmessage({ data: h }); + }), a.on("error", function(h) { + a.onerror(h); + })); + var c = [], e = ["onExit", "onAbort", "print", "printErr"], f; + for (f of e) + B.hasOwnProperty(f) && c.push(f); + a.postMessage({ cmd: "load", handlers: c, urlOrBlob: B.mainScriptUrlOrBlob || _scriptDir, wasmMemory: l, wasmModule: sa }); + }), + Bb: function(a) { + a(); + }, + qb: function() { + var a = la("ort-wasm-simd-threaded.worker.js"); + a = new Worker(a); + W.ab.push(a); + }, + tb: function() { + 0 == W.ab.length && (W.qb(), W.Cb(W.ab[0])); + return W.ab.pop(); + } + }; + B.PThread = W; + var Ua = (a) => { + for (; 0 < a.length; ) + a.shift()(B); + }; + B.establishStackSpace = function() { + var a = Sa(), b = z()[a + 52 >> 2 >>> 0]; + a = z()[a + 56 >> 2 >>> 0]; + Va(b, b - a); + Wa(b); + }; + function Pa(a) { + if (H) + return X(2, 0, a); + Qa(a); + } + B.invokeEntryPoint = function(a, b) { + a = Xa.apply(null, [a, b]); + ya() ? W.kb(a) : Ya(a); + }; + function Za(a) { + this.fb = a - 24; + this.pb = function(b) { + A()[this.fb + 4 >> 2 >>> 0] = b; + }; + this.ob = function(b) { + A()[this.fb + 8 >> 2 >>> 0] = b; + }; + this.gb = function(b, c) { + this.nb(); + this.pb(b); + this.ob(c); + }; + this.nb = function() { + A()[this.fb + 16 >> 2 >>> 0] = 0; + }; + } + var $a = 0, ab = 0; + function bb(a, b, c, e) { + return H ? X(3, 1, a, b, c, e) : cb(a, b, c, e); + } + function cb(a, b, c, e) { + a >>>= 0; + b >>>= 0; + c >>>= 0; + e >>>= 0; + if ("undefined" == typeof SharedArrayBuffer) + return K("Current environment does not support SharedArrayBuffer, pthreads are not available!"), 6; + var f = []; + if (H && 0 === f.length) + return bb(a, b, c, e); + a = { Gb: c, Xa: a, rb: e, Mb: f }; + return H ? (a.Ob = "spawnThread", postMessage(a, f), 0) : La(a); + } + function db(a, b, c) { + return H ? X(4, 1, a, b, c) : 0; + } + function eb(a, b) { + if (H) + return X(5, 1, a, b); + } + var fb = (a) => { + for (var b = 0, c = 0; c < a.length; ++c) { + var e = a.charCodeAt(c); + 127 >= e ? b++ : 2047 >= e ? b += 2 : 55296 <= e && 57343 >= e ? (b += 4, ++c) : b += 3; + } + return b; + }, gb = (a, b, c, e) => { + c >>>= 0; + if (!(0 < e)) + return 0; + var f = c; + e = c + e - 1; + for (var h = 0; h < a.length; ++h) { + var k = a.charCodeAt(h); + if (55296 <= k && 57343 >= k) { + var q = a.charCodeAt(++h); + k = 65536 + ((k & 1023) << 10) | q & 1023; + } + if (127 >= k) { + if (c >= e) + break; + b[c++ >>> 0] = k; + } else { + if (2047 >= k) { + if (c + 1 >= e) + break; + b[c++ >>> 0] = 192 | k >> 6; + } else { + if (65535 >= k) { + if (c + 2 >= e) + break; + b[c++ >>> 0] = 224 | k >> 12; + } else { + if (c + 3 >= e) + break; + b[c++ >>> 0] = 240 | k >> 18; + b[c++ >>> 0] = 128 | k >> 12 & 63; + } + b[c++ >>> 0] = 128 | k >> 6 & 63; + } + b[c++ >>> 0] = 128 | k & 63; + } + } + b[c >>> 0] = 0; + return c - f; + }, hb = (a, b, c) => gb(a, v(), b, c); + function ib(a, b) { + if (H) + return X(6, 1, a, b); + } + function jb(a, b, c) { + if (H) + return X(7, 1, a, b, c); + } + function kb(a, b, c) { + return H ? X(8, 1, a, b, c) : 0; + } + function lb(a, b) { + if (H) + return X(9, 1, a, b); + } + function mb(a, b, c) { + if (H) + return X(10, 1, a, b, c); + } + function nb(a, b, c, e) { + if (H) + return X(11, 1, a, b, c, e); + } + function ob(a, b, c, e) { + if (H) + return X(12, 1, a, b, c, e); + } + function pb(a, b, c, e) { + if (H) + return X(13, 1, a, b, c, e); + } + function qb(a) { + if (H) + return X(14, 1, a); + } + function rb(a, b) { + if (H) + return X(15, 1, a, b); + } + function sb(a, b, c) { + if (H) + return X(16, 1, a, b, c); + } + var tb = (a) => { + if (!P) + try { + if (a(), !ya()) + try { + H ? Ya(Q) : Qa(Q); + } catch (b) { + b instanceof Ia || "unwind" == b || E(1, b); + } + } catch (b) { + b instanceof Ia || "unwind" == b || E(1, b); + } + }; + function ub(a) { + a >>>= 0; + "function" === typeof Atomics.Nb && (Atomics.Nb(z(), a >> 2, a).value.then(Ta), a += 128, Atomics.store(z(), a >> 2, 1)); + } + B.__emscripten_thread_mailbox_await = ub; + function Ta() { + var a = Sa(); + a && (ub(a), tb(() => vb())); + } + B.checkMailbox = Ta; + var Y = (a) => 0 === a % 4 && (0 !== a % 100 || 0 === a % 400), wb = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335], xb = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]; + function yb(a, b, c, e, f, h, k, q) { + return H ? X(17, 1, a, b, c, e, f, h, k, q) : -52; + } + function zb(a, b, c, e, f, h, k) { + if (H) + return X(18, 1, a, b, c, e, f, h, k); + } + var Bb = (a) => { + var b = fb(a) + 1, c = Ab(b); + c && hb(a, c, b); + return c; + }, Cb = [], Db = (a, b) => { + Cb.length = 0; + var c; + for (b >>= 2; c = v()[a++ >>> 0]; ) + b += 105 != c & b, Cb.push(105 == c ? z()[b >>> 0] : da()[b++ >>> 1]), ++b; + return Cb; + }, Fb = (a) => { + var b = Eb(); + a = a(); + Wa(b); + return a; + }; + function X(a, b) { + var c = arguments.length - 2, e = arguments; + return Fb(() => { + for (var f = Gb(8 * c), h = f >> 3, k = 0; k < c; k++) { + var q = e[2 + k]; + da()[h + k >>> 0] = q; + } + return Hb(a, c, f, b); + }); + } + var Ib = [], Jb = {}, Lb = () => { + if (!Kb) { + var a = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: ("object" == typeof navigator && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8", _: ja || "./this.program" }, b; + for (b in Jb) + void 0 === Jb[b] ? delete a[b] : a[b] = Jb[b]; + var c = []; + for (b in a) + c.push(`${b}=${a[b]}`); + Kb = c; + } + return Kb; + }, Kb; + function Mb(a, b) { + if (H) + return X(19, 1, a, b); + a >>>= 0; + b >>>= 0; + var c = 0; + Lb().forEach(function(e, f) { + var h = b + c; + f = A()[a + 4 * f >> 2 >>> 0] = h; + for (h = 0; h < e.length; ++h) + d()[f++ >> 0 >>> 0] = e.charCodeAt(h); + d()[f >> 0 >>> 0] = 0; + c += e.length + 1; + }); + return 0; + } + function Nb(a, b) { + if (H) + return X(20, 1, a, b); + a >>>= 0; + b >>>= 0; + var c = Lb(); + A()[a >> 2 >>> 0] = c.length; + var e = 0; + c.forEach(function(f) { + e += f.length + 1; + }); + A()[b >> 2 >>> 0] = e; + return 0; + } + function Ob(a) { + return H ? X(21, 1, a) : 52; + } + function Pb(a, b, c, e) { + return H ? X(22, 1, a, b, c, e) : 52; + } + function Qb(a, b, c, e, f) { + return H ? X(23, 1, a, b, c, e, f) : 70; + } + var Rb = [null, [], []]; + function Tb(a, b, c, e) { + if (H) + return X(24, 1, a, b, c, e); + b >>>= 0; + c >>>= 0; + e >>>= 0; + for (var f = 0, h = 0; h < c; h++) { + var k = A()[b >> 2 >>> 0], q = A()[b + 4 >> 2 >>> 0]; + b += 8; + for (var n = 0; n < q; n++) { + var m = v()[k + n >>> 0], r = Rb[a]; + 0 === m || 10 === m ? ((1 === a ? ra : K)(Na(r, 0)), r.length = 0) : r.push(m); + } + f += q; + } + A()[e >> 2 >>> 0] = f; + return 0; + } + var Ub = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], Vb = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + function Wb(a) { + var b = Array(fb(a) + 1); + gb(a, b, 0, b.length); + return b; + } + var Xb = (a, b) => { + d().set(a, b >>> 0); + }; + function Yb(a, b, c, e) { + function f(g, u, y) { + for (g = "number" == typeof g ? g.toString() : g || ""; g.length < u; ) + g = y[0] + g; + return g; + } + function h(g, u) { + return f(g, u, "0"); + } + function k(g, u) { + function y(Sb) { + return 0 > Sb ? -1 : 0 < Sb ? 1 : 0; + } + var O; + 0 === (O = y(g.getFullYear() - u.getFullYear())) && 0 === (O = y(g.getMonth() - u.getMonth())) && (O = y(g.getDate() - u.getDate())); + return O; + } + function q(g) { + switch (g.getDay()) { + case 0: + return new Date(g.getFullYear() - 1, 11, 29); + case 1: + return g; + case 2: + return new Date(g.getFullYear(), 0, 3); + case 3: + return new Date( + g.getFullYear(), + 0, + 2 + ); + case 4: + return new Date(g.getFullYear(), 0, 1); + case 5: + return new Date(g.getFullYear() - 1, 11, 31); + case 6: + return new Date(g.getFullYear() - 1, 11, 30); + } + } + function n(g) { + var u = g.Za; + for (g = new Date(new Date(g.$a + 1900, 0, 1).getTime()); 0 < u; ) { + var y = g.getMonth(), O = (Y(g.getFullYear()) ? Ub : Vb)[y]; + if (u > O - g.getDate()) + u -= O - g.getDate() + 1, g.setDate(1), 11 > y ? g.setMonth(y + 1) : (g.setMonth(0), g.setFullYear(g.getFullYear() + 1)); + else { + g.setDate(g.getDate() + u); + break; + } + } + y = new Date(g.getFullYear() + 1, 0, 4); + u = q(new Date( + g.getFullYear(), + 0, + 4 + )); + y = q(y); + return 0 >= k(u, g) ? 0 >= k(y, g) ? g.getFullYear() + 1 : g.getFullYear() : g.getFullYear() - 1; + } + a >>>= 0; + b >>>= 0; + c >>>= 0; + e >>>= 0; + var m = z()[e + 40 >> 2 >>> 0]; + e = { Kb: z()[e >> 2 >>> 0], Jb: z()[e + 4 >> 2 >>> 0], cb: z()[e + 8 >> 2 >>> 0], ib: z()[e + 12 >> 2 >>> 0], eb: z()[e + 16 >> 2 >>> 0], $a: z()[e + 20 >> 2 >>> 0], Wa: z()[e + 24 >> 2 >>> 0], Za: z()[e + 28 >> 2 >>> 0], Tb: z()[e + 32 >> 2 >>> 0], Ib: z()[e + 36 >> 2 >>> 0], Lb: m ? V(m) : "" }; + c = V(c); + m = { + "%c": "%a %b %d %H:%M:%S %Y", + "%D": "%m/%d/%y", + "%F": "%Y-%m-%d", + "%h": "%b", + "%r": "%I:%M:%S %p", + "%R": "%H:%M", + "%T": "%H:%M:%S", + "%x": "%m/%d/%y", + "%X": "%H:%M:%S", + "%Ec": "%c", + "%EC": "%C", + "%Ex": "%m/%d/%y", + "%EX": "%H:%M:%S", + "%Ey": "%y", + "%EY": "%Y", + "%Od": "%d", + "%Oe": "%e", + "%OH": "%H", + "%OI": "%I", + "%Om": "%m", + "%OM": "%M", + "%OS": "%S", + "%Ou": "%u", + "%OU": "%U", + "%OV": "%V", + "%Ow": "%w", + "%OW": "%W", + "%Oy": "%y" + }; + for (var r in m) + c = c.replace(new RegExp(r, "g"), m[r]); + var w = "Sunday Monday Tuesday Wednesday Thursday Friday Saturday".split(" "), x = "January February March April May June July August September October November December".split(" "); + m = { "%a": (g) => w[g.Wa].substring(0, 3), "%A": (g) => w[g.Wa], "%b": (g) => x[g.eb].substring(0, 3), "%B": (g) => x[g.eb], "%C": (g) => h((g.$a + 1900) / 100 | 0, 2), "%d": (g) => h(g.ib, 2), "%e": (g) => f(g.ib, 2, " "), "%g": (g) => n(g).toString().substring(2), "%G": (g) => n(g), "%H": (g) => h(g.cb, 2), "%I": (g) => { + g = g.cb; + 0 == g ? g = 12 : 12 < g && (g -= 12); + return h(g, 2); + }, "%j": (g) => { + for (var u = 0, y = 0; y <= g.eb - 1; u += (Y(g.$a + 1900) ? Ub : Vb)[y++]) + ; + return h(g.ib + u, 3); + }, "%m": (g) => h(g.eb + 1, 2), "%M": (g) => h(g.Jb, 2), "%n": () => "\n", "%p": (g) => 0 <= g.cb && 12 > g.cb ? "AM" : "PM", "%S": (g) => h(g.Kb, 2), "%t": () => " ", "%u": (g) => g.Wa || 7, "%U": (g) => h(Math.floor((g.Za + 7 - g.Wa) / 7), 2), "%V": (g) => { + var u = Math.floor((g.Za + 7 - (g.Wa + 6) % 7) / 7); + 2 >= (g.Wa + 371 - g.Za - 2) % 7 && u++; + if (u) + 53 == u && (y = (g.Wa + 371 - g.Za) % 7, 4 == y || 3 == y && Y(g.$a) || (u = 1)); + else { + u = 52; + var y = (g.Wa + 7 - g.Za - 1) % 7; + (4 == y || 5 == y && Y(g.$a % 400 - 1)) && u++; + } + return h(u, 2); + }, "%w": (g) => g.Wa, "%W": (g) => h(Math.floor((g.Za + 7 - (g.Wa + 6) % 7) / 7), 2), "%y": (g) => (g.$a + 1900).toString().substring(2), "%Y": (g) => g.$a + 1900, "%z": (g) => { + g = g.Ib; + var u = 0 <= g; + g = Math.abs(g) / 60; + return (u ? "+" : "-") + String("0000" + (g / 60 * 100 + g % 60)).slice(-4); + }, "%Z": (g) => g.Lb, "%%": () => "%" }; + c = c.replace(/%%/g, "\0\0"); + for (r in m) + c.includes(r) && (c = c.replace(new RegExp(r, "g"), m[r](e))); + c = c.replace(/\0\0/g, "%"); + r = Wb(c); + if (r.length > b) + return 0; + Xb(r, a); + return r.length - 1; + } + function Zb(a) { + try { + a(); + } catch (b) { + M(b); + } + } + function $b(a) { + var b = {}, c; + for (c in a) + (function(e) { + var f = a[e]; + b[e] = "function" == typeof f ? function() { + ac.push(e); + try { + return f.apply(null, arguments); + } finally { + P || (ac.pop() === e || M(), D && 1 === Z && 0 === ac.length && (Z = 0, xa += 1, Zb(bc), "undefined" != typeof Fibers && Fibers.Ub())); + } + } : f; + })(c); + return b; + } + var Z = 0, D = null, cc = 0, ac = [], dc = {}, ec = {}, fc = 0, gc = null, hc = []; + function ha() { + return new Promise((a, b) => { + gc = { resolve: a, reject: b }; + }); + } + function ic() { + var a = Ab(65548), b = a + 12; + A()[a >> 2 >>> 0] = b; + A()[a + 4 >> 2 >>> 0] = b + 65536; + b = ac[0]; + var c = dc[b]; + void 0 === c && (c = fc++, dc[b] = c, ec[c] = b); + b = c; + z()[a + 8 >> 2 >>> 0] = b; + return a; + } + function jc() { + var a = z()[D + 8 >> 2 >>> 0]; + a = N[ec[a]]; + --xa; + return a(); + } + function kc(a) { + if (!P) { + if (0 === Z) { + var b = false, c = false; + a((e = 0) => { + if (!P && (cc = e, b = true, c)) { + Z = 2; + Zb(() => lc(D)); + "undefined" != typeof Browser && Browser.hb.sb && Browser.hb.resume(); + e = false; + try { + var f = jc(); + } catch (q) { + f = q, e = true; + } + var h = false; + if (!D) { + var k = gc; + k && (gc = null, (e ? k.reject : k.resolve)(f), h = true); + } + if (e && !h) + throw f; + } + }); + c = true; + b || (Z = 1, D = ic(), "undefined" != typeof Browser && Browser.hb.sb && Browser.hb.pause(), Zb(() => mc(D))); + } else + 2 === Z ? (Z = 0, Zb(nc), oc(D), D = null, hc.forEach((e) => tb(e))) : M(`invalid state: ${Z}`); + return cc; + } + } + function pc(a) { + return kc((b) => { + a().then(b); + }); + } + W.gb(); + var qc = [null, Oa, Pa, bb, db, eb, ib, jb, kb, lb, mb, nb, ob, pb, qb, rb, sb, yb, zb, Mb, Nb, Ob, Pb, Qb, Tb], tc = { + r: function(a, b, c) { + return pc(async () => { + await B.xb(a, b, c); + }); + }, + b: function(a, b, c) { + a >>>= 0; + new Za(a).gb(b >>> 0, c >>> 0); + $a = a; + ab++; + throw $a; + }, + O: function(a) { + rc(a >>> 0, !F, 1, !ka, 131072, false); + W.lb(); + }, + l: function(a) { + a >>>= 0; + H ? postMessage({ cmd: "cleanupThread", thread: a }) : Ka(a); + }, + I: cb, + i: db, + U: eb, + E: ib, + G: jb, + V: kb, + S: lb, + K: mb, + R: nb, + p: ob, + F: pb, + C: qb, + T: rb, + D: sb, + q: () => true, + A: function(a, b) { + a >>>= 0; + a == b >>> 0 ? setTimeout(() => Ta()) : H ? postMessage({ + targetThread: a, + cmd: "checkMailbox" + }) : (a = W.Qa[a]) && a.postMessage({ cmd: "checkMailbox" }); + }, + M: function() { + return -1; + }, + N: ub, + X: function(a) { + G && W.Qa[a >>> 0].ref(); + }, + u: function(a, b, c) { + a = b + 2097152 >>> 0 < 4194305 - !!a ? (a >>> 0) + 4294967296 * b : NaN; + c >>>= 0; + a = new Date(1e3 * a); + z()[c >> 2 >>> 0] = a.getUTCSeconds(); + z()[c + 4 >> 2 >>> 0] = a.getUTCMinutes(); + z()[c + 8 >> 2 >>> 0] = a.getUTCHours(); + z()[c + 12 >> 2 >>> 0] = a.getUTCDate(); + z()[c + 16 >> 2 >>> 0] = a.getUTCMonth(); + z()[c + 20 >> 2 >>> 0] = a.getUTCFullYear() - 1900; + z()[c + 24 >> 2 >>> 0] = a.getUTCDay(); + a = (a.getTime() - Date.UTC( + a.getUTCFullYear(), + 0, + 1, + 0, + 0, + 0, + 0 + )) / 864e5 | 0; + z()[c + 28 >> 2 >>> 0] = a; + }, + v: function(a, b, c) { + a = b + 2097152 >>> 0 < 4194305 - !!a ? (a >>> 0) + 4294967296 * b : NaN; + c >>>= 0; + a = new Date(1e3 * a); + z()[c >> 2 >>> 0] = a.getSeconds(); + z()[c + 4 >> 2 >>> 0] = a.getMinutes(); + z()[c + 8 >> 2 >>> 0] = a.getHours(); + z()[c + 12 >> 2 >>> 0] = a.getDate(); + z()[c + 16 >> 2 >>> 0] = a.getMonth(); + z()[c + 20 >> 2 >>> 0] = a.getFullYear() - 1900; + z()[c + 24 >> 2 >>> 0] = a.getDay(); + b = (Y(a.getFullYear()) ? wb : xb)[a.getMonth()] + a.getDate() - 1 | 0; + z()[c + 28 >> 2 >>> 0] = b; + z()[c + 36 >> 2 >>> 0] = -(60 * a.getTimezoneOffset()); + b = new Date( + a.getFullYear(), + 6, + 1 + ).getTimezoneOffset(); + var e = new Date(a.getFullYear(), 0, 1).getTimezoneOffset(); + a = (b != e && a.getTimezoneOffset() == Math.min(e, b)) | 0; + z()[c + 32 >> 2 >>> 0] = a; + }, + w: function(a) { + a >>>= 0; + var b = new Date(z()[a + 20 >> 2 >>> 0] + 1900, z()[a + 16 >> 2 >>> 0], z()[a + 12 >> 2 >>> 0], z()[a + 8 >> 2 >>> 0], z()[a + 4 >> 2 >>> 0], z()[a >> 2 >>> 0], 0), c = z()[a + 32 >> 2 >>> 0], e = b.getTimezoneOffset(), f = new Date(b.getFullYear(), 6, 1).getTimezoneOffset(), h = new Date(b.getFullYear(), 0, 1).getTimezoneOffset(), k = Math.min(h, f); + 0 > c ? z()[a + 32 >> 2 >>> 0] = Number(f != h && k == e) : 0 < c != (k == e) && (f = Math.max(h, f), b.setTime(b.getTime() + 6e4 * ((0 < c ? k : f) - e))); + z()[a + 24 >> 2 >>> 0] = b.getDay(); + c = (Y(b.getFullYear()) ? wb : xb)[b.getMonth()] + b.getDate() - 1 | 0; + z()[a + 28 >> 2 >>> 0] = c; + z()[a >> 2 >>> 0] = b.getSeconds(); + z()[a + 4 >> 2 >>> 0] = b.getMinutes(); + z()[a + 8 >> 2 >>> 0] = b.getHours(); + z()[a + 12 >> 2 >>> 0] = b.getDate(); + z()[a + 16 >> 2 >>> 0] = b.getMonth(); + z()[a + 20 >> 2 >>> 0] = b.getYear(); + a = b.getTime() / 1e3; + return sc((U = a, 1 <= +Math.abs(U) ? 0 < U ? +Math.floor(U / 4294967296) >>> 0 : ~~+Math.ceil((U - +(~~U >>> 0)) / 4294967296) >>> 0 : 0)), a >>> 0; + }, + s: yb, + t: zb, + z: function(a, b, c) { + function e(m) { + return (m = m.toTimeString().match(/\(([A-Za-z ]+)\)$/)) ? m[1] : "GMT"; + } + a >>>= 0; + b >>>= 0; + c >>>= 0; + var f = (/* @__PURE__ */ new Date()).getFullYear(), h = new Date(f, 0, 1), k = new Date(f, 6, 1); + f = h.getTimezoneOffset(); + var q = k.getTimezoneOffset(), n = Math.max(f, q); + A()[a >> 2 >>> 0] = 60 * n; + z()[b >> 2 >>> 0] = Number(f != q); + a = e(h); + b = e(k); + a = Bb(a); + b = Bb(b); + q < f ? (A()[c >> 2 >>> 0] = a, A()[c + 4 >> 2 >>> 0] = b) : (A()[c >> 2 >>> 0] = b, A()[c + 4 >> 2 >>> 0] = a); + }, + d: () => { + M(""); + }, + c: function(a, b, c) { + a >>>= 0; + b = Db(b >>> 0, c >>> 0); + return Ha[a].apply(null, b); + }, + k: function(a, b, c) { + a >>>= 0; + b = Db(b >>> 0, c >>> 0); + return Ha[a].apply(null, b); + }, + m: function() { + }, + j: function() { + return Date.now(); + }, + W: () => { + xa += 1; + throw "unwind"; + }, + B: function() { + return 4294901760; + }, + f: () => performance.timeOrigin + performance.now(), + g: function() { + return G ? (init_os(), __toCommonJS(os_exports)).cpus().length : navigator.hardwareConcurrency; + }, + L: function(a, b, c, e) { + W.Pb = b >>> 0; + Ib.length = c; + b = e >>> 0 >> 3; + for (e = 0; e < c; e++) + Ib[e] = da()[b + e >>> 0]; + return (0 > a ? Ha[-a - 1] : qc[a]).apply(null, Ib); + }, + y: function(a) { + a >>>= 0; + var b = v().length; + if (a <= b || 4294901760 < a) + return false; + for (var c = 1; 4 >= c; c *= 2) { + var e = b * (1 + 0.2 / c); + e = Math.min(e, a + 100663296); + var f = Math; + e = Math.max(a, e); + a: { + f = f.min.call(f, 4294901760, e + (65536 - e % 65536) % 65536) - l.buffer.byteLength + 65535 >>> 16; + try { + l.grow(f); + t(); + var h = 1; + break a; + } catch (k) { + } + h = void 0; + } + if (h) + return true; + } + return false; + }, + P: Mb, + Q: Nb, + H: Qa, + h: Ob, + o: Pb, + x: Qb, + n: Tb, + a: l || B.wasmMemory, + J: Yb, + e: function(a, b, c, e) { + return Yb(a >>> 0, b >>> 0, c >>> 0, e >>> 0); + } + }; + (function() { + function a(c, e) { + c = c.exports; + c = $b(c); + N = c = uc(c); + W.mb.push(N.Da); + va.unshift(N.Y); + sa = e; + Ba(); + return c; + } + var b = { a: tc }; + Aa(); + if (B.instantiateWasm) + try { + return B.instantiateWasm(b, a); + } catch (c) { + K("Module.instantiateWasm callback failed with error: " + c), C(c); + } + Ga(b, function(c) { + a(c.instance, c.module); + }).catch(C); + return {}; + })(); + B._OrtInit = (a, b) => (B._OrtInit = N.Z)(a, b); + B._OrtGetLastError = (a, b) => (B._OrtGetLastError = N._)(a, b); + B._OrtCreateSessionOptions = (a, b, c, e, f, h, k, q, n, m) => (B._OrtCreateSessionOptions = N.$)(a, b, c, e, f, h, k, q, n, m); + B._OrtAppendExecutionProvider = (a, b) => (B._OrtAppendExecutionProvider = N.aa)(a, b); + B._OrtAddFreeDimensionOverride = (a, b, c) => (B._OrtAddFreeDimensionOverride = N.ba)(a, b, c); + B._OrtAddSessionConfigEntry = (a, b, c) => (B._OrtAddSessionConfigEntry = N.ca)(a, b, c); + B._OrtReleaseSessionOptions = (a) => (B._OrtReleaseSessionOptions = N.da)(a); + B._OrtCreateSession = (a, b, c) => (B._OrtCreateSession = N.ea)(a, b, c); + B._OrtReleaseSession = (a) => (B._OrtReleaseSession = N.fa)(a); + B._OrtGetInputOutputCount = (a, b, c) => (B._OrtGetInputOutputCount = N.ga)(a, b, c); + B._OrtGetInputName = (a, b) => (B._OrtGetInputName = N.ha)(a, b); + B._OrtGetOutputName = (a, b) => (B._OrtGetOutputName = N.ia)(a, b); + B._OrtFree = (a) => (B._OrtFree = N.ja)(a); + B._OrtCreateTensor = (a, b, c, e, f, h) => (B._OrtCreateTensor = N.ka)(a, b, c, e, f, h); + B._OrtGetTensorData = (a, b, c, e, f) => (B._OrtGetTensorData = N.la)(a, b, c, e, f); + B._OrtReleaseTensor = (a) => (B._OrtReleaseTensor = N.ma)(a); + B._OrtCreateRunOptions = (a, b, c, e) => (B._OrtCreateRunOptions = N.na)(a, b, c, e); + B._OrtAddRunConfigEntry = (a, b, c) => (B._OrtAddRunConfigEntry = N.oa)(a, b, c); + B._OrtReleaseRunOptions = (a) => (B._OrtReleaseRunOptions = N.pa)(a); + B._OrtCreateBinding = (a) => (B._OrtCreateBinding = N.qa)(a); + B._OrtBindInput = (a, b, c) => (B._OrtBindInput = N.ra)(a, b, c); + B._OrtBindOutput = (a, b, c, e) => (B._OrtBindOutput = N.sa)(a, b, c, e); + B._OrtClearBoundOutputs = (a) => (B._OrtClearBoundOutputs = N.ta)(a); + B._OrtReleaseBinding = (a) => (B._OrtReleaseBinding = N.ua)(a); + B._OrtRunWithBinding = (a, b, c, e, f) => (B._OrtRunWithBinding = N.va)(a, b, c, e, f); + B._OrtRun = (a, b, c, e, f, h, k, q) => (B._OrtRun = N.wa)(a, b, c, e, f, h, k, q); + B._OrtEndProfiling = (a) => (B._OrtEndProfiling = N.xa)(a); + B._JsepOutput = (a, b, c) => (B._JsepOutput = N.ya)(a, b, c); + B._JsepGetNodeName = (a) => (B._JsepGetNodeName = N.za)(a); + var Sa = B._pthread_self = () => (Sa = B._pthread_self = N.Aa)(), Ab = B._malloc = (a) => (Ab = B._malloc = N.Ba)(a), oc = B._free = (a) => (oc = B._free = N.Ca)(a); + B.__emscripten_tls_init = () => (B.__emscripten_tls_init = N.Da)(); + var rc = B.__emscripten_thread_init = (a, b, c, e, f, h) => (rc = B.__emscripten_thread_init = N.Fa)(a, b, c, e, f, h); + B.__emscripten_thread_crashed = () => (B.__emscripten_thread_crashed = N.Ga)(); + var Hb = (a, b, c, e) => (Hb = N.Ha)(a, b, c, e), Ra = (a) => (Ra = N.Ia)(a), Ya = B.__emscripten_thread_exit = (a) => (Ya = B.__emscripten_thread_exit = N.Ja)(a), vb = B.__emscripten_check_mailbox = () => (vb = B.__emscripten_check_mailbox = N.Ka)(), sc = (a) => (sc = N.La)(a), Va = (a, b) => (Va = N.Ma)(a, b), Eb = () => (Eb = N.Na)(), Wa = (a) => (Wa = N.Oa)(a), Gb = (a) => (Gb = N.Pa)(a), Xa = B.dynCall_ii = (a, b) => (Xa = B.dynCall_ii = N.Ra)(a, b), mc = (a) => (mc = N.Sa)(a), bc = () => (bc = N.Ta)(), lc = (a) => (lc = N.Ua)(a), nc = () => (nc = N.Va)(); + B.___start_em_js = 917678; + B.___stop_em_js = 917839; + function uc(a) { + a = Object.assign({}, a); + var b = (e) => () => e() >>> 0, c = (e) => (f) => e(f) >>> 0; + a.__errno_location = b(a.__errno_location); + a.pthread_self = b(a.pthread_self); + a.malloc = c(a.malloc); + a.stackSave = b(a.stackSave); + a.stackAlloc = c(a.stackAlloc); + return a; + } + B.keepRuntimeAlive = ya; + B.wasmMemory = l; + B.stackAlloc = Gb; + B.stackSave = Eb; + B.stackRestore = Wa; + B.UTF8ToString = V; + B.stringToUTF8 = hb; + B.lengthBytesUTF8 = fb; + B.ExitStatus = Ia; + B.PThread = W; + var vc; + S = function wc() { + vc || xc(); + vc || (S = wc); + }; + function xc() { + function a() { + if (!vc && (vc = true, B.calledRun = true, !P)) { + H || Ua(va); + fa(B); + if (B.onRuntimeInitialized) + B.onRuntimeInitialized(); + if (!H) { + if (B.postRun) + for ("function" == typeof B.postRun && (B.postRun = [B.postRun]); B.postRun.length; ) { + var b = B.postRun.shift(); + wa.unshift(b); + } + Ua(wa); + } + } + } + if (!(0 < R)) + if (H) + fa(B), H || Ua(va), startWorker(B); + else { + if (B.preRun) + for ("function" == typeof B.preRun && (B.preRun = [B.preRun]); B.preRun.length; ) + ua.unshift(B.preRun.shift()); + Ua(ua); + 0 < R || (B.setStatus ? (B.setStatus("Running..."), setTimeout(function() { + setTimeout( + function() { + B.setStatus(""); + }, + 1 + ); + a(); + }, 1)) : a()); + } + } + if (B.preInit) + for ("function" == typeof B.preInit && (B.preInit = [B.preInit]); 0 < B.preInit.length; ) + B.preInit.pop()(); + xc(); + return moduleArg.ready; + }; + })(); + if (typeof exports === "object" && typeof module === "object") + module.exports = ortWasmThreaded; + else if (typeof define === "function" && define["amd"]) + define([], () => ortWasmThreaded); + } +}); + +// web/lib/wasm/binding/ort-wasm-threaded.worker.js +var require_ort_wasm_threaded_worker = __commonJS({ + "web/lib/wasm/binding/ort-wasm-threaded.worker.js"(exports, module) { + module.exports = '"use strict";var Module={};var ENVIRONMENT_IS_NODE=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string";if(ENVIRONMENT_IS_NODE){var nodeWorkerThreads=require("worker_threads");var parentPort=nodeWorkerThreads.parentPort;parentPort.on("message",data=>onmessage({data:data}));var fs=require("fs");Object.assign(global,{self:global,require:require,Module:Module,location:{href:__filename},Worker:nodeWorkerThreads.Worker,importScripts:f=>(0,eval)(fs.readFileSync(f,"utf8")+"//# sourceURL="+f),postMessage:msg=>parentPort.postMessage(msg),performance:global.performance||{now:Date.now}})}var initializedJS=false;function threadPrintErr(){var text=Array.prototype.slice.call(arguments).join(" ");if(ENVIRONMENT_IS_NODE){fs.writeSync(2,text+"\\n");return}console.error(text)}function threadAlert(){var text=Array.prototype.slice.call(arguments).join(" ");postMessage({cmd:"alert",text:text,threadId:Module["_pthread_self"]()})}var err=threadPrintErr;self.alert=threadAlert;Module["instantiateWasm"]=(info,receiveInstance)=>{var module=Module["wasmModule"];Module["wasmModule"]=null;var instance=new WebAssembly.Instance(module,info);return receiveInstance(instance)};self.onunhandledrejection=e=>{throw e.reason??e};function handleMessage(e){try{if(e.data.cmd==="load"){let messageQueue=[];self.onmessage=e=>messageQueue.push(e);self.startWorker=instance=>{Module=instance;postMessage({"cmd":"loaded"});for(let msg of messageQueue){handleMessage(msg)}self.onmessage=handleMessage};Module["wasmModule"]=e.data.wasmModule;for(const handler of e.data.handlers){Module[handler]=(...args)=>{postMessage({cmd:"callHandler",handler:handler,args:args})}}Module["wasmMemory"]=e.data.wasmMemory;Module["buffer"]=Module["wasmMemory"].buffer;Module["ENVIRONMENT_IS_PTHREAD"]=true;if(typeof e.data.urlOrBlob=="string"){importScripts(e.data.urlOrBlob)}else{var objectUrl=URL.createObjectURL(e.data.urlOrBlob);importScripts(objectUrl);URL.revokeObjectURL(objectUrl)}ortWasmThreaded(Module)}else if(e.data.cmd==="run"){Module["__emscripten_thread_init"](e.data.pthread_ptr,/*isMainBrowserThread=*/0,/*isMainRuntimeThread=*/0,/*canBlock=*/1);Module["__emscripten_thread_mailbox_await"](e.data.pthread_ptr);Module["establishStackSpace"]();Module["PThread"].receiveObjectTransfer(e.data);Module["PThread"].threadInitTLS();if(!initializedJS){initializedJS=true}try{Module["invokeEntryPoint"](e.data.start_routine,e.data.arg)}catch(ex){if(ex!="unwind"){throw ex}}}else if(e.data.cmd==="cancel"){if(Module["_pthread_self"]()){Module["__emscripten_thread_exit"](-1)}}else if(e.data.target==="setimmediate"){}else if(e.data.cmd==="checkMailbox"){if(initializedJS){Module["checkMailbox"]()}}else if(e.data.cmd){err("worker.js received unknown command "+e.data.cmd);err(e.data)}}catch(ex){if(Module["__emscripten_thread_crashed"]){Module["__emscripten_thread_crashed"]()}throw ex}}self.onmessage=handleMessage;\n'; + } +}); + +// web/lib/wasm/wasm-factory.ts +var ortWasmFactory, ortWasmFactoryThreaded, wasm, initialized, initializing, aborted, isMultiThreadSupported, isSimdSupported, getWasmFileName, initializeWebAssembly, getInstance; +var init_wasm_factory = __esm({ + "web/lib/wasm/wasm-factory.ts"() { + "use strict"; + init_node_path(); + if (false) { + ortWasmFactory = null; + } else { + ortWasmFactory = false ? null : require_ort_wasm_simd_jsep(); + } + ortWasmFactoryThreaded = true ? false ? null : require_ort_wasm_simd_threaded_jsep() : ortWasmFactory; + initialized = false; + initializing = false; + aborted = false; + isMultiThreadSupported = (numThreads) => { + if (numThreads === 1) { + return false; + } + if (typeof SharedArrayBuffer === "undefined") { + if (typeof self !== "undefined" && !self.crossOriginIsolated) { + console.warn( + "env.wasm.numThreads is set to " + numThreads + ", but this will not work unless you enable crossOriginIsolated mode. See https://web.dev/cross-origin-isolation-guide/ for more info." + ); + } + return false; + } + if (typeof process !== "undefined" && process.versions && process.versions.node) { + console.warn( + "env.wasm.numThreads is set to " + numThreads + ", however, currently onnxruntime-web does not support multi-threads in Node.js. Please consider using onnxruntime-node for performance critical scenarios." + ); + } + try { + if (typeof MessageChannel !== "undefined") { + new MessageChannel().port1.postMessage(new SharedArrayBuffer(1)); + } + return WebAssembly.validate(new Uint8Array([ + 0, + 97, + 115, + 109, + 1, + 0, + 0, + 0, + 1, + 4, + 1, + 96, + 0, + 0, + 3, + 2, + 1, + 0, + 5, + 4, + 1, + 3, + 1, + 1, + 10, + 11, + 1, + 9, + 0, + 65, + 0, + 254, + 16, + 2, + 0, + 26, + 11 + ])); + } catch (e) { + return false; + } + }; + isSimdSupported = () => { + try { + return WebAssembly.validate(new Uint8Array([ + 0, + 97, + 115, + 109, + 1, + 0, + 0, + 0, + 1, + 4, + 1, + 96, + 0, + 0, + 3, + 2, + 1, + 0, + 10, + 30, + 1, + 28, + 0, + 65, + 0, + 253, + 15, + 253, + 12, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 253, + 186, + 1, + 26, + 11 + ])); + } catch (e) { + return false; + } + }; + getWasmFileName = (useSimd, useThreads) => { + if (useSimd) { + if (false) { + return "ort-training-wasm-simd.wasm"; + } + return useThreads ? "ort-wasm-simd-threaded.wasm" : "ort-wasm-simd.wasm"; + } else { + return useThreads ? "ort-wasm-threaded.wasm" : "ort-wasm.wasm"; + } + }; + initializeWebAssembly = async (flags) => { + if (initialized) { + return Promise.resolve(); + } + if (initializing) { + throw new Error("multiple calls to 'initializeWebAssembly()' detected."); + } + if (aborted) { + throw new Error("previous call to 'initializeWebAssembly()' failed."); + } + initializing = true; + const timeout = flags.initTimeout; + const numThreads = flags.numThreads; + const simd = flags.simd; + const useThreads = isMultiThreadSupported(numThreads); + const useSimd = simd && isSimdSupported(); + const wasmPaths = flags.wasmPaths; + const wasmPrefixOverride = typeof wasmPaths === "string" ? wasmPaths : void 0; + const wasmFileName = getWasmFileName(useSimd, useThreads); + const wasmPathOverride = typeof wasmPaths === "object" ? wasmPaths[wasmFileName] : void 0; + let isTimeout = false; + const tasks = []; + if (timeout > 0) { + tasks.push(new Promise((resolve) => { + setTimeout(() => { + isTimeout = true; + resolve(); + }, timeout); + })); + } + tasks.push(new Promise((resolve, reject) => { + const factory = useThreads ? ortWasmFactoryThreaded : ortWasmFactory; + const config = { + locateFile: (fileName, scriptDirectory) => { + if (useThreads && fileName.endsWith(".worker.js") && typeof Blob !== "undefined") { + return URL.createObjectURL(new Blob( + [ + // This require() function is handled by esbuild plugin to load file content as string. + // eslint-disable-next-line @typescript-eslint/no-require-imports + require_ort_wasm_threaded_worker() + ], + { type: "text/javascript" } + )); + } + if (fileName.endsWith(".wasm")) { + if (wasmPathOverride) { + return wasmPathOverride; + } + const prefix = wasmPrefixOverride ?? scriptDirectory; + if (true) { + if (wasmFileName === "ort-wasm-simd.wasm") { + return prefix + "ort-wasm-simd.jsep.wasm"; + } else if (wasmFileName === "ort-wasm-simd-threaded.wasm") { + return prefix + "ort-wasm-simd-threaded.jsep.wasm"; + } + } + return prefix + wasmFileName; + } + return scriptDirectory + fileName; + } + }; + if (useThreads) { + config.numThreads = numThreads; + if (typeof Blob === "undefined") { + config.mainScriptUrlOrBlob = join(__dirname, "ort-wasm-threaded.js"); + } else { + const scriptSourceCode = `var ortWasmThreaded=${factory.toString()};`; + config.mainScriptUrlOrBlob = new Blob([scriptSourceCode], { type: "text/javascript" }); + } + } + factory(config).then( + // wasm module initialized successfully + (module) => { + initializing = false; + initialized = true; + wasm = module; + resolve(); + }, + // wasm module failed to initialize + (what) => { + initializing = false; + aborted = true; + reject(what); + } + ); + })); + await Promise.race(tasks); + if (isTimeout) { + throw new Error(`WebAssembly backend initializing failed due to timeout: ${timeout}ms`); + } + }; + getInstance = () => { + if (initialized && wasm) { + return wasm; + } + throw new Error("WebAssembly is not initialized yet."); + }; + } +}); + +// web/lib/wasm/wasm-utils.ts +var allocWasmString, iterateExtraOptions, checkLastError; +var init_wasm_utils = __esm({ + "web/lib/wasm/wasm-utils.ts"() { + "use strict"; + init_wasm_factory(); + allocWasmString = (data, allocs) => { + const wasm2 = getInstance(); + const dataLength = wasm2.lengthBytesUTF8(data) + 1; + const dataOffset = wasm2._malloc(dataLength); + wasm2.stringToUTF8(data, dataOffset, dataLength); + allocs.push(dataOffset); + return dataOffset; + }; + iterateExtraOptions = (options, prefix, seen, handler) => { + if (typeof options == "object" && options !== null) { + if (seen.has(options)) { + throw new Error("Circular reference in options"); + } else { + seen.add(options); + } + } + Object.entries(options).forEach(([key, value]) => { + const name = prefix ? prefix + key : key; + if (typeof value === "object") { + iterateExtraOptions(value, name + ".", seen, handler); + } else if (typeof value === "string" || typeof value === "number") { + handler(name, value.toString()); + } else if (typeof value === "boolean") { + handler(name, value ? "1" : "0"); + } else { + throw new Error(`Can't handle extra config type: ${typeof value}`); + } + }); + }; + checkLastError = (message) => { + const wasm2 = getInstance(); + const stack = wasm2.stackSave(); + try { + const paramsOffset = wasm2.stackAlloc(8); + wasm2._OrtGetLastError(paramsOffset, paramsOffset + 4); + const errorCode = wasm2.HEAP32[paramsOffset / 4]; + const errorMessagePointer = wasm2.HEAPU32[paramsOffset / 4 + 1]; + const errorMessage = errorMessagePointer ? wasm2.UTF8ToString(errorMessagePointer) : ""; + throw new Error(`${message} ERROR_CODE: ${errorCode}, ERROR_MESSAGE: ${errorMessage}`); + } finally { + wasm2.stackRestore(stack); + } + }; + } +}); + +// web/lib/wasm/run-options.ts +var setRunOptions; +var init_run_options = __esm({ + "web/lib/wasm/run-options.ts"() { + "use strict"; + init_wasm_factory(); + init_wasm_utils(); + setRunOptions = (options) => { + const wasm2 = getInstance(); + let runOptionsHandle = 0; + const allocs = []; + const runOptions = options || {}; + try { + if (options?.logSeverityLevel === void 0) { + runOptions.logSeverityLevel = 2; + } else if (typeof options.logSeverityLevel !== "number" || !Number.isInteger(options.logSeverityLevel) || options.logSeverityLevel < 0 || options.logSeverityLevel > 4) { + throw new Error(`log serverity level is not valid: ${options.logSeverityLevel}`); + } + if (options?.logVerbosityLevel === void 0) { + runOptions.logVerbosityLevel = 0; + } else if (typeof options.logVerbosityLevel !== "number" || !Number.isInteger(options.logVerbosityLevel)) { + throw new Error(`log verbosity level is not valid: ${options.logVerbosityLevel}`); + } + if (options?.terminate === void 0) { + runOptions.terminate = false; + } + let tagDataOffset = 0; + if (options?.tag !== void 0) { + tagDataOffset = allocWasmString(options.tag, allocs); + } + runOptionsHandle = wasm2._OrtCreateRunOptions( + runOptions.logSeverityLevel, + runOptions.logVerbosityLevel, + !!runOptions.terminate, + tagDataOffset + ); + if (runOptionsHandle === 0) { + checkLastError("Can't create run options."); + } + if (options?.extra !== void 0) { + iterateExtraOptions(options.extra, "", /* @__PURE__ */ new WeakSet(), (key, value) => { + const keyDataOffset = allocWasmString(key, allocs); + const valueDataOffset = allocWasmString(value, allocs); + if (wasm2._OrtAddRunConfigEntry(runOptionsHandle, keyDataOffset, valueDataOffset) !== 0) { + checkLastError(`Can't set a run config entry: ${key} - ${value}.`); + } + }); + } + return [runOptionsHandle, allocs]; + } catch (e) { + if (runOptionsHandle !== 0) { + wasm2._OrtReleaseRunOptions(runOptionsHandle); + } + allocs.forEach((alloc) => wasm2._free(alloc)); + throw e; + } + }; + } +}); + +// web/lib/wasm/session-options.ts +var getGraphOptimzationLevel, getExecutionMode, appendDefaultOptions, setExecutionProviders, setSessionOptions; +var init_session_options = __esm({ + "web/lib/wasm/session-options.ts"() { + "use strict"; + init_wasm_factory(); + init_wasm_utils(); + getGraphOptimzationLevel = (graphOptimizationLevel) => { + switch (graphOptimizationLevel) { + case "disabled": + return 0; + case "basic": + return 1; + case "extended": + return 2; + case "all": + return 99; + default: + throw new Error(`unsupported graph optimization level: ${graphOptimizationLevel}`); + } + }; + getExecutionMode = (executionMode) => { + switch (executionMode) { + case "sequential": + return 0; + case "parallel": + return 1; + default: + throw new Error(`unsupported execution mode: ${executionMode}`); + } + }; + appendDefaultOptions = (options) => { + if (!options.extra) { + options.extra = {}; + } + if (!options.extra.session) { + options.extra.session = {}; + } + const session = options.extra.session; + if (!session.use_ort_model_bytes_directly) { + session.use_ort_model_bytes_directly = "1"; + } + if (options.executionProviders && options.executionProviders.some((ep) => (typeof ep === "string" ? ep : ep.name) === "webgpu")) { + options.enableMemPattern = false; + } + }; + setExecutionProviders = (sessionOptionsHandle, executionProviders, allocs) => { + for (const ep of executionProviders) { + let epName = typeof ep === "string" ? ep : ep.name; + switch (epName) { + case "webnn": + epName = "WEBNN"; + if (typeof ep !== "string") { + const webnnOptions = ep; + if (webnnOptions?.deviceType) { + const keyDataOffset = allocWasmString("deviceType", allocs); + const valueDataOffset = allocWasmString(webnnOptions.deviceType, allocs); + if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) { + checkLastError(`Can't set a session config entry: 'deviceType' - ${webnnOptions.deviceType}.`); + } + } + if (webnnOptions?.numThreads) { + let numThreads = webnnOptions.numThreads; + if (typeof numThreads != "number" || !Number.isInteger(numThreads) || numThreads < 0) { + numThreads = 0; + } + const keyDataOffset = allocWasmString("numThreads", allocs); + const valueDataOffset = allocWasmString(numThreads.toString(), allocs); + if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) { + checkLastError(`Can't set a session config entry: 'numThreads' - ${webnnOptions.numThreads}.`); + } + } + if (webnnOptions?.powerPreference) { + const keyDataOffset = allocWasmString("powerPreference", allocs); + const valueDataOffset = allocWasmString(webnnOptions.powerPreference, allocs); + if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) { + checkLastError( + `Can't set a session config entry: 'powerPreference' - ${webnnOptions.powerPreference}.` + ); + } + } + } + break; + case "webgpu": + epName = "JS"; + if (typeof ep !== "string") { + const webgpuOptions = ep; + if (webgpuOptions?.preferredLayout) { + if (webgpuOptions.preferredLayout !== "NCHW" && webgpuOptions.preferredLayout !== "NHWC") { + throw new Error(`preferredLayout must be either 'NCHW' or 'NHWC': ${webgpuOptions.preferredLayout}`); + } + const keyDataOffset = allocWasmString("preferredLayout", allocs); + const valueDataOffset = allocWasmString(webgpuOptions.preferredLayout, allocs); + if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) { + checkLastError( + `Can't set a session config entry: 'preferredLayout' - ${webgpuOptions.preferredLayout}.` + ); + } + } + } + break; + case "wasm": + case "cpu": + continue; + default: + throw new Error(`not supported execution provider: ${epName}`); + } + const epNameDataOffset = allocWasmString(epName, allocs); + if (getInstance()._OrtAppendExecutionProvider(sessionOptionsHandle, epNameDataOffset) !== 0) { + checkLastError(`Can't append execution provider: ${epName}.`); + } + } + }; + setSessionOptions = (options) => { + const wasm2 = getInstance(); + let sessionOptionsHandle = 0; + const allocs = []; + const sessionOptions = options || {}; + appendDefaultOptions(sessionOptions); + try { + const graphOptimizationLevel = getGraphOptimzationLevel(sessionOptions.graphOptimizationLevel ?? "all"); + const executionMode = getExecutionMode(sessionOptions.executionMode ?? "sequential"); + const logIdDataOffset = typeof sessionOptions.logId === "string" ? allocWasmString(sessionOptions.logId, allocs) : 0; + const logSeverityLevel = sessionOptions.logSeverityLevel ?? 2; + if (!Number.isInteger(logSeverityLevel) || logSeverityLevel < 0 || logSeverityLevel > 4) { + throw new Error(`log serverity level is not valid: ${logSeverityLevel}`); + } + const logVerbosityLevel = sessionOptions.logVerbosityLevel ?? 0; + if (!Number.isInteger(logVerbosityLevel) || logVerbosityLevel < 0 || logVerbosityLevel > 4) { + throw new Error(`log verbosity level is not valid: ${logVerbosityLevel}`); + } + const optimizedModelFilePathOffset = typeof sessionOptions.optimizedModelFilePath === "string" ? allocWasmString(sessionOptions.optimizedModelFilePath, allocs) : 0; + sessionOptionsHandle = wasm2._OrtCreateSessionOptions( + graphOptimizationLevel, + !!sessionOptions.enableCpuMemArena, + !!sessionOptions.enableMemPattern, + executionMode, + !!sessionOptions.enableProfiling, + 0, + logIdDataOffset, + logSeverityLevel, + logVerbosityLevel, + optimizedModelFilePathOffset + ); + if (sessionOptionsHandle === 0) { + checkLastError("Can't create session options."); + } + if (sessionOptions.executionProviders) { + setExecutionProviders(sessionOptionsHandle, sessionOptions.executionProviders, allocs); + } + if (sessionOptions.enableGraphCapture !== void 0) { + if (typeof sessionOptions.enableGraphCapture !== "boolean") { + throw new Error(`enableGraphCapture must be a boolean value: ${sessionOptions.enableGraphCapture}`); + } + const keyDataOffset = allocWasmString("enableGraphCapture", allocs); + const valueDataOffset = allocWasmString(sessionOptions.enableGraphCapture.toString(), allocs); + if (wasm2._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) { + checkLastError( + `Can't set a session config entry: 'enableGraphCapture' - ${sessionOptions.enableGraphCapture}.` + ); + } + } + if (sessionOptions.freeDimensionOverrides) { + for (const [name, value] of Object.entries(sessionOptions.freeDimensionOverrides)) { + if (typeof name !== "string") { + throw new Error(`free dimension override name must be a string: ${name}`); + } + if (typeof value !== "number" || !Number.isInteger(value) || value < 0) { + throw new Error(`free dimension override value must be a non-negative integer: ${value}`); + } + const nameOffset = allocWasmString(name, allocs); + if (wasm2._OrtAddFreeDimensionOverride(sessionOptionsHandle, nameOffset, value) !== 0) { + checkLastError(`Can't set a free dimension override: ${name} - ${value}.`); + } + } + } + if (sessionOptions.extra !== void 0) { + iterateExtraOptions(sessionOptions.extra, "", /* @__PURE__ */ new WeakSet(), (key, value) => { + const keyDataOffset = allocWasmString(key, allocs); + const valueDataOffset = allocWasmString(value, allocs); + if (wasm2._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) { + checkLastError(`Can't set a session config entry: ${key} - ${value}.`); + } + }); + } + return [sessionOptionsHandle, allocs]; + } catch (e) { + if (sessionOptionsHandle !== 0) { + wasm2._OrtReleaseSessionOptions(sessionOptionsHandle); + } + allocs.forEach((alloc) => wasm2._free(alloc)); + throw e; + } + }; + } +}); + +// web/lib/wasm/wasm-common.ts +var tensorDataTypeStringToEnum, tensorDataTypeEnumToString, getTensorElementSize, tensorTypeToTypedArrayConstructor, logLevelStringToEnum, isGpuBufferSupportedType, dataLocationStringToEnum; +var init_wasm_common = __esm({ + "web/lib/wasm/wasm-common.ts"() { + "use strict"; + tensorDataTypeStringToEnum = (type) => { + switch (type) { + case "int8": + return 3 /* int8 */; + case "uint8": + return 2 /* uint8 */; + case "bool": + return 9 /* bool */; + case "int16": + return 5 /* int16 */; + case "uint16": + return 4 /* uint16 */; + case "int32": + return 6 /* int32 */; + case "uint32": + return 12 /* uint32 */; + case "float16": + return 10 /* float16 */; + case "float32": + return 1 /* float */; + case "float64": + return 11 /* double */; + case "string": + return 8 /* string */; + case "int64": + return 7 /* int64 */; + case "uint64": + return 13 /* uint64 */; + default: + throw new Error(`unsupported data type: ${type}`); + } + }; + tensorDataTypeEnumToString = (typeProto) => { + switch (typeProto) { + case 3 /* int8 */: + return "int8"; + case 2 /* uint8 */: + return "uint8"; + case 9 /* bool */: + return "bool"; + case 5 /* int16 */: + return "int16"; + case 4 /* uint16 */: + return "uint16"; + case 6 /* int32 */: + return "int32"; + case 12 /* uint32 */: + return "uint32"; + case 10 /* float16 */: + return "float16"; + case 1 /* float */: + return "float32"; + case 11 /* double */: + return "float64"; + case 8 /* string */: + return "string"; + case 7 /* int64 */: + return "int64"; + case 13 /* uint64 */: + return "uint64"; + default: + throw new Error(`unsupported data type: ${typeProto}`); + } + }; + getTensorElementSize = (dateType) => [void 0, 4, 1, 1, 2, 2, 4, 8, void 0, 1, 2, 8, 4, 8, void 0, void 0, void 0][dateType]; + tensorTypeToTypedArrayConstructor = (type) => { + switch (type) { + case "float16": + return typeof Float16Array !== "undefined" && Float16Array.from ? Float16Array : Uint16Array; + case "float32": + return Float32Array; + case "uint8": + return Uint8Array; + case "int8": + return Int8Array; + case "uint16": + return Uint16Array; + case "int16": + return Int16Array; + case "int32": + return Int32Array; + case "bool": + return Uint8Array; + case "float64": + return Float64Array; + case "uint32": + return Uint32Array; + case "int64": + return BigInt64Array; + case "uint64": + return BigUint64Array; + default: + throw new Error(`unsupported type: ${type}`); + } + }; + logLevelStringToEnum = (logLevel) => { + switch (logLevel) { + case "verbose": + return 0; + case "info": + return 1; + case "warning": + return 2; + case "error": + return 3; + case "fatal": + return 4; + default: + throw new Error(`unsupported logging level: ${logLevel}`); + } + }; + isGpuBufferSupportedType = (type) => type === "float32" || type === "float16" || type === "int32" || type === "int64" || type === "uint32" || type === "uint8" || type === "bool"; + dataLocationStringToEnum = (location) => { + switch (location) { + case "none": + return 0; + case "cpu": + return 1; + case "cpu-pinned": + return 2; + case "texture": + return 3; + case "gpu-buffer": + return 4; + default: + throw new Error(`unsupported data location: ${location}`); + } + }; + } +}); + +// nodejs-ignore:node:fs/promises +var readFile2; +var init_promises = __esm({ + "nodejs-ignore:node:fs/promises"() { + readFile2 = void 0; + } +}); + +// web/lib/wasm/wasm-utils-load-file.ts +var loadFile; +var init_wasm_utils_load_file = __esm({ + "web/lib/wasm/wasm-utils-load-file.ts"() { + "use strict"; + init_fs(); + init_promises(); + loadFile = async (file) => { + if (typeof file === "string") { + if (typeof process !== "undefined" && process.versions && process.versions.node) { + try { + return new Uint8Array(await readFile2(file)); + } catch (e) { + if (e.code === "ERR_FS_FILE_TOO_LARGE") { + const stream = createReadStream(file); + const chunks = []; + for await (const chunk of stream) { + chunks.push(chunk); + } + return new Uint8Array(Buffer.concat(chunks)); + } + throw e; + } + } else { + const response = await fetch(file); + if (!response.ok) { + throw new Error(`failed to load external data file: ${file}`); + } + const contentLengthHeader = response.headers.get("Content-Length"); + const fileSize = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0; + if (fileSize < 1073741824) { + return new Uint8Array(await response.arrayBuffer()); + } else { + if (!response.body) { + throw new Error(`failed to load external data file: ${file}, no response body.`); + } + const reader = response.body.getReader(); + let buffer; + try { + buffer = new ArrayBuffer(fileSize); + } catch (e) { + if (e instanceof RangeError) { + const pages = Math.ceil(fileSize / 65536); + buffer = new WebAssembly.Memory({ initial: pages, maximum: pages }).buffer; + } else { + throw e; + } + } + let offset = 0; + while (true) { + const { done, value } = await reader.read(); + if (done) { + break; + } + const chunkSize = value.byteLength; + const chunk = new Uint8Array(buffer, offset, chunkSize); + chunk.set(value); + offset += chunkSize; + } + return new Uint8Array(buffer, 0, fileSize); + } + } + } else if (file instanceof Blob) { + return new Uint8Array(await file.arrayBuffer()); + } else if (file instanceof Uint8Array) { + return file; + } else { + return new Uint8Array(file); + } + }; + } +}); + +// web/lib/wasm/jsep/log.ts +var logLevelPrefix, doLog, configLogLevel, debug, configureLogger, LOG, LOG_DEBUG; +var init_log = __esm({ + "web/lib/wasm/jsep/log.ts"() { + "use strict"; + init_wasm_common(); + logLevelPrefix = ["V", "I", "W", "E", "F"]; + doLog = (level, message) => { + console.log(`[${logLevelPrefix[level]},${(/* @__PURE__ */ new Date()).toISOString()}]${message}`); + }; + configureLogger = ($configLogLevel, $debug) => { + configLogLevel = $configLogLevel; + debug = $debug; + }; + LOG = (logLevel, msg) => { + const messageLevel = logLevelStringToEnum(logLevel); + const configLevel = logLevelStringToEnum(configLogLevel); + if (messageLevel >= configLevel) { + doLog(messageLevel, typeof msg === "function" ? msg() : msg); + } + }; + LOG_DEBUG = (...args) => { + if (debug) { + LOG(...args); + } + }; + } +}); + +// web/lib/wasm/jsep/tensor-view.ts +var createView; +var init_tensor_view = __esm({ + "web/lib/wasm/jsep/tensor-view.ts"() { + "use strict"; + init_wasm_common(); + createView = (dataBuffer, type) => new (tensorTypeToTypedArrayConstructor(type))(dataBuffer); + } +}); + +// web/lib/wasm/jsep/webgpu/types.ts +var init_types = __esm({ + "web/lib/wasm/jsep/webgpu/types.ts"() { + "use strict"; + } +}); + +// web/lib/wasm/jsep/webgpu/gpu-data-manager.ts +var bucketFreelist, bucketArr, calcNormalizedBufferSize, calcBucketBufferSize, guid, createNewGpuDataId, downloadGpuData, GpuDataManagerImpl, createGpuDataManager; +var init_gpu_data_manager = __esm({ + "web/lib/wasm/jsep/webgpu/gpu-data-manager.ts"() { + "use strict"; + init_log(); + init_types(); + bucketFreelist = /* @__PURE__ */ new Map([ + [64, 250], + [128, 200], + [256, 200], + [512, 200], + [2048, 230], + [4096, 200], + [8192, 50], + [16384, 50], + [32768, 50], + [65536, 50], + [131072, 50], + [262144, 50], + [524288, 50], + [1048576, 50], + [2097152, 30], + [4194304, 20], + [8388608, 10], + [12582912, 10], + [16777216, 10], + [26214400, 15], + [33554432, 22], + [44236800, 2], + [58982400, 6], + // we don't want to cache the bucket sizes below but not caching them + // results in some major performance hits for models like sd-turbo. + [67108864, 6], + [134217728, 6], + [167772160, 6] + ]); + bucketArr = []; + calcNormalizedBufferSize = (size) => Math.ceil(size / 16) * 16; + calcBucketBufferSize = (size) => { + for (let idx = 0; idx < bucketArr.length; idx++) { + const sizeForBucket = bucketArr[idx]; + if (size <= sizeForBucket) { + return sizeForBucket; + } + } + return Math.ceil(size / 16) * 16; + }; + guid = 1; + createNewGpuDataId = () => guid++; + downloadGpuData = async (backend, gpuBuffer, originalSize, getTargetBuffer) => { + const bufferSize = calcNormalizedBufferSize(originalSize); + const gpuReadBuffer = backend.device.createBuffer( + // eslint-disable-next-line no-bitwise + { size: bufferSize, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ } + ); + try { + const commandEncoder = backend.getCommandEncoder(); + backend.endComputePass(); + commandEncoder.copyBufferToBuffer( + gpuBuffer, + 0, + gpuReadBuffer, + 0, + bufferSize + /* size */ + ); + backend.flush(); + await gpuReadBuffer.mapAsync(GPUMapMode.READ); + const arrayBuffer = gpuReadBuffer.getMappedRange(); + if (getTargetBuffer) { + const targetBuffer = getTargetBuffer(); + targetBuffer.set(new Uint8Array(arrayBuffer, 0, originalSize)); + return targetBuffer; + } else { + return new Uint8Array(arrayBuffer.slice(0, originalSize)); + } + } finally { + gpuReadBuffer.destroy(); + } + }; + GpuDataManagerImpl = class { + constructor(backend) { + this.backend = backend; + this.storageCache = /* @__PURE__ */ new Map(); + this.freeBuffers = /* @__PURE__ */ new Map(); + this.freeUniformBuffers = /* @__PURE__ */ new Map(); + this.buffersForUploadingPending = []; + this.buffersPending = []; + this.externalBuffers = /* @__PURE__ */ new Map(); + this.capturedPendingBuffers = /* @__PURE__ */ new Map(); + for (const [key] of bucketFreelist) { + bucketArr.push(key); + this.freeBuffers.set(key, []); + this.freeUniformBuffers.set(key, []); + } + } + upload(id, data) { + const srcArrayBuffer = data.buffer; + const srcOffset = data.byteOffset; + const srcLength = data.byteLength; + const size = calcNormalizedBufferSize(srcLength); + const gpuDataCache = this.storageCache.get(id); + if (!gpuDataCache) { + throw new Error("gpu data for uploading does not exist"); + } + if (gpuDataCache.originalSize !== srcLength) { + throw new Error(`inconsistent data size. gpu data size=${gpuDataCache.originalSize}, data size=${srcLength}`); + } + const gpuBufferForUploading = this.backend.device.createBuffer( + // eslint-disable-next-line no-bitwise + { mappedAtCreation: true, size, usage: GPUBufferUsage.MAP_WRITE | GPUBufferUsage.COPY_SRC } + ); + const arrayBuffer = gpuBufferForUploading.getMappedRange(); + new Uint8Array(arrayBuffer).set(new Uint8Array(srcArrayBuffer, srcOffset, srcLength)); + gpuBufferForUploading.unmap(); + const commandEncoder = this.backend.getCommandEncoder(); + this.backend.endComputePass(); + commandEncoder.copyBufferToBuffer(gpuBufferForUploading, 0, gpuDataCache.gpuData.buffer, 0, size); + LOG_DEBUG("verbose", () => `[WebGPU] GpuDataManager.upload(id=${id})`); + this.buffersForUploadingPending.push(gpuBufferForUploading); + } + memcpy(sourceId, destinationId) { + const sourceGpuDataCache = this.storageCache.get(sourceId); + if (!sourceGpuDataCache) { + throw new Error("source gpu data for memcpy does not exist"); + } + const destinationGpuDataCache = this.storageCache.get(destinationId); + if (!destinationGpuDataCache) { + throw new Error("destination gpu data for memcpy does not exist"); + } + if (sourceGpuDataCache.originalSize !== destinationGpuDataCache.originalSize) { + throw new Error("inconsistent source and destination gpu data size"); + } + const size = calcNormalizedBufferSize(sourceGpuDataCache.originalSize); + const commandEncoder = this.backend.getCommandEncoder(); + this.backend.endComputePass(); + commandEncoder.copyBufferToBuffer( + sourceGpuDataCache.gpuData.buffer, + 0, + destinationGpuDataCache.gpuData.buffer, + 0, + size + ); + } + registerExternalBuffer(buffer, originalSize, previousBuffer) { + let id; + if (previousBuffer) { + id = this.externalBuffers.get(previousBuffer); + if (id === void 0) { + throw new Error("previous buffer is not registered"); + } + if (buffer === previousBuffer) { + LOG_DEBUG( + "verbose", + () => `[WebGPU] GpuDataManager.registerExternalBuffer(size=${originalSize}) => id=${id}, buffer is the same, skip.` + ); + return id; + } else if (this.backend.capturedCommandList.has(this.backend.currentSessionId)) { + throw new Error(`Registering a different external buffer under graph capture mode is not supported yet. + Please use the previous external buffer!`); + } + this.externalBuffers.delete(previousBuffer); + } else { + id = createNewGpuDataId(); + } + this.storageCache.set(id, { gpuData: { id, type: 0 /* default */, buffer }, originalSize }); + this.externalBuffers.set(buffer, id); + LOG_DEBUG( + "verbose", + () => `[WebGPU] GpuDataManager.registerExternalBuffer(size=${originalSize}) => id=${id}, registered.` + ); + return id; + } + unregisterExternalBuffer(buffer) { + const id = this.externalBuffers.get(buffer); + if (id !== void 0) { + this.storageCache.delete(id); + this.externalBuffers.delete(buffer); + LOG_DEBUG("verbose", () => `[WebGPU] GpuDataManager.unregisterExternalBuffer() => id=${id}`); + } + } + // eslint-disable-next-line no-bitwise + create(size, usage = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST) { + const bufferSize = calcBucketBufferSize(size); + let gpuBuffer; + const isStorage = (usage & GPUBufferUsage.STORAGE) === GPUBufferUsage.STORAGE; + const isUniform = (usage & GPUBufferUsage.UNIFORM) === GPUBufferUsage.UNIFORM; + if (isStorage || isUniform) { + const freeBuffers = isStorage ? this.freeBuffers : this.freeUniformBuffers; + const buffers = freeBuffers.get(bufferSize); + if (!buffers) { + gpuBuffer = this.backend.device.createBuffer({ size: bufferSize, usage }); + } else { + if (buffers.length > 0) { + gpuBuffer = buffers.pop(); + } else { + gpuBuffer = this.backend.device.createBuffer({ size: bufferSize, usage }); + } + } + } else { + gpuBuffer = this.backend.device.createBuffer({ size: bufferSize, usage }); + } + const gpuData = { id: createNewGpuDataId(), type: 0 /* default */, buffer: gpuBuffer }; + this.storageCache.set(gpuData.id, { gpuData, originalSize: size }); + LOG_DEBUG("verbose", () => `[WebGPU] GpuDataManager.create(size=${size}) => id=${gpuData.id}`); + return gpuData; + } + get(id) { + return this.storageCache.get(id)?.gpuData; + } + release(id) { + const cachedData = this.storageCache.get(id); + if (!cachedData) { + throw new Error("releasing data does not exist"); + } + LOG_DEBUG("verbose", () => `[WebGPU] GpuDataManager.release(id=${id}), gpuDataId=${cachedData.gpuData.id}`); + this.storageCache.delete(id); + this.buffersPending.push(cachedData.gpuData.buffer); + return cachedData.originalSize; + } + async download(id, getTargetBuffer) { + const cachedData = this.storageCache.get(id); + if (!cachedData) { + throw new Error("data does not exist"); + } + await downloadGpuData(this.backend, cachedData.gpuData.buffer, cachedData.originalSize, getTargetBuffer); + } + refreshPendingBuffers() { + for (const buffer of this.buffersForUploadingPending) { + buffer.destroy(); + } + this.buffersForUploadingPending = []; + if (this.buffersPending.length === 0) { + return; + } + if (this.backend.sessionStatus === "default") { + for (const buffer of this.buffersPending) { + const maxInFreeList = bucketFreelist.get(buffer.size); + if ((buffer.usage & GPUBufferUsage.STORAGE) === GPUBufferUsage.STORAGE) { + const freelist = this.freeBuffers.get(buffer.size) || []; + if (maxInFreeList === void 0 || freelist.length >= maxInFreeList) { + buffer.destroy(); + } else { + freelist.push(buffer); + } + } else if ((buffer.usage & GPUBufferUsage.UNIFORM) === GPUBufferUsage.UNIFORM) { + const freelist = this.freeUniformBuffers.get(buffer.size) || []; + if (maxInFreeList === void 0 || freelist.length >= maxInFreeList) { + buffer.destroy(); + } else { + freelist.push(buffer); + } + } else { + buffer.destroy(); + } + } + this.buffersPending = []; + } else { + let capturedBuffers = this.capturedPendingBuffers.get(this.backend.currentSessionId); + if (!capturedBuffers) { + capturedBuffers = []; + this.capturedPendingBuffers.set(this.backend.currentSessionId, capturedBuffers); + } + for (const buffer of this.buffersPending) { + capturedBuffers.push(buffer); + } + this.buffersPending = []; + } + } + dispose() { + this.freeBuffers.forEach((buffers) => { + buffers.forEach((buffer) => { + buffer.destroy(); + }); + }); + this.freeUniformBuffers.forEach((buffers) => { + buffers.forEach((buffer) => { + buffer.destroy(); + }); + }); + this.storageCache.forEach((storage) => { + storage.gpuData.buffer.destroy(); + }); + this.capturedPendingBuffers.forEach((buffers) => { + buffers.forEach((buffer) => { + buffer.destroy(); + }); + }); + this.storageCache = /* @__PURE__ */ new Map(); + this.freeBuffers = /* @__PURE__ */ new Map(); + this.freeUniformBuffers = /* @__PURE__ */ new Map(); + this.capturedPendingBuffers = /* @__PURE__ */ new Map(); + } + onReleaseSession(sessionId) { + const pendingBuffers = this.capturedPendingBuffers.get(sessionId); + if (pendingBuffers) { + pendingBuffers.forEach((buffer) => { + buffer.destroy(); + }); + this.capturedPendingBuffers.delete(sessionId); + } + } + }; + createGpuDataManager = (...args) => new GpuDataManagerImpl(...args); + } +}); + +// web/lib/wasm/jsep/webgpu/attribute-with-cache-key.ts +var AttributeWithCacheKeyImpl, createAttributeWithCacheKey; +var init_attribute_with_cache_key = __esm({ + "web/lib/wasm/jsep/webgpu/attribute-with-cache-key.ts"() { + "use strict"; + AttributeWithCacheKeyImpl = class { + constructor(attribute) { + Object.assign(this, attribute); + } + get cacheKey() { + if (!this.key) { + this.key = Object.getOwnPropertyNames(this).sort().map((name) => `${this[name]}`).join(";"); + } + return this.key; + } + }; + createAttributeWithCacheKey = (attribute) => new AttributeWithCacheKeyImpl(attribute); + } +}); + +// web/lib/wasm/jsep/util.ts +var MatMulUtil, BroadcastUtil, ShapeUtil, PoolConvUtil, GemmUtil, MIN_CLIP, MAX_CLIP; +var init_util = __esm({ + "web/lib/wasm/jsep/util.ts"() { + "use strict"; + MatMulUtil = class { + /** + * Calculate the expected shape when matrix multiplication + * @param a The shape of tensor A. Should be a tuple of 2 positive integers + * @param b The shape of tensor B. Should be a tuple of 2 positive integers + * @returns The expected shape of the result, or undefined if N/A + */ + static calcMatMulShape(a, b) { + return a[1] !== b[0] ? void 0 : [a[0], b[1]]; + } + }; + BroadcastUtil = class { + /** + * Calculate the expected shape when broadcasting 2 tensors + * @param a The shape of tensor A. Should be an array of positive integers + * @param b The shape of tensor B. Should be an array of positive integers + * @param isMatMul Whether the operation is MatMul + * @returns The expected shape of the result, or undefined if N/A + */ + static calcShape(adims, bdims, isMatMul = false) { + const arank = adims.length; + const brank = bdims.length; + if (arank === 0) { + return bdims; + } + if (brank === 0) { + return adims; + } + const crank = Math.max(adims.length, bdims.length); + const cdims = new Array(crank); + if (isMatMul) { + if (arank < 2 || brank < 2) { + return void 0; + } + const cShapeMatMul = MatMulUtil.calcMatMulShape([adims[arank - 2], adims[arank - 1]], [bdims[brank - 2], bdims[brank - 1]]); + if (cShapeMatMul === void 0) { + return void 0; + } + [cdims[crank - 2], cdims[crank - 1]] = cShapeMatMul; + } + for (let i = isMatMul ? 3 : 1; i <= crank; i++) { + const aLen = arank - i < 0 ? 1 : adims[arank - i]; + const bLen = brank - i < 0 ? 1 : bdims[brank - i]; + if (aLen !== bLen && aLen > 1 && bLen > 1) { + return void 0; + } + const max = Math.max(aLen, bLen); + if (aLen && bLen) { + cdims[crank - i] = Math.max(aLen, bLen); + } else { + if (max > 1) { + return void 0; + } + cdims[crank - i] = 0; + } + } + return cdims; + } + /** + * Determine if a shape is unidirectional broadcastable to another shape + * @param shape The input shape + * @param finalShape The desired shape after broadcasting + */ + static isValidBroadcast(shape, finalShape) { + const inputRank = shape.length; + const finalRank = finalShape.length; + if (inputRank > finalRank) { + return false; + } + for (let i = 1; i <= inputRank; i++) { + if (shape[inputRank - i] !== 1 && shape[inputRank - i] !== finalShape[finalRank - i]) { + return false; + } + } + return true; + } + }; + ShapeUtil = class _ShapeUtil { + /** + * calculate the size (number of elements) + */ + static size(dims) { + return _ShapeUtil.getSizeFromDimensionRange(dims, 0, dims.length); + } + /** + * convert dims corresponding to type change to pack. ex. uint8 data to uint32 + */ + static convertShape(dims, size = 4) { + const rank = dims.length; + if (rank === 0) { + return []; + } + const newDims = new Array(rank); + let i = rank - 1; + while (i >= 0) { + if (dims[i] % size === 0) { + newDims[i] = dims[i] / size; + break; + } + if (size % dims[i] !== 0) { + throw new Error("cannot convert shape"); + } + newDims[i] = 1; + size /= dims[i]; + i--; + } + for (i--; i >= 0; i--) { + newDims[i] = dims[i]; + } + return newDims; + } + /** + * calculate the size (number of elements) from the given axis (inclusive) + */ + static sizeFromDimension(dims, axis) { + if (axis < 0 || axis > dims.length) { + throw new Error(`invalid dimension of ${axis} for sizeFromDimension as Tensor has ${dims.length} dimensions.`); + } + return _ShapeUtil.getSizeFromDimensionRange(dims, axis, dims.length); + } + /** + * calculate the size (number of elements) to the given axis (exclusive) + */ + static sizeToDimension(dims, axis) { + if (axis < 0 || axis > dims.length) { + throw new Error(`invalid dimension of ${axis} for sizeToDimension as Tensor has ${dims.length} dimensions.`); + } + return _ShapeUtil.getSizeFromDimensionRange(dims, 0, axis); + } + /** + * calculate the size (number of elements) from and to the given axis [start, end) + */ + static getSizeFromDimensionRange(dims, start, end) { + let size = 1; + for (let i = start; i < end; i++) { + if (dims[i] < 0) { + throw new Error( + // eslint-disable-next-line max-len + "cannot get valid size from specified dimension range. Most likely the range contains negative values in them." + ); + } + size *= dims[i]; + } + return size; + } + static computeStrides(dims) { + const rank = dims.length; + if (rank === 0) { + return []; + } else if (rank === 1) { + return [1]; + } + const strides = new Array(rank); + strides[rank - 1] = 1; + strides[rank - 2] = dims[rank - 1]; + for (let i = rank - 3; i >= 0; --i) { + strides[i] = strides[i + 1] * dims[i + 1]; + } + return strides; + } + /** + * normailze axis of range [-r, r) into [0, r). + */ + static normalizeAxis(axis, tensorRank) { + if (axis < -tensorRank && axis >= tensorRank) { + throw new Error("unsupported axis for this operation."); + } + return axis < 0 ? axis + tensorRank : axis; + } + static normalizeAxes(axes, tensorRank) { + return axes.map((x) => this.normalizeAxis(x, tensorRank ?? axes.length)); + } + /** + * Sorts a given array based on the indices in the Perm array + * Used in Transpose + * @param a Array to be sorted such as dims or strides + * @param perm Perm given; if null a will be reversed + */ + static sortBasedOnPerm(a, perm) { + if (perm) { + return perm.map((v) => a[v]); + } else { + return a.slice().reverse(); + } + } + /** + * Pads a given shape according to the padding values + * @param dims shape of the Tensor to be padded + * @param pad pad values + */ + static padShape(dims, pad2) { + const rank = dims.length; + return dims.map((v, i) => v + pad2[i] + pad2[i + rank]); + } + /** + * Determines if the two shapes are identical + * @param shape1 + * @param shape2 + */ + static areEqual(shape1, shape2) { + if (shape1.length !== shape2.length) { + return false; + } + return shape1.every((v, i) => v === shape2[i]); + } + }; + PoolConvUtil = class _PoolConvUtil { + /** + * Adjust the kernel, strides, pads to correct rank. Set to default value if not present + * @param isGlobalOperator If true, perform global pooling. + * @param inputDims The input tensor dimension. + * @param kernelShape The size of the kernel along each axis. + * @param strides Stride along each axis. + * @param dilations Dilation along each axis. + * @param pads Padding for the beginning and ending along each axis. + */ + static adjustPoolAttributes(isGlobalOperator, inputDims, kernelShape, strides, dilations, pads) { + if (!isGlobalOperator && kernelShape.length !== inputDims.length - 2) { + throw new Error("length of specified kernel shapes should be 2 less than length of input dimensions"); + } + if (isGlobalOperator) { + for (let dim = 0; dim < inputDims.length - 2; dim++) { + if (dim >= kernelShape.length) { + kernelShape.push(inputDims[dim + 2]); + } else { + kernelShape[dim] = inputDims[dim + 2]; + } + } + } + for (let dim = 0; dim < kernelShape.length; dim++) { + if (dim < strides.length) { + if (strides[dim] < 0) { + throw new Error("strides should be greater than or equal to 1"); + } + } else { + strides.push(1); + } + } + for (let dim = 0; dim < kernelShape.length; dim++) { + if (dim < dilations.length) { + if (dilations[dim] < 0) { + throw new Error("dilations should be greater than or equal to 1"); + } + } else { + dilations.push(1); + } + } + for (let dim = 0; dim < kernelShape.length * 2; dim++) { + if (dim < pads.length) { + if (pads[dim] < 0) { + throw new Error("pad should be greater than or equal to 1"); + } + } else { + pads.push(0); + } + } + for (let dim = 0; dim < kernelShape.length; dim++) { + if (kernelShape[dim] <= 0) { + throw new Error("kernel shapes need to be greater than 0"); + } + if (pads[dim] >= kernelShape[dim] || pads[dim + kernelShape.length] >= kernelShape[dim]) { + throw new Error("pads should be smaller than kernel"); + } + } + } + // adjust pad values based on 'autoPad' attribute + static adjustPadsBasedOnAutoPad(inputDims, strides, dilations, kernelShape, pads, isChannelLast, autoPad) { + if (!autoPad) { + return; + } + if (pads.length !== 2 * (inputDims.length - 2)) { + throw new Error("length of pads should be twice the length of data dimensions"); + } + if (strides.length !== inputDims.length - 2) { + throw new Error("length of strides should be the length of data dimensions"); + } + if (kernelShape.length !== inputDims.length - 2) { + throw new Error("length of kernel shapes should be the length of data dimensions"); + } + for (let dim = 0; dim < inputDims.length - 2; dim++) { + _PoolConvUtil.adjustPadAndReturnShape( + inputDims[dim + (isChannelLast ? 1 : 2)], + strides[dim], + dilations[dim], + kernelShape[dim], + pads, + dim, + dim + inputDims.length - 2, + autoPad + ); + } + } + /** + * Calculate the output shape for Pool ops based on input attributes. (Should be used only for Pool ops) + * @param isGlobalOperator If true, perform global pooling. + * @param inputDims The input tensor dimension. (inputs[0].dims) + * @param strides Stride along each axis. + * @param dilations Dilation along each axis. + * @param kernelShape The size of the kernel along each axis. + * @param pads Padding for the beginning and ending along each axis. + * @param autoPad DEPRECATED attribute supported for legacy models. Specifies how to implicitly calculate pads in each + * dimension. Can take values NOTSET, SAME_UPPER, SAME_LOWER, or VALID. + */ + static computePoolOutputShape(isGlobalOperator, inputDims, strides, dilations, kernelShape, pads, autoPad) { + if (inputDims.length <= 0) { + throw new Error("input shape must be of size greater than 0"); + } + const outputDims = [inputDims[0], inputDims[1]]; + _PoolConvUtil.computeShapeHelper( + isGlobalOperator, + inputDims, + outputDims, + strides, + dilations, + kernelShape, + pads, + autoPad + ); + return outputDims; + } + /** + * Calculate the output shape for Conv op based on input attributes. (Should be used only for Conv op) + * @param inputDims The input tensor dimension. (inputs[0].dims) + * @param filterDims The filter tensor dimension. (inputs[1].dims) + * @param strides Stride along each axis. + * @param kernelShape The size of the kernel along each axis. + * @param pads Padding for the beginning and ending along each axis. + * @param autoPad DEPRECATED attribute supported for legacy models. Specifies how to implicitly calculate pads in each + * dimension. Can take values NOTSET, SAME_UPPER, SAME_LOWER, or VALID. + */ + static computeConvOutputShape(inputDims, filterDims, strides, dilations, kernelShape, pads, autoPad) { + if (inputDims.length <= 0 || filterDims.length <= 0) { + throw new Error("invalid input tensor dims or invalid filter tensor dims"); + } + const outputDims = [inputDims[0], filterDims[0]]; + _PoolConvUtil.computeShapeHelper(false, inputDims, outputDims, strides, dilations, kernelShape, pads, autoPad); + return outputDims; + } + // will compute output shapes for data dimensions ONLY (i.e.) no batch size and channels + // called by computePoolOutputShape() and computeConvOutputShape() + // adjust pads based on 'autoPad' attribute prior to shape computation + static computeShapeHelper(isGlobalOperator, inputDims, outputDims, strides, dilations, kernelShape, pads, autoPad) { + if (isGlobalOperator) { + for (let dim = 0; dim < inputDims.length - 2; dim++) { + outputDims.push(1); + } + } else { + for (let dim = 0; dim < inputDims.length - 2; dim++) { + outputDims.push(_PoolConvUtil.adjustPadAndReturnShape( + inputDims[dim + 2], + strides[dim], + dilations[dim], + kernelShape[dim], + pads, + dim, + dim + inputDims.length - 2, + autoPad + )); + } + } + } + // helper for computeShapeHelper() and adjustPadsBasedOnAutoPad() + // adjusts pad value for given 'autoPad' string and computes output shape along a particular dimension + static adjustPadAndReturnShape(inSize, stride, dilation, kernel, pads, padHeadIndex, padTailIndex, autoPad) { + const dkernel = dilation * (kernel - 1) + 1; + if (autoPad && autoPad !== "NOTSET") { + switch (autoPad) { + case "VALID": + pads[padHeadIndex] = 0; + pads[padTailIndex] = 0; + return Math.floor((inSize - dkernel) / stride + 1); + case "SAME_LOWER": + case "SAME_UPPER": + if (dilation !== 1) { + throw new Error("Dilation not supported for SAME_UPPER or SAME_LOWER"); + } else { + const legacyTargetSize = (inSize + stride - 1) / stride; + const padNeeded = (legacyTargetSize - 1) * stride + kernel - inSize; + pads[padHeadIndex] = autoPad === "SAME_LOWER" ? Math.floor((padNeeded + 1) / 2) : Math.floor(padNeeded / 2); + pads[padTailIndex] = padNeeded - pads[padHeadIndex]; + return Math.floor((inSize + padNeeded - kernel) / stride + 1); + } + default: + throw new Error("Unsupported AutoPad type"); + } + } else { + return Math.floor((inSize + pads[padHeadIndex] + pads[padTailIndex] - dkernel) / stride + 1); + } + } + }; + GemmUtil = class { + // will make sure input shapes are compatible for this op + // and return back the shape of the output in the form of a tuple + // will throw exception if the input shapes are not compatible + static getShapeOfGemmResult(leftShape, transLeft, rightShape, transRight, biasShape) { + if (leftShape.length !== 2 || rightShape.length !== 2) { + throw new Error("shape need to be of size 2"); + } + let M; + let K; + let N; + if (transLeft) { + M = leftShape[1]; + K = leftShape[0]; + } else { + M = leftShape[0]; + K = leftShape[1]; + } + let kDim = -1; + if (transRight) { + N = rightShape[0]; + kDim = 1; + } else { + N = rightShape[1]; + kDim = 0; + } + if (rightShape[kDim] !== K) { + throw new Error("dimension mismatch"); + } + if (M <= 0 || N <= 0 || K <= 0) { + throw new Error("invalid shape specified"); + } + if (biasShape && !BroadcastUtil.isValidBroadcast(biasShape, [M, N])) { + throw new Error("gemm: invalid bias shape for broadcast"); + } + return [M, N, K]; + } + }; + MIN_CLIP = -34028234663852886e22; + MAX_CLIP = 34028234663852886e22; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/common.ts +var WORKGROUP_SIZE, getWgslMappedType, tensorTypeToWsglStorageType, tensorTypeToWsglValueType, createTensorShapeVariables, getMaxComponents, fillVector, castToF32, sumVector, getElementAt, createIndicesHelper, inputVariable, outputVariable, internalVariable, ShaderHelperImpl, createShaderHelper, getBroadcastDims; +var init_common = __esm({ + "web/lib/wasm/jsep/webgpu/ops/common.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + WORKGROUP_SIZE = 64; + getWgslMappedType = (type, components) => { + if (components === 3) { + throw new Error("vec3 has same alignment as vec4, use vec4 instead"); + } + switch (type) { + case 10 /* float16 */: + return components > 1 ? `vec${components}` : "f16"; + case 1 /* float */: + return components > 1 ? `vec${components}` : "f32"; + case 6 /* int32 */: + return components > 1 ? `vec${components}` : "i32"; + case 12 /* uint32 */: + return components > 1 ? `vec${components}` : "u32"; + case 7 /* int64 */: + if (components > 1) { + throw new Error("currently not supported vecX of uint64 yet"); + } + return ["vec2", "i32"]; + case 13 /* uint64 */: + if (components > 1) { + throw new Error("currently not supported vecX of uint64 yet"); + } + return ["vec2", "u32"]; + case 9 /* bool */: + if (components !== 4) { + throw new Error("bool must be vec4"); + } + return ["u32", "vec4"]; + default: + throw new Error(`Unknown data type: ${type}`); + } + }; + tensorTypeToWsglStorageType = (type, components = 1) => { + const mappedType = getWgslMappedType(type, components); + return typeof mappedType === "string" ? mappedType : mappedType[0]; + }; + tensorTypeToWsglValueType = (type, components = 1) => { + const mappedType = getWgslMappedType(type, components); + return typeof mappedType === "string" ? mappedType : mappedType[1]; + }; + createTensorShapeVariables = (...dims) => { + const programUniforms = []; + dims.forEach((dim) => { + if (dim.length !== 0) { + programUniforms.push( + { type: 12 /* uint32 */, data: dim }, + { type: 12 /* uint32 */, data: ShapeUtil.computeStrides(dim) } + ); + } + }); + return programUniforms; + }; + getMaxComponents = (size) => { + if (size % 4 === 0) { + return 4; + } else if (size % 2 === 0) { + return 2; + } + return 1; + }; + fillVector = (dataType = "f32", components, value = "0") => { + if (!components || components === 1) { + return `${dataType}(${value})`; + } + return `vec${components}<${dataType}>(${value})`; + }; + castToF32 = (dataType, components, value) => { + if (dataType === "f32") { + return value; + } + if (components === 1) { + return `f32(${value})`; + } + return `vec${components}(${value})`; + }; + sumVector = (name, components) => { + if (components === 4) { + return `(${name}.x + ${name}.y + ${name}.z + ${name}.w)`; + } else if (components === 2) { + return `(${name}.x + ${name}.y)`; + } else if (components === 3) { + return `(${name}.x + ${name}.y + ${name}.z)`; + } + return name; + }; + getElementAt = (name, index, length, type) => { + if (name.startsWith("uniforms.") && length > 4) { + if (typeof index === "string") { + if (type === "f16") { + return `${name}[(${index}) / 8][(${index}) % 8 / 4][(${index}) % 8 % 4]`; + } else { + return `${name}[(${index}) / 4][(${index}) % 4]`; + } + } else { + if (type === "f16") { + return `${name}[${Math.floor(index / 8)}][${Math.floor(index % 8 / 4)}][${index % 8 % 4}]`; + } else { + return `${name}[${Math.floor(index / 4)}][${index % 4}]`; + } + } + } else { + return length > 1 ? `${name}[${index}]` : name; + } + }; + createIndicesHelper = (name, tensorType, shapeOrRank, usage, components) => { + const useUniform = typeof shapeOrRank === "number"; + const rank = useUniform ? shapeOrRank : shapeOrRank.length; + const rankIdentity = [...new Array(rank).keys()]; + const indicesType = rank < 2 ? "u32" : rank <= 4 ? `vec${rank}` : `array`; + const mappedType = getWgslMappedType(tensorType, components); + const valueType = typeof mappedType === "string" ? mappedType : mappedType[1]; + const storageType = typeof mappedType === "string" ? mappedType : mappedType[0]; + const type = { indices: indicesType, value: valueType, storage: storageType, tensor: tensorType }; + const normalizeDim = (dim) => typeof dim === "string" ? dim : `${dim}u`; + const implementationUsed = { + offsetToIndices: false, + indicesToOffset: false, + broadcastedIndicesToOffset: false, + set: false, + setByIndices: false, + get: false, + getByIndices: false + }; + const uniformPrefix = useUniform ? "uniforms." : ""; + const shape = `${uniformPrefix}${name}_shape`; + const strides = `${uniformPrefix}${name}_strides`; + let o2iSnippet = ""; + for (let i = 0; i < rank - 1; i++) { + o2iSnippet += ` + let dim${i} = current / ${getElementAt(strides, i, rank)}; + let rest${i} = current % ${getElementAt(strides, i, rank)}; + indices[${i}] = dim${i}; + current = rest${i}; + `; + } + o2iSnippet += `indices[${rank - 1}] = current;`; + const offsetToIndicesImplementation = rank < 2 ? "" : ` + fn o2i_${name}(offset: u32) -> ${type.indices} { + var indices: ${type.indices}; + var current = offset; + ${o2iSnippet} + return indices; + }`; + const offsetToIndices = (varOffset) => { + implementationUsed.offsetToIndices = true; + return rank < 2 ? varOffset : `o2i_${name}(${varOffset})`; + }; + const offsets = []; + if (rank >= 2) { + for (let i = rank - 1; i >= 0; i--) { + offsets.push(`${getElementAt(strides, i, rank)} * (indices[${i}])`); + } + } + const indicesToOffsetImplementation = rank < 2 ? "" : ` + fn i2o_${name}(indices: ${type.indices}) -> u32 { + return ${offsets.join("+")}; + }`; + const indicesToOffset = (varIndices) => { + implementationUsed.indicesToOffset = true; + return rank < 2 ? varIndices : `i2o_${name}(${varIndices})`; + }; + const indices = (...init2) => rank === 0 ? "0u" : `${type.indices}(${init2.map(normalizeDim).join(",")})`; + const indicesGet = (varIndices, idx) => { + if (rank < 2) { + return `${varIndices}`; + } else { + return `${getElementAt(varIndices, idx, rank)}`; + } + }; + const indicesSet = (varIndices, idx, value) => { + if (rank < 2) { + return `${varIndices}=${value};`; + } else { + return `${getElementAt(varIndices, idx, rank)}=${value};`; + } + }; + const broadcastedIndicesToOffsetImplementation = {}; + const broadcastedIndicesToOffset = (varIndices, output) => { + implementationUsed.broadcastedIndicesToOffset = true; + const implKey = `${output.name}broadcastedIndicesTo${name}Offset`; + if (implKey in broadcastedIndicesToOffsetImplementation) { + return `${implKey}(${varIndices})`; + } + const offsets2 = []; + for (let i = rank - 1; i >= 0; i--) { + const idx = output.indicesGet("outputIndices", i + output.rank - rank); + offsets2.push(`${indicesGet(strides, i)} * (${idx} % ${indicesGet(shape, i)})`); + } + broadcastedIndicesToOffsetImplementation[implKey] = `fn ${implKey}(outputIndices: ${output.type.indices}) -> u32 { + return ${offsets2.length > 0 ? offsets2.join("+") : "0u"}; + }`; + return `${implKey}(${varIndices})`; + }; + const setByOffset = (offset, value) => (() => { + if (type.storage === type.value) { + return `${name}[${offset}]=${value};`; + } else if (type.storage === "vec2" && type.value === "i32") { + return `${name}[${offset}]=vec2(u32(${value}), select(0u, 0xFFFFFFFFu, ${value} < 0));`; + } else if (type.storage === "vec2" && type.value === "u32") { + return `${name}[${offset}]=vec2(u32(${value}), 0u);`; + } else if (type.storage === "u32" && type.value === "vec4") { + return `${name}[${offset}]=dot(vec4(0x1, 0x100, 0x10000, 0x1000000), vec4(${value}));`; + } else { + throw new Error(`not supported combination of storage type ${type.storage} and value type ${type.value} yet`); + } + })(); + const getByOffset = (offset) => (() => { + if (type.storage === type.value) { + return `${name}[${offset}]`; + } else if (type.storage === "vec2" && type.value === "i32") { + return `i32(${name}[${offset}].x)`; + } else if (type.storage === "vec2" && type.value === "u32") { + return `u32(${name}[${offset}].x)`; + } else if (type.storage === "u32" && type.value === "vec4") { + return `vec4(bool(${name}[${offset}] & 0xFFu), bool(${name}[${offset}] & 0xFF00u), bool(${name}[${offset}] & 0xFF0000u), bool(${name}[${offset}] & 0xFF000000u))`; + } else { + throw new Error(`not supported combination of storage type ${type.storage} and value type ${type.value} yet`); + } + })(); + const getByIndicesImplementation = rank < 2 ? "" : ` + fn get_${name}ByIndices(indices: ${type.indices}) -> ${valueType} { + return ${getByOffset(`i2o_${name}(indices)`)}; + }`; + const getImplementation = rank < 2 ? "" : (() => { + const functionParams = rankIdentity.map((i) => `d${i}: u32`).join(", "); + const dimsParams = rankIdentity.map((i) => `d${i}`).join(", "); + return ` + fn get_${name}(${functionParams}) -> ${valueType} { + return get_${name}ByIndices(${indices(dimsParams)}); + }`; + })(); + const get = (...indices2) => { + if (indices2.length !== rank) { + throw new Error(`indices length must be ${rank}`); + } + const normalizedIndices = indices2.map(normalizeDim).join(","); + if (rank === 0) { + return getByOffset("0u"); + } else if (rank === 1) { + return getByOffset(normalizedIndices[0]); + } else { + implementationUsed.get = true; + implementationUsed.getByIndices = true; + implementationUsed.indicesToOffset = true; + return `get_${name}(${normalizedIndices})`; + } + }; + const getByIndices = (varIndices) => { + if (rank < 2) { + return getByOffset(varIndices); + } else { + implementationUsed.getByIndices = true; + implementationUsed.indicesToOffset = true; + return `get_${name}ByIndices(${varIndices})`; + } + }; + const setByIndicesImplementation = rank < 2 ? "" : ` + fn set_${name}ByIndices(indices: ${type.indices}, value: ${valueType}) { + ${setByOffset(`i2o_${name}(indices)`, "value")} + }`; + const setImplementation = rank < 2 ? "" : (() => { + const functionParams = rankIdentity.map((i) => `d${i}: u32`).join(", "); + const dimsParams = rankIdentity.map((i) => `d${i}`).join(", "); + return ` + fn set_${name}(${functionParams}, value: ${valueType}) { + set_${name}ByIndices(${indices(dimsParams)}, value); + }`; + })(); + const set = (...indicesAndValue) => { + if (indicesAndValue.length !== rank + 1) { + throw new Error(`indices length must be ${rank}`); + } + const value = indicesAndValue[rank]; + if (typeof value !== "string") { + throw new Error("value must be string"); + } + const normalizedIndices = indicesAndValue.slice(0, rank).map(normalizeDim).join(","); + if (rank === 0) { + return setByOffset("0u", value); + } else if (rank === 1) { + return setByOffset(normalizedIndices[0], value); + } else { + implementationUsed.set = true; + implementationUsed.setByIndices = true; + implementationUsed.indicesToOffset = true; + return `set_${name}(${normalizedIndices}, ${value})`; + } + }; + const setByIndices = (varIndices, value) => { + if (rank < 2) { + return setByOffset(varIndices, value); + } else { + implementationUsed.setByIndices = true; + implementationUsed.indicesToOffset = true; + return `set_${name}ByIndices(${varIndices}, ${value});`; + } + }; + const impl = () => { + const impls = []; + let needShapeStrides = false; + if (implementationUsed.offsetToIndices) { + impls.push(offsetToIndicesImplementation); + needShapeStrides = true; + } + if (implementationUsed.indicesToOffset) { + impls.push(indicesToOffsetImplementation); + needShapeStrides = true; + } + if (implementationUsed.broadcastedIndicesToOffset) { + Object.values(broadcastedIndicesToOffsetImplementation).forEach((impl2) => impls.push(impl2)); + needShapeStrides = true; + } + if (implementationUsed.set) { + impls.push(setImplementation); + needShapeStrides = true; + } + if (implementationUsed.setByIndices) { + impls.push(setByIndicesImplementation); + needShapeStrides = true; + } + if (implementationUsed.get) { + impls.push(getImplementation); + needShapeStrides = true; + } + if (implementationUsed.getByIndices) { + impls.push(getByIndicesImplementation); + needShapeStrides = true; + } + if (!useUniform && needShapeStrides) { + impls.unshift( + `const ${shape} = ${type.indices}(${shapeOrRank.join(",")});`, + `const ${strides} = ${type.indices}(${ShapeUtil.computeStrides(shapeOrRank).join(",")});` + ); + } + return impls.join("\n"); + }; + return { + impl, + type, + offsetToIndices, + indicesToOffset, + broadcastedIndicesToOffset, + indices, + indicesGet, + indicesSet, + set, + setByOffset, + setByIndices, + get, + getByOffset, + getByIndices, + // isVec4, + usage, + name, + strides, + shape, + rank + }; + }; + inputVariable = (name, type, shapeOrRank, components = 1) => createIndicesHelper(name, type, shapeOrRank, "input", components); + outputVariable = (name, type, shapeOrRank, components = 1) => createIndicesHelper(name, type, shapeOrRank, "output", components); + internalVariable = (name, type, shapeOrRank, components = 1) => createIndicesHelper(name, type, shapeOrRank, "internal", components); + ShaderHelperImpl = class { + constructor(normalizedDispatchGroup, limits) { + this.normalizedDispatchGroup = normalizedDispatchGroup; + this.limits = limits; + this.internalVariables = []; + this.variables = []; + this.uniforms = []; + this.variableIndex = 0; + } + guardAgainstOutOfBoundsWorkgroupSizes(size) { + const sizeInCode = typeof size === "number" ? `${size}u` : size; + return `if (global_idx >= ${sizeInCode}) { return; }`; + } + mainStart(workgroupSize = WORKGROUP_SIZE) { + const workgroupSizeX = typeof workgroupSize === "number" ? workgroupSize : workgroupSize[0]; + const workgroupSizeY = typeof workgroupSize === "number" ? 1 : workgroupSize[1]; + const workgroupSizeZ = typeof workgroupSize === "number" ? 1 : workgroupSize[2]; + if (workgroupSizeX > this.limits.maxComputeWorkgroupSizeX || workgroupSizeY > this.limits.maxComputeWorkgroupSizeY || workgroupSizeZ > this.limits.maxComputeWorkgroupSizeZ) { + throw new Error(`workgroup size [${workgroupSizeX}, ${workgroupSizeY}, ${workgroupSizeZ}] exceeds the maximum workgroup size [${this.limits.maxComputeWorkgroupSizeX}, ${this.limits.maxComputeWorkgroupSizeY}, ${this.limits.maxComputeWorkgroupSizeZ}].`); + } + if (workgroupSizeX * workgroupSizeY * workgroupSizeZ > this.limits.maxComputeInvocationsPerWorkgroup) { + throw new Error(`workgroup size [${workgroupSizeX}, ${workgroupSizeY}, ${workgroupSizeZ}] exceeds the maximum workgroup invocations ${this.limits.maxComputeInvocationsPerWorkgroup}.`); + } + const is1DimensionDispatch = this.normalizedDispatchGroup[1] === 1 && this.normalizedDispatchGroup[2] === 1; + const paramList = is1DimensionDispatch ? `@builtin(global_invocation_id) global_id : vec3, + @builtin(workgroup_id) workgroup_id : vec3, + @builtin(local_invocation_id) local_id : vec3` : `@builtin(global_invocation_id) global_id : vec3, + @builtin(local_invocation_id) local_id : vec3, + @builtin(local_invocation_index) local_idx : u32, + @builtin(workgroup_id) workgroup_id : vec3, + @builtin(num_workgroups) num_workgroups : vec3`; + const globalIdxDefinition = is1DimensionDispatch ? "let global_idx = global_id.x; let local_idx = local_id.x;" : `let global_idx = (workgroup_id.z * num_workgroups[0] * num_workgroups[1] + + workgroup_id.y * num_workgroups[0] + workgroup_id.x) * ${workgroupSizeX * workgroupSizeY * workgroupSizeZ}u + local_idx;`; + return `@compute @workgroup_size(${workgroupSizeX}, ${workgroupSizeY}, ${workgroupSizeZ}) + fn main(${paramList}) { + ${globalIdxDefinition} + `; + } + appendVariableUniforms(variable) { + if (variable.rank !== 0) { + if (variable.shape.startsWith("uniforms.")) { + this.uniforms.push({ name: variable.shape.replace("uniforms.", ""), type: "u32", length: variable.rank }); + } + if (variable.strides.startsWith("uniforms.")) { + this.uniforms.push({ name: variable.strides.replace("uniforms.", ""), type: "u32", length: variable.rank }); + } + } + } + declareVariable(variable, bindingIndex) { + if (variable.usage === "internal") { + throw new Error("cannot use internal variable with declareVariable(). use registerInternalVariables() instead."); + } + this.variables.push(variable); + this.appendVariableUniforms(variable); + const access = variable.usage === "input" ? "read" : "read_write"; + const storageType = variable.type.storage; + return `@group(0) @binding(${bindingIndex}) var ${variable.name}: array<${storageType}>;`; + } + declareVariables(...variables) { + return variables.map((v) => this.declareVariable(v, this.variableIndex++)).join("\n"); + } + registerInternalVariable(variable) { + if (variable.usage !== "internal") { + throw new Error( + "cannot use input or output variable with registerInternalVariable(). use declareVariables() instead." + ); + } + this.internalVariables.push(variable); + this.appendVariableUniforms(variable); + } + registerInternalVariables(...variables) { + variables.forEach((v) => this.registerInternalVariable(v)); + return this; + } + registerUniform(name, type, length = 1) { + this.uniforms.push({ name, type, length }); + return this; + } + registerUniforms(additionalUniforms) { + this.uniforms = this.uniforms.concat(additionalUniforms); + return this; + } + uniformDeclaration() { + if (this.uniforms.length === 0) { + return ""; + } + const uniformSnippets = []; + for (const { name, type, length } of this.uniforms) { + if (length && length > 4) { + if (type === "f16") { + uniformSnippets.push(`@align(16) ${name}:array, ${Math.ceil(length / 8)}>`); + } else { + uniformSnippets.push(`${name}:array, ${Math.ceil(length / 4)}>`); + } + } else { + const typeTemp = length == null || length === 1 ? type : `vec${length}<${type}>`; + uniformSnippets.push(`${name}:${typeTemp}`); + } + } + return ` + struct Uniforms { ${uniformSnippets.join(", ")} }; + @group(0) @binding(${this.variableIndex}) var uniforms: Uniforms;`; + } + /** + * Get additional implementation that needs to be added to the shader source. + */ + get additionalImplementations() { + return this.uniformDeclaration() + this.variables.map((i) => i.impl()).join("\n") + this.internalVariables.map((i) => i.impl()).join("\n"); + } + /** + * Get the variable info of the shader program. + */ + get variablesInfo() { + if (this.uniforms.length === 0) { + return void 0; + } + const uniformWgslTypeToDataType = (type) => [ + 12 /* uint32 */, + 10 /* float16 */, + 1 /* float */, + 6 /* int32 */ + ][["u32", "f16", "f32", "i32"].indexOf(type)]; + return this.uniforms.map((u) => [uniformWgslTypeToDataType(u.type), u.length ?? 1]); + } + }; + createShaderHelper = (dispatchGroup, limits) => new ShaderHelperImpl(dispatchGroup, limits); + getBroadcastDims = (inShape, outShape) => { + const inRank = inShape.length; + const dims = []; + for (let i = 0; i < inRank; i++) { + const dim = inRank - 1 - i; + const a = inShape[dim] || 1; + const b = outShape[outShape.length - 1 - i] || 1; + if (b > 1 && a === 1) { + dims.unshift(dim); + } + } + return dims; + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/transpose.ts +var validateInputs, getAdjustedPerm, getOutputShape, permFunctionBody, createTransposeProgramInfo, transpose, parseTransposeAttributes; +var init_transpose = __esm({ + "web/lib/wasm/jsep/webgpu/ops/transpose.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_attribute_with_cache_key(); + init_common(); + validateInputs = (inputs) => { + if (!inputs || inputs.length !== 1) { + throw new Error("Transpose requires 1 input."); + } + }; + getAdjustedPerm = (inputRank, perm) => perm && perm.length !== inputRank ? [...new Array(inputRank).keys()].reverse() : perm; + getOutputShape = (inputShape, perm) => ShapeUtil.sortBasedOnPerm(inputShape, getAdjustedPerm(inputShape.length, perm)); + permFunctionBody = (perm, rank, input, output) => { + const reverseFunc = []; + reverseFunc.push(`fn perm(i: ${output.type.indices}) -> ${input.type.indices} { + var a: ${input.type.indices};`); + for (let i = 0; i < rank; ++i) { + reverseFunc.push(input.indicesSet("a", perm[i], `i[${i}]`)); + } + reverseFunc.push("return a;}"); + return reverseFunc.join("\n"); + }; + createTransposeProgramInfo = (inputTensor, permAttr) => { + const inputDataType = inputTensor.dataType; + const inputRank = inputTensor.dims.length; + const perm = getAdjustedPerm(inputRank, permAttr); + const outputShape = getOutputShape(inputTensor.dims, perm); + const output = outputVariable("output", inputDataType, outputShape.length); + const input = inputVariable("a", inputDataType, inputRank); + const getShaderSource = (shaderHelper) => ` + ${shaderHelper.registerUniform("output_size", "u32").declareVariables(input, output)} + + ${permFunctionBody(perm, inputRank, input, output)} + + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")} + + let indices = ${output.offsetToIndices("global_idx")}; + let aIndices = perm(indices); + + ${output.setByOffset("global_idx", input.getByIndices("aIndices"))} + }`; + return { + name: "Transpose", + shaderCache: { hint: `${permAttr}`, inputDependencies: ["rank"] }, + getRunData: (inputs) => { + const outputSize = ShapeUtil.size(outputShape); + return { + outputs: [{ dims: outputShape, dataType: inputs[0].dataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms: [{ type: 12 /* uint32 */, data: outputSize }, ...createTensorShapeVariables(inputs[0].dims, outputShape)] + }; + }, + getShaderSource + }; + }; + transpose = (context, attributes) => { + validateInputs(context.inputs); + context.compute(createTransposeProgramInfo(context.inputs[0], attributes.perm)); + }; + parseTransposeAttributes = (attributes) => createAttributeWithCacheKey({ perm: attributes.perm }); + } +}); + +// web/lib/wasm/jsep/webgpu/ops/reduce-shared.ts +var reduceOps, reduceSharedOps, reduceInitValues, reduceOutputValues, getInnerMostAxes, computeOutAndReduceShapes, expandShapeToKeepDim, areAxesInnerMostDims, getAxesPermutation, createReduceSharedProgramInfo, reduceCommon, reduceMeanShared, reduceL1Shared, reduceL2Shared, reduceLogSumExpShared, reduceMaxShared, reduceMinShared, reduceProdShared, reduceSumShared, reduceSumSquareShared, reduceLogSumShared; +var init_reduce_shared = __esm({ + "web/lib/wasm/jsep/webgpu/ops/reduce-shared.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_common(); + init_reduce(); + init_transpose(); + reduceOps = { + max: "select(bestValue, candidate, candidate > bestValue)", + min: "select(bestValue, candidate, candidate < bestValue)", + mean: "bestValue + candidate", + sum: "bestValue + candidate", + prod: "bestValue * candidate", + sumSquare: "bestValue + candidate * candidate", + logSumExp: "bestValue + exp(candidate)", + l1: "bestValue + abs(candidate)", + l2: "bestValue + candidate * candidate", + logSum: "bestValue + candidate" + }; + reduceSharedOps = { + max: "select(bestValue, candidate, candidate > bestValue)", + min: "select(bestValue, candidate, candidate < bestValue)", + mean: "bestValue + candidate", + sum: "bestValue + candidate", + prod: "bestValue * candidate", + sumSquare: "bestValue + candidate", + logSumExp: "bestValue + candidate", + l1: "bestValue + candidate", + l2: "bestValue + candidate", + logSum: "bestValue + candidate" + }; + reduceInitValues = { + max: "_A[offset]", + min: "_A[offset]", + mean: "0", + sum: "0", + prod: "1", + sumSquare: "0", + logSumExp: "0", + l1: "0", + l2: "0", + logSum: "0" + }; + reduceOutputValues = { + max: "bestValue", + min: "bestValue", + sum: "bestValue", + prod: "bestValue", + sumSquare: "bestValue", + logSumExp: "log(bestValue)", + l1: "bestValue", + l2: "sqrt(bestValue)", + logSum: "log(bestValue)" + }; + getInnerMostAxes = (numInnerAxes, rank) => { + const res = []; + for (let i = rank - numInnerAxes; i < rank; ++i) { + res.push(i); + } + return res; + }; + computeOutAndReduceShapes = (shape, axes) => { + const outputShape = []; + const rank = shape.length; + for (let dim = 0; dim < rank; dim++) { + if (axes.indexOf(dim) === -1) { + outputShape.push(shape[dim]); + } + } + const reduceShape = axes.map((dim) => shape[dim]); + return [outputShape, reduceShape]; + }; + expandShapeToKeepDim = (shape, axes) => { + const rank = shape.length + axes.length; + const expandShape = []; + let shapeIdx = 0; + for (let dim = 0; dim < rank; dim++) { + if (axes.indexOf(dim) === -1) { + expandShape.push(shape[shapeIdx++]); + } else { + expandShape.push(1); + } + } + return expandShape; + }; + areAxesInnerMostDims = (axes, rank) => { + for (let i = 0; i < axes.length; ++i) { + if (axes[axes.length - i - 1] !== rank - 1 - i) { + return false; + } + } + return true; + }; + getAxesPermutation = (axes, rank) => { + const res = []; + if (!areAxesInnerMostDims(axes, rank)) { + for (let i = 0; i < rank; ++i) { + if (axes.indexOf(i) === -1) { + res.push(i); + } + } + axes.forEach((axis) => res.push(axis)); + } + return res; + }; + createReduceSharedProgramInfo = (name, shaderCache, inputs, reduceType, outputDataType, outputShape, reduceShape) => { + const inputShape = inputs[0].dims; + const outputSize = ShapeUtil.size(outputShape); + const reduceSize = ShapeUtil.size(reduceShape); + const input = inputVariable("_A", inputs[0].dataType, inputShape); + const output = outputVariable("output", outputDataType, outputShape); + const workgroupSize = 32; + const sharedMemorySnippet = ` + var aBestValues : array; + `; + const getShaderSource = (shaderHelper) => ` + ${shaderHelper.registerUniform("reduceSize", "u32").declareVariables(input, output)} + ${sharedMemorySnippet} + fn DIV_CEIL(a : u32, b : u32) -> u32 { + return ((a - 1u) / b + 1u); + } + ${shaderHelper.mainStart(workgroupSize)} + + let outputIndex = global_idx / ${workgroupSize}; + let offset = outputIndex * uniforms.reduceSize; + + var bestValue = f32(${reduceInitValues[reduceType]}); + let Length = uniforms.reduceSize; + for (var k = local_idx; k < Length; k = k + ${workgroupSize}) { + let candidate = f32(${input.getByOffset("offset + k")}); + bestValue = ${reduceOps[reduceType]}; + } + aBestValues[local_idx] = bestValue; + workgroupBarrier(); + + var reduceSize = min(Length, ${workgroupSize}u); + for (var currentSize = reduceSize / 2u; reduceSize > 1u; + currentSize = reduceSize / 2u) { + let interval = DIV_CEIL(reduceSize, 2u); + if (local_idx < currentSize) { + let candidate = aBestValues[local_idx + interval]; + bestValue = ${reduceSharedOps[reduceType]}; + aBestValues[local_idx] = bestValue; + } + reduceSize = interval; + workgroupBarrier(); + } + + if (local_idx == 0u) { + ${output.setByOffset( + "outputIndex", + `${reduceType === "mean" ? `${output.type.storage}(bestValue / f32(uniforms.reduceSize))` : `${output.type.storage}(${reduceOutputValues[reduceType]})`}` + )}; + } + }`; + return { + name, + shaderCache, + getShaderSource, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: outputDataType }], + dispatchGroup: { x: outputSize }, + programUniforms: [{ type: 12 /* uint32 */, data: reduceSize }] + }) + }; + }; + reduceCommon = (context, name, attributes, reduceType) => { + const updatedAttributes = context.inputs.length === 1 ? attributes : createReduceAttributesFromInputs(context.inputs, attributes); + let updatedAxes = updatedAttributes.axes; + if (updatedAxes.length === 0 && !updatedAttributes.noopWithEmptyAxes) { + updatedAxes = context.inputs[0].dims.map((_dim, i) => i); + } + const normalizeAxes = ShapeUtil.normalizeAxes(updatedAxes, context.inputs[0].dims.length); + let axes = normalizeAxes; + let input = context.inputs[0]; + const permutedAxes = getAxesPermutation(axes, context.inputs[0].dims.length); + if (permutedAxes.length > 0) { + input = context.compute( + createTransposeProgramInfo(context.inputs[0], permutedAxes), + { inputs: [0], outputs: [-1] } + )[0]; + axes = getInnerMostAxes(axes.length, input.dims.length); + } + const [outputShape, reduceShape] = computeOutAndReduceShapes(input.dims, axes); + let finalOutputShape = outputShape; + if (updatedAttributes.keepDims) { + finalOutputShape = expandShapeToKeepDim(outputShape, normalizeAxes); + } + context.compute( + createReduceSharedProgramInfo( + name, + { hint: updatedAttributes.cacheKey, inputDependencies: ["type"] }, + [input], + reduceType, + context.inputs[0].dataType, + finalOutputShape, + reduceShape + ), + { inputs: [input] } + ); + }; + reduceMeanShared = (context, attributes) => { + reduceCommon(context, "ReduceMeanShared", attributes, "mean"); + }; + reduceL1Shared = (context, attributes) => { + reduceCommon(context, "ReduceL1Shared", attributes, "l1"); + }; + reduceL2Shared = (context, attributes) => { + reduceCommon(context, "ReduceL2Shared", attributes, "l2"); + }; + reduceLogSumExpShared = (context, attributes) => { + reduceCommon(context, "ReduceLogSumExpShared", attributes, "logSumExp"); + }; + reduceMaxShared = (context, attributes) => { + reduceCommon(context, "ReduceMaxShared", attributes, "max"); + }; + reduceMinShared = (context, attributes) => { + reduceCommon(context, "ReduceMinShared", attributes, "min"); + }; + reduceProdShared = (context, attributes) => { + reduceCommon(context, "ReduceProdShared", attributes, "prod"); + }; + reduceSumShared = (context, attributes) => { + reduceCommon(context, "ReduceSumShared", attributes, "sum"); + }; + reduceSumSquareShared = (context, attributes) => { + reduceCommon(context, "ReduceSumSquareShared", attributes, "sumSquare"); + }; + reduceLogSumShared = (context, attributes) => { + reduceCommon(context, "ReduceLogSumShared", attributes, "logSum"); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/reduce.ts +var validateInputs2, noOp, createReduceProgramInfo, createReduceAttributesFromInputs, runReduceProgram, reduceLogSumNaive, reduceL1Naive, reduceL2Naive, reduceLogSumExpNaive, reduceMaxNaive, reduceMeanNaive, reduceMinNaive, reduceProdNaive, reduceSumNaive, reduceSumSquareNaive, useNaiveReduceMethod, reduceMean, reduceL1, reduceL2, reduceLogSumExp, reduceMax, reduceMin, reduceProd, reduceSum, reduceSumSquare, reduceLogSum; +var init_reduce = __esm({ + "web/lib/wasm/jsep/webgpu/ops/reduce.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_attribute_with_cache_key(); + init_common(); + init_reduce_shared(); + validateInputs2 = (inputs) => { + if (!inputs || inputs.length === 0 || inputs.length > 2) { + throw new Error("Reduce op requires 1 or 2 inputs."); + } + if (inputs.length === 2 && inputs[1].dims.length !== 1) { + throw new Error("Invalid axes input dims."); + } + }; + noOp = (input) => ["", "", `var value = ${input.getByIndices("input_indices")};`, ""]; + createReduceProgramInfo = (name, shaderCache, inputs, reduceOp, axesInput, outputDataType, keepDims = false, noopWithEmptyAxes = false) => { + const outputShape = []; + const inputShape = inputs[0].dims; + const inputRank = inputShape.length; + const axes = ShapeUtil.normalizeAxes(axesInput, inputRank); + const reduceOnAllAxes = !noopWithEmptyAxes && axes.length === 0; + inputShape.forEach((d, i) => { + if (reduceOnAllAxes || axes.indexOf(i) >= 0) { + if (keepDims) { + outputShape.push(1); + } + } else { + outputShape.push(d); + } + }); + const outputRank = outputShape.length; + const outputSize = ShapeUtil.size(outputShape); + const getShaderSource = (shaderHelper) => { + const idxCopy = []; + const input = inputVariable("_A", inputs[0].dataType, inputRank); + const output = outputVariable("output", outputDataType, outputRank); + const ops = reduceOp(input, output, axes); + let reduceOps2 = ops[2]; + for (let k = 0, l = 0; k < inputRank; k++) { + if (reduceOnAllAxes || axes.indexOf(k) >= 0) { + if (keepDims) { + l++; + } + reduceOps2 = `for(var j${k}: u32 = 0; j${k} < ${inputShape[k]}; j${k}++) { + ${ops[2].includes("last_index") ? `let last_index = j${k};` : ""} + ${input.indicesSet("input_indices", k, `j${k}`)} + ${reduceOps2} + }`; + } else { + idxCopy.push(`${input.indicesSet("input_indices", k, output.indicesGet("output_indices", l))};`); + l++; + } + } + return ` + + ${shaderHelper.registerUniform("output_size", "u32").declareVariables(input, output)} + + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")} + var input_indices: ${input.type.indices}; + let output_indices = ${output.offsetToIndices("global_idx")}; + + ${idxCopy.join("\n")} + ${ops[0]} // init ops for reduce max/min + ${ops[1]} + ${reduceOps2} + ${ops[3]} + ${ops.length === 4 ? output.setByOffset("global_idx", "value") : ops.slice(4).join("\n")} + }`; + }; + return { + name, + shaderCache, + getShaderSource, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: outputDataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms: [{ type: 12 /* uint32 */, data: outputSize }, ...createTensorShapeVariables(inputShape, outputShape)] + }) + }; + }; + createReduceAttributesFromInputs = (inputs, attributes) => { + const axes = []; + if (inputs[1].dims[0] > 0) { + inputs[1].getBigInt64Array().forEach((v) => axes.push(Number(v))); + } + return createAttributeWithCacheKey( + { axes, keepDims: attributes.keepDims, noopWithEmptyAxes: attributes.noopWithEmptyAxes } + ); + }; + runReduceProgram = (context, name, attributes, reduceOp) => { + const inputs = context.inputs; + const updatedAttributes = inputs.length === 1 ? attributes : createReduceAttributesFromInputs(inputs, attributes); + context.compute( + createReduceProgramInfo( + name, + { hint: updatedAttributes.cacheKey, inputDependencies: ["rank"] }, + [inputs[0]], + updatedAttributes.noopWithEmptyAxes && updatedAttributes.axes.length === 0 ? noOp : reduceOp, + updatedAttributes.axes, + inputs[0].dataType, + updatedAttributes.keepDims, + updatedAttributes.noopWithEmptyAxes + ), + { inputs: [0] } + ); + }; + reduceLogSumNaive = (context, attributes) => { + validateInputs2(context.inputs); + const reduceOp = (input, output) => [ + `var value = ${output.type.storage}(0);`, + "", + `value += ${input.getByIndices("input_indices")};`, + "value = log(value);" + ]; + runReduceProgram(context, "ReduceLogSum", attributes, reduceOp); + }; + reduceL1Naive = (context, attributes) => { + validateInputs2(context.inputs); + const reduceOp = (input, output) => [ + `var value = ${output.type.storage}(0);`, + "", + `value += abs(${input.getByIndices("input_indices")});`, + "" + ]; + runReduceProgram(context, "ReduceL1", attributes, reduceOp); + }; + reduceL2Naive = (context, attributes) => { + validateInputs2(context.inputs); + const reduceOp = (input, output) => [ + `var t = ${output.type.value}(0); var value = ${output.type.value}(0);`, + "", + `t = ${input.getByIndices("input_indices")}; value += (t * t);`, + "value = sqrt(value);" + ]; + runReduceProgram(context, "ReduceL2", attributes, reduceOp); + }; + reduceLogSumExpNaive = (context, attributes) => { + validateInputs2(context.inputs); + const reduceOp = (input, output) => [ + `var value = ${output.type.storage}(0);`, + "", + `value += exp(${input.getByIndices("input_indices")});`, + "value = log(value);" + ]; + runReduceProgram(context, "ReduceLogSumExp", attributes, reduceOp); + }; + reduceMaxNaive = (context, attributes) => { + validateInputs2(context.inputs); + const reduceOp = (input, _output, axes) => { + const idxZero = []; + for (let k = 0; k < input.rank; k++) { + if (axes.indexOf(k) >= 0 || axes.length === 0) { + idxZero.push(input.indicesSet("input_indices", k, 0)); + } + } + return [ + `${idxZero.join("\n")}`, + `var value = ${input.getByIndices("input_indices")};`, + `value = max(value, ${input.getByIndices("input_indices")});`, + "" + ]; + }; + runReduceProgram(context, "ReduceMax", attributes, reduceOp); + }; + reduceMeanNaive = (context, attributes) => { + validateInputs2(context.inputs); + const reduceOp = (input, output, axes) => { + let size = 1; + for (let k = 0; k < input.rank; k++) { + if (axes.indexOf(k) >= 0 || axes.length === 0) { + size *= context.inputs[0].dims[k]; + } + } + return [ + "var sum = f32(0);", + "", + `sum += f32(${input.getByIndices("input_indices")});`, + `let value = ${output.type.value}(sum / ${size});` + ]; + }; + runReduceProgram(context, "ReduceMean", attributes, reduceOp); + }; + reduceMinNaive = (context, attributes) => { + validateInputs2(context.inputs); + const reduceOp = (input, _output, axes) => { + const idxZero = []; + for (let k = 0; k < input.rank; k++) { + if (axes.indexOf(k) >= 0 || axes.length === 0) { + idxZero.push(`input_indices[${k}] = 0;`); + } + } + return [ + `${idxZero.join("\n")}`, + `var value = ${input.getByIndices("input_indices")};`, + `value = min(value, ${input.getByIndices("input_indices")});`, + "" + ]; + }; + runReduceProgram(context, "ReduceMin", attributes, reduceOp); + }; + reduceProdNaive = (context, attributes) => { + validateInputs2(context.inputs); + const reduceOp = (input, output) => [ + `var value = ${output.type.storage}(1);`, + "", + `value *= ${input.getByIndices("input_indices")};`, + "" + ]; + runReduceProgram(context, "ReduceProd", attributes, reduceOp); + }; + reduceSumNaive = (context, attributes) => { + validateInputs2(context.inputs); + const reduceOp = (input, output) => [ + `var value = ${output.type.storage}(0);`, + "", + `value += ${input.getByIndices("input_indices")};`, + "" + ]; + runReduceProgram(context, "ReduceSum", attributes, reduceOp); + }; + reduceSumSquareNaive = (context, attributes) => { + validateInputs2(context.inputs); + const reduceOp = (input, output) => [ + `var t = ${output.type.value}(0); var value = ${output.type.value}(0);`, + "", + `t = ${input.getByIndices("input_indices")}; value += t * t;`, + "" + ]; + runReduceProgram(context, "ReduceSumSquare", attributes, reduceOp); + }; + useNaiveReduceMethod = (shape, axes, noopWithEmptyAxes) => { + if (axes.length === 0) { + return noopWithEmptyAxes; + } + let outputSize = 1; + let reduceSize = 1; + for (let dim = 0; dim < axes.length; dim++) { + if (axes.indexOf(dim) === -1) { + outputSize *= shape[dim]; + } else { + reduceSize *= shape[dim]; + } + } + return reduceSize < 32 && outputSize > 1024; + }; + reduceMean = (context, attributes) => { + if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) { + reduceMeanNaive(context, attributes); + } else { + reduceMeanShared(context, attributes); + } + }; + reduceL1 = (context, attributes) => { + if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) { + reduceL1Naive(context, attributes); + } else { + reduceL1Shared(context, attributes); + } + }; + reduceL2 = (context, attributes) => { + if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) { + reduceL2Naive(context, attributes); + } else { + reduceL2Shared(context, attributes); + } + }; + reduceLogSumExp = (context, attributes) => { + if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) { + reduceLogSumExpNaive(context, attributes); + } else { + reduceLogSumExpShared(context, attributes); + } + }; + reduceMax = (context, attributes) => { + if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) { + reduceMaxNaive(context, attributes); + } else { + reduceMaxShared(context, attributes); + } + }; + reduceMin = (context, attributes) => { + if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) { + reduceMinNaive(context, attributes); + } else { + reduceMinShared(context, attributes); + } + }; + reduceProd = (context, attributes) => { + if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) { + reduceProdNaive(context, attributes); + } else { + reduceProdShared(context, attributes); + } + }; + reduceSum = (context, attributes) => { + if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) { + reduceSumNaive(context, attributes); + } else { + reduceSumShared(context, attributes); + } + }; + reduceSumSquare = (context, attributes) => { + if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) { + reduceSumSquareNaive(context, attributes); + } else { + reduceSumSquareShared(context, attributes); + } + }; + reduceLogSum = (context, attributes) => { + if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) { + reduceLogSumNaive(context, attributes); + } else { + reduceLogSumShared(context, attributes); + } + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/argminmax.ts +var validateInputs3, argMin, argMax, parseArgMinMaxAttributes; +var init_argminmax = __esm({ + "web/lib/wasm/jsep/webgpu/ops/argminmax.ts"() { + "use strict"; + init_wasm_common(); + init_attribute_with_cache_key(); + init_reduce(); + validateInputs3 = (inputs) => { + if (!inputs || inputs.length === 0 || inputs.length > 2) { + throw new Error("ArgMinMaxOp op requires 1 or 2 inputs."); + } + if (inputs[0].dataType !== 1 /* float */) { + throw new Error("Invalid input type."); + } + }; + argMin = (context, attributes) => { + validateInputs3(context.inputs); + const argMinMaxOp = (input, output, axes) => { + const idxZero = []; + for (let k = 0; k < input.rank; k++) { + if (axes.indexOf(k) >= 0 || axes.length === 0) { + idxZero.push(`input_indices[${k}] = 0;`); + } + } + return [ + `${idxZero.join("\n")}`, + `var value = ${input.getByIndices("input_indices")}; +var best_index : i32 = 0;`, + `if (${input.getByIndices("input_indices")} ${attributes.selectLastIndex > 0 ? "<=" : "<"} value) { + value = ${input.getByIndices("input_indices")}; + best_index = i32(last_index); + }`, + "", + output.setByOffset("global_idx", "best_index") + ]; + }; + context.compute( + createReduceProgramInfo( + "ArgMin", + { hint: attributes.cacheKey, inputDependencies: ["rank"] }, + [context.inputs[0]], + argMinMaxOp, + [attributes.axis], + 7 /* int64 */, + attributes.keepDims + ), + { inputs: [0] } + ); + }; + argMax = (context, attributes) => { + validateInputs3(context.inputs); + const argMinMaxOp = (input, output, axes) => { + const idxZero = []; + for (let k = 0; k < input.rank; k++) { + if (axes.indexOf(k) >= 0 || axes.length === 0) { + idxZero.push(`input_indices[${k}] = 0;`); + } + } + return [ + `${idxZero.join("\n")}`, + `var value = ${input.getByIndices("input_indices")}; +var best_index : i32 = 0;`, + `if (${input.getByIndices("input_indices")} ${attributes.selectLastIndex > 0 ? ">=" : ">"} value) { + value = ${input.getByIndices("input_indices")}; + best_index = i32(last_index); + }`, + "", + output.setByOffset("global_idx", "best_index") + ]; + }; + context.compute( + createReduceProgramInfo( + "argMax", + { hint: attributes.cacheKey, inputDependencies: ["rank"] }, + [context.inputs[0]], + argMinMaxOp, + [attributes.axis], + 7 /* int64 */, + attributes.keepDims + ), + { inputs: [0] } + ); + }; + parseArgMinMaxAttributes = (attributes) => createAttributeWithCacheKey(attributes); + } +}); + +// web/lib/wasm/jsep/webgpu/ops/concat.ts +var validateInputs4, calculateInputIndexImpl, assignOutputData, createConcatProgramInfo, concat, parseConcatAttributes; +var init_concat = __esm({ + "web/lib/wasm/jsep/webgpu/ops/concat.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_attribute_with_cache_key(); + init_common(); + validateInputs4 = (inputs, axis) => { + if (!inputs || inputs.length < 1) { + throw new Error("too few inputs"); + } + const referenceIndex = 0; + const referenceInput = inputs[referenceIndex]; + const inputType = referenceInput.dataType; + const inputRank = referenceInput.dims.length; + inputs.forEach((input, i) => { + if (i === referenceIndex) { + return; + } + if (input.dataType !== inputType) { + throw new Error("input tensors should be one type"); + } + if (input.dims.length !== inputRank) { + throw new Error("input tensors should have the same shape"); + } + input.dims.forEach((dim, i2) => { + if (i2 !== axis && dim !== referenceInput.dims[i2]) { + throw new Error("non concat dimensions must match"); + } + }); + }); + }; + calculateInputIndexImpl = (numberOfTensors, sizeInConcatAxisStr) => ` + fn calculateInputIndex(index: u32) -> u32 { + let sizeInConcatAxis = array(${sizeInConcatAxisStr}); + for (var i: u32 = 0u; i < ${numberOfTensors}; i += 1u ) { + if (index < sizeInConcatAxis[i]) { + return i; + } + } + return ${numberOfTensors}u; + }`; + assignOutputData = (inputs, output) => { + const numberOfTensors = inputs.length; + const codeLines = []; + for (let i = 0; i < numberOfTensors; ++i) { + const returnSnippet = output.setByOffset("global_idx", inputs[i].getByIndices("indices")); + if (numberOfTensors === 1) { + codeLines.push(returnSnippet); + } else if (i === 0) { + codeLines.push(`if (inputIndex == ${i}u) { ${returnSnippet} }`); + } else if (i === numberOfTensors - 1) { + codeLines.push(`else { ${returnSnippet} }`); + } else { + codeLines.push(`else if (inputIndex == ${i}) { ${returnSnippet} }`); + } + } + return codeLines.join("\n"); + }; + createConcatProgramInfo = (inputs, adjustedAxis, outputShape, dataType) => { + const outputSize = ShapeUtil.size(outputShape); + const sizeInConcatAxis = new Array(inputs.length); + const inputVars = new Array(inputs.length); + let previousSum = 0; + const inputDependencies = []; + const inputRanks = []; + const programUniforms = [{ type: 12 /* uint32 */, data: outputSize }]; + for (let i = 0; i < inputs.length; ++i) { + previousSum += inputs[i].dims[adjustedAxis]; + sizeInConcatAxis[i] = previousSum; + inputRanks.push(inputs[i].dims.length); + inputVars[i] = inputVariable(`input${i}`, dataType, inputRanks[i]); + inputDependencies.push("rank"); + programUniforms.push({ type: 12 /* uint32 */, data: sizeInConcatAxis[i] }); + } + for (let i = 0; i < inputs.length; ++i) { + programUniforms.push(...createTensorShapeVariables(inputs[i].dims)); + } + programUniforms.push(...createTensorShapeVariables(outputShape)); + const output = outputVariable("output", dataType, outputShape.length); + const indicesAxis = output.indicesGet("indices", adjustedAxis); + const sizeInConcatAxisStr = Array.from(Array(sizeInConcatAxis.length).keys()).map((i) => `uniforms.sizeInConcatAxis${i}`).join(","); + const getShaderSource = (shaderHelper) => ` + + ${(() => { + shaderHelper.registerUniform("outputSize", "u32"); + for (let i = 0; i < inputs.length; i++) { + shaderHelper.registerUniform(`sizeInConcatAxis${i}`, "u32"); + } + return shaderHelper.declareVariables(...inputVars, output); + })()} + + ${calculateInputIndexImpl(sizeInConcatAxis.length, sizeInConcatAxisStr)} + + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")} + + var indices = ${output.offsetToIndices("global_idx")}; + + let inputIndex = calculateInputIndex(${indicesAxis}); + if (inputIndex != 0u) { + let sizeInConcatAxis = array(${sizeInConcatAxisStr}); + ${indicesAxis} -= sizeInConcatAxis[inputIndex - 1u]; + } + + ${assignOutputData(inputVars, output)} + }`; + return { + name: "Concat", + shaderCache: { hint: `${adjustedAxis}`, inputDependencies }, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms + }), + getShaderSource + }; + }; + concat = (context, attributes) => { + const inputs = context.inputs; + const inputShape = inputs[0].dims; + const adjustedAxis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length); + validateInputs4(inputs, adjustedAxis); + const outputShape = inputShape.slice(); + outputShape[adjustedAxis] = inputs.reduce((sum, input) => sum + (input.dims.length > adjustedAxis ? input.dims[adjustedAxis] : 0), 0); + const nonEmptyInputs = inputs.filter((input) => ShapeUtil.size(input.dims) > 0); + context.compute( + createConcatProgramInfo(nonEmptyInputs, adjustedAxis, outputShape, inputs[0].dataType), + { inputs: nonEmptyInputs } + ); + }; + parseConcatAttributes = (attributes) => createAttributeWithCacheKey({ axis: attributes.axis }); + } +}); + +// web/lib/wasm/jsep/webgpu/ops/attention.ts +var validateAttentionInputs, createInPlaceSoftmaxProgramInfo, createAttentionProbsProgramInfo, createVxAttentionScoreProgramInfo, applyAttention, prepare, attention; +var init_attention = __esm({ + "web/lib/wasm/jsep/webgpu/ops/attention.ts"() { + "use strict"; + init_wasm_common(); + init_types(); + init_common(); + init_concat(); + validateAttentionInputs = (inputs, attributes) => { + const input = inputs[0]; + const weights = inputs[1]; + const bias = inputs[2]; + const maskIndex = inputs[3]; + const past = inputs[4]; + const relativePositionBias = inputs[5]; + if (past && relativePositionBias) { + throw new Error("Attention cannot have both past and relative_position_bias"); + } + if (input.dims.length !== 3) { + throw new Error('Input "input" must have 3 dimensions'); + } + const batchSize = input.dims[0]; + const sequenceLength = input.dims[1]; + const inputHiddenSize = input.dims[2]; + if (bias.dims.length !== 1) { + throw new Error('Input "bias" is expected to have 1 dimensions'); + } + if (weights.dims.length !== 2) { + throw new Error('Input "weights" is expected to have 2 dimensions'); + } + if (weights.dims[0] !== inputHiddenSize) { + throw new Error("Input 1 dimension 0 should have same length as dimension 2 of input 0"); + } + if (bias.dims[0] !== weights.dims[1]) { + throw new Error('Input "bias" dimension 0 should have same length as dimension 1 of input "weights"'); + } + let qHiddenSize = bias.dims[0] / 3; + let kHiddenSize = qHiddenSize; + let vHiddenSize = kHiddenSize; + if (attributes.qkvHiddenSizes.length > 0) { + if (attributes.qkvHiddenSizes.length !== 3) { + throw new Error("qkv_hidden_sizes attribute should have 3 elements"); + } + for (const sz of attributes.qkvHiddenSizes) { + if (sz % attributes.numHeads !== 0) { + throw new Error("qkv_hidden_sizes should be divisible by num_heads"); + } + } + qHiddenSize = attributes.qkvHiddenSizes[0]; + kHiddenSize = attributes.qkvHiddenSizes[1]; + vHiddenSize = attributes.qkvHiddenSizes[2]; + } + const kvSequenceLength = sequenceLength; + if (qHiddenSize !== kHiddenSize) { + throw new Error("qkv_hidden_sizes first element should be same as the second"); + } + if (bias.dims[0] !== qHiddenSize + kHiddenSize + vHiddenSize) { + throw new Error('Input "bias" dimension 0 should have same length as sum of Q/K/V hidden sizes'); + } + let pastSequenceLength = 0; + if (past) { + if (kHiddenSize !== vHiddenSize) { + throw new Error('Input "past" expect k_hidden_size == v_hidden_size'); + } + if (past.dims.length !== 5) { + throw new Error('Input "past" must have 5 dimensions'); + } + if (past.dims[0] !== 2) { + throw new Error('Input "past" first dimension must be 2'); + } + if (past.dims[1] !== batchSize) { + throw new Error('Input "past" second dimension must be batch_size'); + } + if (past.dims[2] !== attributes.numHeads) { + throw new Error('Input "past" third dimension must be num_heads'); + } + if (past.dims[4] !== kHiddenSize / attributes.numHeads) { + throw new Error('Input "past" fifth dimension must be k_hidden_size / num_heads'); + } + if (!attributes.pastPresentShareBuffer) { + pastSequenceLength = past.dims[3]; + } + } + const totalSequenceLength = kvSequenceLength + pastSequenceLength; + const maxSequenceLength = -1; + const maskType = 0 /* none */; + if (maskIndex) { + throw new Error("Mask not supported"); + } + if (past) { + throw new Error("past is not supported"); + } + return { + batchSize, + sequenceLength, + pastSequenceLength, + kvSequenceLength, + totalSequenceLength, + maxSequenceLength, + inputHiddenSize, + hiddenSize: qHiddenSize, + vHiddenSize, + headSize: Math.floor(qHiddenSize / attributes.numHeads), + vHeadSize: Math.floor(vHiddenSize / attributes.numHeads), + numHeads: attributes.numHeads, + isUnidirectional: false, + pastPresentShareBuffer: false, + maskFilterValue: attributes.maskFilterValue, + maskType, + scale: attributes.scale, + broadcastResPosBias: false, + passPastInKv: false, + qkvFormat: 1 /* qkvBNSH */ + }; + }; + createInPlaceSoftmaxProgramInfo = (_context, input, n, d) => { + const components = getMaxComponents(d); + let WG = 64; + const dComp = d / components; + if (dComp < WG) { + WG = 1; + } else if (dComp / 8 < 64) { + WG = Math.ceil(dComp / 8); + } + const elementsPerThread = Math.ceil(d / components / WG); + const programUniforms = [ + { type: input.dataType, data: 1 / d }, + { type: 12 /* uint32 */, data: dComp }, + { type: 12 /* uint32 */, data: elementsPerThread } + ]; + const dataType = tensorTypeToWsglStorageType(input.dataType, components); + const f32Type = tensorTypeToWsglValueType(1 /* float */, components); + const getShaderSource = (shaderHelper) => { + const inputHelper = outputVariable("x", input.dataType, input.dims, components); + const elemValueType = tensorTypeToWsglValueType(input.dataType); + const uniforms = [ + { name: "d_inv", type: elemValueType }, + { name: "d_comp", type: "u32" }, + { name: "elements_per_thread", type: "u32" } + ]; + return ` + var thread_max: array; + var thread_sum: array; + ${shaderHelper.registerUniforms(uniforms).declareVariables(inputHelper)} + ${shaderHelper.mainStart([ + WG, + 1, + 1 + ])} + let local_offset = local_idx * uniforms.elements_per_thread; + let offset = workgroup_id.x * uniforms.d_comp + local_offset; + + var thread_max_vector = ${f32Type}(-3.402823e+38f); + for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) { + thread_max_vector = max(${f32Type}(x[offset + i]), thread_max_vector); + } + thread_max[local_idx] = ${(() => { + switch (components) { + case 1: + return "thread_max_vector"; + case 2: + return "max(thread_max_vector.x, thread_max_vector.y)"; + case 4: + return "max(max(thread_max_vector.x, thread_max_vector.y), max(thread_max_vector.z, thread_max_vector.w))"; + default: + throw new Error(`Unsupported components: ${components}`); + } + })()}; + workgroupBarrier(); + + var max_value = f32(-3.402823e+38f); + for (var i = 0u; i < ${WG}; i++) { + max_value = max(thread_max[i], max_value); + } + + var sum_vector = ${f32Type}(0); + for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) { + sum_vector += exp(${f32Type}(x[offset + i]) - max_value); + } + thread_sum[local_idx] = ${(() => { + switch (components) { + case 1: + return "sum_vector"; + case 2: + return "sum_vector.x + sum_vector.y"; + case 4: + return "sum_vector.x + sum_vector.y + sum_vector.z + sum_vector.w"; + default: + throw new Error(`Unsupported components: ${components}`); + } + })()}; + workgroupBarrier(); + + var sum: f32 = 0; + for (var i = 0u; i < ${WG}; i++) { + sum += thread_sum[i]; + } + + if (sum == 0) { + for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) { + x[offset + i] = ${inputHelper.type.value}(uniforms.d_inv); + } + } else { + for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) { + var f32input = ${f32Type}(x[offset + i]); + x[offset + i] = ${inputHelper.type.value}(exp(f32input - max_value) / sum); + } + } + }`; + }; + return { + name: "AttentionProbsSoftmax", + shaderCache: { hint: `${WG};${dataType};${components}` }, + getShaderSource, + getRunData: () => ({ outputs: [], dispatchGroup: { x: n }, programUniforms }) + }; + }; + createAttentionProbsProgramInfo = (_context, q, key, relativePositionBias, parameters, attributes, pastSequenceLength) => { + const totalSequenceLength = pastSequenceLength + parameters.kvSequenceLength; + const probsShape = [parameters.batchSize, parameters.numHeads, parameters.sequenceLength, totalSequenceLength]; + const alpha = attributes.scale === 0 ? 1 / Math.sqrt(parameters.headSize) : attributes.scale; + const components = getMaxComponents(parameters.headSize); + const vectorizedHeadSize = parameters.headSize / components; + const TILE_SIZE = 12; + const dispatch = { + x: Math.ceil(totalSequenceLength / TILE_SIZE), + y: Math.ceil(parameters.sequenceLength / TILE_SIZE), + z: parameters.batchSize * parameters.numHeads + }; + const programUniforms = [ + { type: 12 /* uint32 */, data: parameters.sequenceLength }, + { type: 12 /* uint32 */, data: vectorizedHeadSize }, + { type: 12 /* uint32 */, data: totalSequenceLength }, + { type: 12 /* uint32 */, data: parameters.numHeads }, + { type: 1 /* float */, data: alpha } + ]; + const inputDependencies = ["type", "type"]; + if (relativePositionBias) { + inputDependencies.push("rank"); + programUniforms.push(...createTensorShapeVariables(relativePositionBias.dims)); + } + const getShaderSource = (shaderHelper) => { + const qInput = inputVariable("q", q.dataType, q.dims, components); + const kInput = inputVariable("key", key.dataType, key.dims, components); + const inputVars = [qInput, kInput]; + const relativePositionBiasInput = relativePositionBias ? inputVariable("relative_position_bias", relativePositionBias.dataType, relativePositionBias.dims.length) : void 0; + if (relativePositionBiasInput) { + inputVars.push(relativePositionBiasInput); + } + const output = outputVariable("output", q.dataType, probsShape); + const f32Type = tensorTypeToWsglValueType(1 /* float */, components); + const uniforms = [ + { name: "M", type: "u32" }, + { name: "K", type: "u32" }, + { name: "N", type: "u32" }, + { name: "num_heads", type: "u32" }, + { name: "alpha", type: "f32" } + ]; + return ` + const TILE_SIZE = ${TILE_SIZE}u; + + var tileQ: array<${qInput.type.storage}, ${TILE_SIZE * TILE_SIZE}>; + var tileK: array<${qInput.type.storage}, ${TILE_SIZE * TILE_SIZE}>; + ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)} + ${shaderHelper.mainStart([ + TILE_SIZE, + TILE_SIZE, + 1 + ])} + // x holds the N and y holds the M + let headIdx = workgroup_id.z; + let m = workgroup_id.y * TILE_SIZE; + let n = workgroup_id.x * TILE_SIZE; + let qOffset = uniforms.M * uniforms.K * headIdx + m * uniforms.K; + let kOffset = uniforms.N * uniforms.K * headIdx + n * uniforms.K; + + var value = ${f32Type}(0); + for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) { + if (global_id.y < uniforms.M && w + local_id.x < uniforms.K) { + tileQ[TILE_SIZE * local_id.y + local_id.x] = q[qOffset + local_id.y * uniforms.K + w + local_id.x]; + } + if (n + local_id.y < uniforms.N && w + local_id.x < uniforms.K) { + tileK[TILE_SIZE * local_id.y + local_id.x] = key[kOffset + local_id.y * uniforms.K + w + local_id.x]; + } + workgroupBarrier(); + + for (var k: u32 = 0u; k < TILE_SIZE && w+k < uniforms.K; k++) { + value += ${f32Type}(tileQ[TILE_SIZE * local_id.y + k] * tileK[TILE_SIZE * local_id.x + k]); + } + + workgroupBarrier(); + } + + let headOffset = headIdx * uniforms.M * uniforms.N; + if (global_id.y < uniforms.M && global_id.x < uniforms.N) { + let outputIdx = headOffset + global_id.y * uniforms.N + global_id.x; + var sum: f32 = ${(() => { + switch (components) { + case 1: + return "value"; + case 2: + return "value.x + value.y"; + case 4: + return "value.x + value.y + value.z + value.w"; + default: + throw new Error(`Unsupported components: ${components}`); + } + })()}; + + ${(() => { + if (relativePositionBiasInput) { + return ` + let batch = workgroup_id.z / uniforms.num_heads; + let head = workgroup_id.z % uniforms.num_heads; + var indices = ${relativePositionBiasInput.type.indices}(batch, head, global_id.y, global_id.x); + output[outputIdx] = ${output.type.value}(sum * uniforms.alpha) + ${relativePositionBiasInput.getByIndices("indices")};`; + } + return `output[outputIdx] = ${output.type.value} (sum * uniforms.alpha);`; + })()} + } + }`; + }; + return { + name: "AttentionProbs", + shaderCache: { hint: `${components}`, inputDependencies }, + getRunData: () => ({ + outputs: [{ dims: probsShape, dataType: q.dataType, gpuDataType: 0 /* default */ }], + dispatchGroup: dispatch, + programUniforms + }), + getShaderSource + }; + }; + createVxAttentionScoreProgramInfo = (_context, probs, v, params, pastSequenceLength) => { + const totalSequenceLength = pastSequenceLength + params.kvSequenceLength; + const outputShape = [params.batchSize, params.sequenceLength, params.vHiddenSize]; + const TILE_SIZE = 12; + const dispatch = { + x: Math.ceil(params.vHeadSize / TILE_SIZE), + y: Math.ceil(params.sequenceLength / TILE_SIZE), + z: params.batchSize * params.numHeads + }; + const programUniforms = [ + { type: 12 /* uint32 */, data: params.sequenceLength }, + { type: 12 /* uint32 */, data: totalSequenceLength }, + { type: 12 /* uint32 */, data: params.vHeadSize }, + { type: 12 /* uint32 */, data: params.numHeads }, + { type: 12 /* uint32 */, data: params.vHiddenSize } + ]; + const inputDependencies = ["type", "type"]; + const getShaderSource = (shaderHelper) => { + const probsHelper = inputVariable("probs", probs.dataType, probs.dims); + const vHelper = inputVariable("v", v.dataType, v.dims); + const output = outputVariable("output", probs.dataType, outputShape); + const uniforms = [ + { name: "M", type: "u32" }, + { name: "K", type: "u32" }, + { name: "N", type: "u32" }, + { name: "num_heads", type: "u32" }, + { name: "v_hidden_size", type: "u32" } + ]; + return ` + const TILE_SIZE = ${TILE_SIZE}u; + var tileQ: array<${probsHelper.type.value}, ${TILE_SIZE * TILE_SIZE}>; + var tileK: array<${probsHelper.type.value}, ${TILE_SIZE * TILE_SIZE}>; + ${shaderHelper.registerUniforms(uniforms).declareVariables(probsHelper, vHelper, output)} + ${shaderHelper.mainStart([ + TILE_SIZE, + TILE_SIZE, + 1 + ])} + let headIdx = workgroup_id.z; + let m = global_id.y; + let n = global_id.x; + + let offsetA = headIdx * (uniforms.M * uniforms.K) + m * uniforms.K; + let offsetB = headIdx * (uniforms.N * uniforms.K) + n; + + var value = ${probsHelper.type.storage}(0); + for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) { + if (m < uniforms.M && w + local_id.x < uniforms.K) { + tileQ[TILE_SIZE * local_id.y + local_id.x] = probs[offsetA + w + local_id.x]; + } + if (n < uniforms.N && w + local_id.y < uniforms.K) { + tileK[TILE_SIZE * local_id.y + local_id.x] = v[offsetB + (w + local_id.y) * uniforms.N]; + } + workgroupBarrier(); + for (var k: u32 = 0u; k < TILE_SIZE && w+k < uniforms.K; k++) { + value += tileQ[TILE_SIZE * local_id.y + k] * tileK[TILE_SIZE * k + local_id.x]; + } + workgroupBarrier(); + } + + // we need to transpose output from BNSH_v to BSND_v + let batchIdx = workgroup_id.z / uniforms.num_heads; + let currentBatchHeadNumber = workgroup_id.z % uniforms.num_heads; + if (m < uniforms.M && n < uniforms.N) { + let outputIdx = batchIdx * uniforms.M * uniforms.v_hidden_size + m * uniforms.v_hidden_size + + currentBatchHeadNumber * uniforms.N + n; + output[outputIdx] = value; + } + }`; + }; + return { + name: "AttentionScore", + shaderCache: { inputDependencies }, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: probs.dataType, gpuDataType: 0 /* default */ }], + dispatchGroup: dispatch, + programUniforms + }), + getShaderSource + }; + }; + applyAttention = (context, q, k, v, _maskIndex, _past, pastKey, pastValue, relativePositionBias, parameters, attributes) => { + const outputPresentKey = context.outputCount > 1; + const outputPresentValue = context.outputCount > 2; + const pastSequenceLength = outputPresentKey && outputPresentValue ? parameters.pastSequenceLength : 0; + const totalSequenceLength = pastSequenceLength + parameters.kvSequenceLength; + const presentKeyShape = [parameters.batchSize, parameters.numHeads, totalSequenceLength, parameters.headSize]; + const concatKeyInputs = pastKey ? [pastKey, k] : [k]; + const key = outputPresentKey ? context.compute( + createConcatProgramInfo(concatKeyInputs, 2, presentKeyShape, k.dataType), + { inputs: concatKeyInputs, outputs: [1] } + )[0] : k; + const presentValueShape = [parameters.batchSize, parameters.numHeads, totalSequenceLength, parameters.headSize]; + const concatValueInputs = pastValue ? [pastValue, v] : [v]; + const value = outputPresentValue ? context.compute( + createConcatProgramInfo(concatValueInputs, 2, presentValueShape, v.dataType), + { inputs: concatValueInputs, outputs: [2] } + )[0] : v; + const inputsK = [q, key]; + if (relativePositionBias) { + inputsK.push(relativePositionBias); + } + const probs = context.compute( + createAttentionProbsProgramInfo( + context, + q, + key, + relativePositionBias, + parameters, + attributes, + pastSequenceLength + ), + { inputs: inputsK, outputs: [-1] } + )[0]; + context.compute( + createInPlaceSoftmaxProgramInfo( + context, + probs, + parameters.batchSize * parameters.numHeads * parameters.sequenceLength, + totalSequenceLength + ), + { inputs: [probs], outputs: [] } + ); + const inputsV = [probs, value]; + context.compute( + createVxAttentionScoreProgramInfo(context, probs, value, parameters, pastSequenceLength), + { inputs: inputsV, outputs: [0] } + ); + }; + prepare = (context, parameters) => { + const outputShape = [ + parameters.batchSize, + parameters.numHeads, + parameters.sequenceLength, + parameters.headSize + ]; + const M = parameters.sequenceLength; + const K = parameters.inputHiddenSize; + const N = parameters.headSize; + const TILE_SIZE = 12; + const dispatch = { + x: Math.ceil(parameters.headSize / TILE_SIZE), + y: Math.ceil(parameters.sequenceLength / TILE_SIZE), + z: parameters.batchSize * parameters.numHeads + }; + const inputs = [context.inputs[0], context.inputs[1], context.inputs[2]]; + const programUniforms = [ + { type: 12 /* uint32 */, data: M }, + { type: 12 /* uint32 */, data: K }, + { type: 12 /* uint32 */, data: N }, + { type: 12 /* uint32 */, data: parameters.numHeads }, + { type: 12 /* uint32 */, data: parameters.headSize }, + { type: 12 /* uint32 */, data: parameters.hiddenSize }, + { type: 12 /* uint32 */, data: parameters.hiddenSize + parameters.hiddenSize + parameters.vHiddenSize } + ]; + const getShaderSource = (shaderHelper) => { + const outputQ = outputVariable("output_q", inputs[0].dataType, outputShape); + const outputK = outputVariable("output_k", inputs[0].dataType, outputShape); + const outputV = outputVariable("output_v", inputs[0].dataType, outputShape); + const input = inputVariable("input", inputs[0].dataType, inputs[0].dims); + const weight = inputVariable("weight", inputs[1].dataType, inputs[1].dims); + const bias = inputVariable("bias", inputs[2].dataType, inputs[2].dims); + const dataType = input.type.storage; + const uniforms = [ + { name: "M", type: "u32" }, + { name: "K", type: "u32" }, + { name: "N", type: "u32" }, + { name: "num_heads", type: "u32" }, + { name: "head_size", type: "u32" }, + { name: "hidden_size", type: "u32" }, + { name: "ldb", type: "u32" } + ]; + return ` + const TILE_SIZE = ${TILE_SIZE}u; + var tileInput: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>; + var tileWeightQ: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>; + var tileWeightK: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>; + var tileWeightV: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>; + ${shaderHelper.registerUniforms(uniforms).declareVariables(input, weight, bias, outputQ, outputK, outputV)} + ${shaderHelper.mainStart([ + TILE_SIZE, + TILE_SIZE, + 1 + ])} + let batchIndex = workgroup_id.z / uniforms.num_heads; + let headNumber = workgroup_id.z % uniforms.num_heads; + let m = global_id.y; + let n = global_id.x; + + let inputOffset = batchIndex * (uniforms.M * uniforms.K) + m * uniforms.K; + let biasOffsetQ = headNumber * uniforms.head_size; + let biasOffsetK = uniforms.hidden_size + biasOffsetQ; + let biasOffsetV = uniforms.hidden_size + biasOffsetK; + + var valueQ = ${dataType}(0); + var valueK = ${dataType}(0); + var valueV = ${dataType}(0); + for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) { + if (m < uniforms.M && w + local_id.x < uniforms.K) { + tileInput[TILE_SIZE * local_id.y + local_id.x] = input[inputOffset + w + local_id.x]; + } + if (n < uniforms.N && w + local_id.y < uniforms.K) { + let offset = n + (w + local_id.y) * uniforms.ldb; + tileWeightQ[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetQ + offset]; + tileWeightK[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetK + offset]; + tileWeightV[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetV + offset]; + } + workgroupBarrier(); + for (var k: u32 = 0u; k ({ + outputs: [ + { dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: 0 /* default */ }, + { dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: 0 /* default */ }, + { dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: 0 /* default */ } + ], + dispatchGroup: dispatch, + programUniforms + }), + getShaderSource + }, + { inputs, outputs: [-1, -1, -1] } + ); + }; + attention = (context, attributes) => { + const params = validateAttentionInputs(context.inputs, attributes); + const [q, k, v] = prepare(context, params); + return applyAttention( + context, + q, + k, + v, + context.inputs[4], + void 0, + void 0, + void 0, + context.inputs[5], + params, + attributes + ); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/batch-norm.ts +var validateInputs5, createBatchNormInferenceProgramInfo, parseBatchNormAttributes, batchNorm; +var init_batch_norm = __esm({ + "web/lib/wasm/jsep/webgpu/ops/batch-norm.ts"() { + "use strict"; + init_esm(); + init_wasm_common(); + init_util(); + init_attribute_with_cache_key(); + init_common(); + validateInputs5 = (inputs, attributes) => { + if (!inputs || inputs.length !== 5) { + throw new Error("BatchNormalization requires 5 inputs"); + } + const checkShapeEqual = (actual, expected, message) => { + const r = expected.length; + if (r !== actual.length) { + throw new Error(`${message}: num dimensions != ${r}`); + } + expected.forEach((v, i) => { + if (v !== actual[i]) { + throw new Error(`${message}: dim[${i}] do not match`); + } + }); + }; + if (inputs[0].dims.length > 1) { + const shape = attributes.format === "NHWC" ? attributes.spatial ? inputs[0].dims.slice(-1) : inputs[0].dims.slice(-1).concat(inputs[0].dims.slice(1, inputs[0].dims.length - 1)) : inputs[0].dims.slice(1, attributes.spatial ? 2 : void 0); + checkShapeEqual(inputs[1].dims, shape, "Invalid input scale"); + checkShapeEqual(inputs[2].dims, shape, "Invalid input B"); + checkShapeEqual(inputs[3].dims, shape, "Invalid input mean"); + checkShapeEqual(inputs[4].dims, shape, "Invalid input var"); + } else { + checkShapeEqual(inputs[1].dims, [1], "Invalid input scale"); + checkShapeEqual(inputs[2].dims, [1], "Invalid input B"); + checkShapeEqual(inputs[3].dims, [1], "Invalid input mean"); + checkShapeEqual(inputs[4].dims, [1], "Invalid input var"); + } + }; + createBatchNormInferenceProgramInfo = (inputs, attributes) => { + const { epsilon, spatial, format } = attributes; + const yShape = inputs[0].dims; + const components = spatial ? getMaxComponents(yShape[yShape.length - 1]) : 1; + const cComponents = format === "NHWC" && yShape.length > 1 ? components : 1; + const outputSize = ShapeUtil.size(yShape) / components; + const useShapesUniforms = spatial; + const shapeOrRank = useShapesUniforms ? yShape.length : yShape; + const x = inputVariable("x", inputs[0].dataType, inputs[0].dims, components); + const scale = inputVariable("scale", inputs[1].dataType, inputs[1].dims, cComponents); + const bias = inputVariable("bias", inputs[2].dataType, inputs[2].dims, cComponents); + const inputMean = inputVariable("inputMean", inputs[3].dataType, inputs[3].dims, cComponents); + const inputVar = inputVariable("inputVar", inputs[4].dataType, inputs[4].dims, cComponents); + const y = outputVariable("y", inputs[0].dataType, shapeOrRank, components); + const calcCOffset = () => { + let cOffset = ""; + if (spatial) { + cOffset = `let cOffset = ${yShape.length === 1 ? "0u" : format === "NHWC" ? `outputIndices[${yShape.length - 1}] / ${components}` : "outputIndices[1]"};`; + } else { + if (format === "NCHW") { + cOffset = ` + ${y.indicesSet("outputIndices", "0", "0")} + let cOffset = ${y.indicesToOffset("outputIndices")};`; + } else { + cOffset = `var cIndices = ${scale.type.indices}(0); + cIndices[0] = outputIndices[${yShape.length - 1}];`; + for (let i = 1; i < scale.rank; i++) { + cOffset += `cIndices[${i}] = outputIndices[${i}];`; + } + cOffset += `let cOffset = ${scale.indicesToOffset("cIndices")};`; + } + } + return cOffset; + }; + const getInferenceModeShaderSource = (helper) => ` + const epsilon = ${epsilon}; + ${helper.registerUniform("outputSize", "u32").declareVariables(x, scale, bias, inputMean, inputVar, y)} + ${helper.mainStart()} + ${helper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")} + var outputIndices = ${y.offsetToIndices(`global_idx * ${components}`)}; + ${calcCOffset()} + let scale = ${scale.getByOffset("cOffset")}; + let bias = ${bias.getByOffset("cOffset")}; + let inputMean = ${inputMean.getByOffset("cOffset")}; + let inputVar = ${inputVar.getByOffset("cOffset")}; + let x = ${x.getByOffset("global_idx")}; + let value = (x - inputMean) * inverseSqrt(inputVar + epsilon) * scale + bias; + ${y.setByOffset("global_idx", "value")} + }`; + return { + name: "BatchNormalization", + shaderCache: { + hint: `${attributes.epsilon}_${attributes.format}_${spatial}_${components}`, + inputDependencies: useShapesUniforms ? ["rank", "type", "type", "type", "type"] : void 0 + }, + getShaderSource: getInferenceModeShaderSource, + getRunData: () => ({ + outputs: [{ dims: inputs[0].dims, dataType: inputs[0].dataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms: useShapesUniforms ? [ + { type: 12 /* uint32 */, data: outputSize }, + ...createTensorShapeVariables(yShape) + ] : [ + { type: 12 /* uint32 */, data: outputSize } + ] + }) + }; + }; + parseBatchNormAttributes = (attributes) => createAttributeWithCacheKey(attributes); + batchNorm = (context, attributes) => { + const { inputs, outputCount } = context; + const updatedAttributes = parseBatchNormAttributes({ ...attributes, outputCount }); + if (env2.webgpu.validateInputContent) { + validateInputs5(inputs, updatedAttributes); + } + if (attributes.trainingMode) { + throw new Error("BatchNormalization trainingMode is not supported yet."); + } else { + context.compute(createBatchNormInferenceProgramInfo(inputs, updatedAttributes)); + } + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/bias-add.ts +var validateInputs6, createBiasAddProgramInfo, biasAdd; +var init_bias_add = __esm({ + "web/lib/wasm/jsep/webgpu/ops/bias-add.ts"() { + "use strict"; + init_util(); + init_common(); + validateInputs6 = (inputs) => { + if (inputs[0].dims.length !== 3) { + throw new Error("input should have 3 dimensions"); + } + if (![320, 640, 1280].includes(inputs[0].dims[2])) { + throw new Error("number of channels should be 320, 640 or 1280"); + } + if (inputs[1].dims.length !== 1) { + throw new Error("bias is expected to have 1 dimensions"); + } + if (inputs[0].dims[2] !== inputs[1].dims[0]) { + throw new Error("last dimension of input and bias are not the same"); + } + }; + createBiasAddProgramInfo = (inputs) => { + const outputShape = inputs[0].dims; + const channels = inputs[0].dims[2]; + const outputSize = ShapeUtil.size(outputShape) / 4; + const dataType = inputs[0].dataType; + const input = inputVariable("input", dataType, outputShape, 4); + const bias = inputVariable("bias", dataType, [channels], 4); + const residual = inputVariable("residual", dataType, outputShape, 4); + const output = outputVariable("output", dataType, outputShape, 4); + const getShaderSource = (shaderHelper) => ` + const channels = ${channels}u / 4; + ${shaderHelper.declareVariables(input, bias, residual, output)} + + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)} + let value = ${input.getByOffset("global_idx")} + + ${bias.getByOffset("global_idx % channels")} + ${residual.getByOffset("global_idx")}; + ${output.setByOffset("global_idx", "value")} + }`; + return { + name: "BiasAdd", + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: inputs[0].dataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) } + }), + getShaderSource + }; + }; + biasAdd = (context) => { + validateInputs6(context.inputs); + context.compute(createBiasAddProgramInfo(context.inputs)); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/unary-op.ts +var createElementwiseProgramShader, createElementwiseProgramInfo, abs, acos, acosh, asin, asinh, atan, atanh, parseCastAttributes, cast, generateClipAttributesFromInputs, clip, ceil, cos, cosh, parseAlphaAttributes, elu, erfImpl, erf, exp, floor, gelu, leakyRelu, not, neg, reciprocal, relu, sigmoid, parseHardSigmoidAttributes, hardSigmoid, sin, sinh, sqrt, tan, tanhExpression, tanh, fastGeluImpl, fastGeluExpression, fastGelu, thresholdedRelu, log; +var init_unary_op = __esm({ + "web/lib/wasm/jsep/webgpu/ops/unary-op.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_attribute_with_cache_key(); + init_common(); + createElementwiseProgramShader = (shaderHelper, datasize, inputDataType, outputDataType, funcCall, additionalImplementation) => { + const vecSize = Math.ceil(datasize / 4); + let expression = ""; + if (typeof funcCall === "string") { + expression = `${funcCall}(a)`; + } else { + expression = funcCall("a"); + } + const input = inputVariable("inputData", inputDataType, [vecSize], 4); + const output = outputVariable("outputData", outputDataType, [vecSize], 4); + return ` + ${shaderHelper.registerUniform("vec_size", "u32").declareVariables(input, output)} + + ${additionalImplementation ?? ""} + + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.vec_size")} + + let a = ${input.getByOffset("global_idx")}; + ${output.setByOffset("global_idx", expression)} + }`; + }; + createElementwiseProgramInfo = (input, name, funcCall, additionalImplementation, cacheKey, outputDataType = input.dataType) => ({ + name, + shaderCache: { hint: cacheKey, inputDependencies: ["type"] }, + getShaderSource: (shaderHelper) => createElementwiseProgramShader( + shaderHelper, + ShapeUtil.size(input.dims), + input.dataType, + outputDataType, + funcCall, + additionalImplementation + ), + getRunData: (inputTensors) => ({ + outputs: [{ dims: input.dims, dataType: outputDataType }], + dispatchGroup: { x: Math.ceil( + ShapeUtil.size(inputTensors[0].dims) / 64 / 4 + /* vec size */ + ) }, + programUniforms: [ + { type: 12 /* uint32 */, data: Math.ceil(ShapeUtil.size(input.dims) / 4) } + ] + }) + }); + abs = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Abs", "abs")); + }; + acos = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Acos", "acos")); + }; + acosh = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Acosh", "acosh")); + }; + asin = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Asin", "asin")); + }; + asinh = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Asinh", "asinh")); + }; + atan = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Atan", "atan")); + }; + atanh = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Atanh", "atanh")); + }; + parseCastAttributes = (attributes) => createAttributeWithCacheKey(attributes); + cast = (context, attributes) => { + let func; + switch (attributes.to) { + case 10 /* float16 */: + func = "vec4"; + break; + case 1 /* float */: + func = "vec4"; + break; + case 12 /* uint32 */: + func = "vec4"; + break; + case 6 /* int32 */: + func = "vec4"; + break; + case 9 /* bool */: + func = "vec4"; + break; + default: + throw new RangeError(`not supported type (specified in attribute 'to' from 'Cast' operator): ${attributes.to}`); + } + context.compute( + createElementwiseProgramInfo(context.inputs[0], "Cast", func, void 0, attributes.cacheKey, attributes.to) + ); + }; + generateClipAttributesFromInputs = (inputs) => { + const min = inputs.length >= 2 && inputs[1].data !== 0 ? inputs[1].getFloat32Array()[0] : MIN_CLIP; + const max = inputs.length >= 3 && inputs[2].data !== 0 ? inputs[2].getFloat32Array()[0] : MAX_CLIP; + return createAttributeWithCacheKey({ min, max }); + }; + clip = (context, clipAttributes) => { + const attributes = context.inputs.length === 1 ? clipAttributes : generateClipAttributesFromInputs(context.inputs); + const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType); + context.compute( + createElementwiseProgramInfo( + context.inputs[0], + "Clip", + (a) => `clamp(${a}, clip_min_, clip_max_)`, + ` + const clip_min_: vec4<${dataType}> = vec4(${dataType}(${attributes.min})); + const clip_max_: vec4<${dataType}> = vec4(${dataType}(${attributes.max})); +`, + attributes.cacheKey + ), + { inputs: [0] } + ); + }; + ceil = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Ceil", "ceil")); + }; + cos = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Cos", "cos")); + }; + cosh = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Cosh", "cosh")); + }; + parseAlphaAttributes = (attributes) => createAttributeWithCacheKey(attributes); + elu = (context, attributes) => { + const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType); + context.compute(createElementwiseProgramInfo( + context.inputs[0], + "Elu", + (a) => `elu_vf32(${a})`, + ` + const elu_alpha_ = ${dataType}(${attributes.alpha}); + + fn elu_f32(a: ${dataType}) -> ${dataType} { + return select((exp(a) - 1.0) * elu_alpha_, a, a >= 0.0); + } + + fn elu_vf32(v: vec4<${dataType}>) -> vec4<${dataType}> { + return vec4(elu_f32(v.x), elu_f32(v.y), elu_f32(v.z), elu_f32(v.w)); + }`, + attributes.cacheKey + )); + }; + erfImpl = (varType = "f32") => ` +const r0: ${varType} = 0.3275911; +const r1: ${varType} = 0.254829592; +const r2: ${varType} = -0.284496736; +const r3: ${varType} = 1.421413741; +const r4: ${varType} = -1.453152027; +const r5: ${varType} = 1.061405429; + +fn erf_vf32(v: vec4<${varType}>) -> vec4<${varType}> { + let absv = abs(v); + let x = 1.0 / (1.0 + r0 * absv); + return sign(v) * (1.0 - ((((r5 * x + r4) * x + r3) * x + r2) * x + r1) * x * exp(-absv * absv)); +}`; + erf = (context) => { + const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType); + context.compute(createElementwiseProgramInfo(context.inputs[0], "Erf", (a) => `erf_vf32(${a})`, erfImpl(dataType))); + }; + exp = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Exp", "exp")); + }; + floor = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Floor", "floor")); + }; + gelu = (context) => { + const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType); + context.compute(createElementwiseProgramInfo( + context.inputs[0], + "Gelu", + (a) => `0.5 * ${a} * (1.0 + erf_vf32(${a} * 0.7071067811865475))`, + erfImpl(dataType) + )); + }; + leakyRelu = (context, attributes) => { + const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType); + context.compute(createElementwiseProgramInfo( + context.inputs[0], + "LeakyRelu", + (a) => `select(leaky_relu_alpha_ * ${a}, ${a}, ${a} >= vec4<${dataType}>(0.0))`, + `const leaky_relu_alpha_ = ${dataType}(${attributes.alpha});`, + attributes.cacheKey + )); + }; + not = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Not", (a) => `!${a}`)); + }; + neg = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Neg", (a) => `-${a}`)); + }; + reciprocal = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Reciprocal", (a) => `1.0/${a}`)); + }; + relu = (context) => { + const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType); + context.compute(createElementwiseProgramInfo( + context.inputs[0], + "Relu", + (a) => `select(vec4<${dataType}>(0.0), ${a}, ${a} > vec4<${dataType}>(0.0))` + )); + }; + sigmoid = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Sigmoid", (a) => `(1.0 / (1.0 + exp(-${a})))`)); + }; + parseHardSigmoidAttributes = (attributes) => createAttributeWithCacheKey(attributes); + hardSigmoid = (context, attributes) => { + const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType); + context.compute(createElementwiseProgramInfo( + context.inputs[0], + "HardSigmoid", + (a) => `max(vec4<${dataType}>(0.0), min(vec4<${dataType}>(1.0), ${attributes.alpha} * ${a} + vec4<${dataType}>(${attributes.beta})))`, + void 0, + attributes.cacheKey + )); + }; + sin = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Sin", "sin")); + }; + sinh = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Sinh", "sinh")); + }; + sqrt = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Sqrt", "sqrt")); + }; + tan = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Tan", "tan")); + }; + tanhExpression = (a) => `sign(${a}) * (1 - exp(-2 * abs(${a}))) / (1 + exp(-2 * abs(${a})))`; + tanh = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Tanh", tanhExpression)); + }; + fastGeluImpl = (varType = "f32") => ` +const fast_gelu_a: ${varType} = 0.5; +const fast_gelu_b: ${varType} = 0.7978845608028654; +const fast_gelu_c: ${varType} = 0.035677408136300125; + +fn tanh_v(v: vec4<${varType}>) -> vec4<${varType}> { + return ${tanhExpression("v")}; +} +`; + fastGeluExpression = (x) => `(fast_gelu_a + fast_gelu_a * tanh_v(${x} * (fast_gelu_c * ${x} * ${x} + fast_gelu_b))) * ${x}`; + fastGelu = (context) => { + const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType); + context.compute(createElementwiseProgramInfo( + context.inputs[0], + "FastGelu", + fastGeluExpression, + fastGeluImpl(dataType), + void 0, + context.inputs[0].dataType + )); + }; + thresholdedRelu = (context, attributes) => { + const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType); + context.compute(createElementwiseProgramInfo( + context.inputs[0], + "ThresholdedRelu", + (a) => `select(vec4<${dataType}>(0.0), ${a}, ${a} > thresholded_relu_alpha_)`, + `const thresholded_relu_alpha_ = vec4<${dataType}>(${attributes.alpha});`, + attributes.cacheKey + )); + return 0; + }; + log = (context) => { + context.compute(createElementwiseProgramInfo(context.inputs[0], "Log", "log")); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/bias-split-gelu.ts +var validateInputs7, createBiasSplitGeluProgramInfo, biasSplitGelu; +var init_bias_split_gelu = __esm({ + "web/lib/wasm/jsep/webgpu/ops/bias-split-gelu.ts"() { + "use strict"; + init_util(); + init_common(); + init_unary_op(); + validateInputs7 = (inputs) => { + if (inputs[0].dims.length !== 3) { + throw new Error("input should have 3 dimensions"); + } + if (![2560, 5120, 10240].includes(inputs[0].dims[2])) { + throw new Error("hidden state should be 2560, 5120 or 10240"); + } + if (inputs[1].dims.length !== 1) { + throw new Error("bias is expected to have 1 dimensions"); + } + if (inputs[0].dims[2] !== inputs[1].dims[0]) { + throw new Error("last dimension of input and bias are not the same"); + } + }; + createBiasSplitGeluProgramInfo = (inputs) => { + const outputShape = inputs[0].dims.slice(); + outputShape[2] = outputShape[2] / 2; + const input = inputVariable("input", inputs[0].dataType, inputs[0].dims, 4); + const bias = inputVariable("bias", inputs[0].dataType, [inputs[0].dims[2]], 4); + const output = outputVariable("output", inputs[0].dataType, outputShape, 4); + const outputSize = ShapeUtil.size(outputShape) / 4; + const dataType = tensorTypeToWsglStorageType(inputs[0].dataType); + const getShaderSource = (shaderHelper) => ` + const M_SQRT2 = sqrt(2.0); + const halfChannels = ${inputs[0].dims[2] / 4 / 2}u; + + ${shaderHelper.declareVariables(input, bias, output)} + + ${erfImpl(dataType)} + + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)} + let biasIdx = global_idx % halfChannels; + let batchIndex = global_idx / halfChannels; + let inputOffset = biasIdx + batchIndex * halfChannels * 2; + let valueLeft = input[inputOffset] + bias[biasIdx]; + let valueRight = input[inputOffset + halfChannels] + bias[biasIdx + halfChannels]; + let geluRight = valueRight * 0.5 * (erf_vf32(valueRight / M_SQRT2) + 1); + + ${output.setByOffset("global_idx", "valueLeft * geluRight")} + }`; + return { + name: "BiasSplitGelu", + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: inputs[0].dataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) } + }), + getShaderSource + }; + }; + biasSplitGelu = (context) => { + validateInputs7(context.inputs); + context.compute(createBiasSplitGeluProgramInfo(context.inputs)); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/binary-op.ts +var createBinaryOpProgramShader, createBinaryOpProgramInfo, runBinaryOp, add, div, equal, mul, pow, sub, greater, less, greaterOrEqual, lessOrEqual; +var init_binary_op = __esm({ + "web/lib/wasm/jsep/webgpu/ops/binary-op.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_common(); + createBinaryOpProgramShader = (shaderHelper, dimsA, dimsB, dimsOutput, vectorize, doBroadcast, sharedDimensionDivisibleBy4, funcCall, typeA, typeB, typeOutput, additionalImplementation) => { + let expressionScalar; + let expressionVector; + if (typeof funcCall === "string") { + expressionScalar = expressionVector = (a2, b2) => `${funcCall}((${a2}),(${b2}))`; + } else if (typeof funcCall === "function") { + expressionScalar = expressionVector = funcCall; + } else { + expressionScalar = funcCall.scalar; + expressionVector = funcCall.vector; + } + const output = outputVariable("outputData", typeOutput, dimsOutput.length, 4); + const a = inputVariable("aData", typeA, dimsA.length, 4); + const b = inputVariable("bData", typeB, dimsB.length, 4); + let assignment; + if (vectorize) { + if (doBroadcast) { + const isAOneElement = ShapeUtil.size(dimsA) === 1; + const isBOneElement = ShapeUtil.size(dimsB) === 1; + const aLastDimDivisibleBy4 = dimsA.length > 0 && dimsA[dimsA.length - 1] % 4 === 0; + const bLastDimDivisibleBy4 = dimsB.length > 0 && dimsB[dimsB.length - 1] % 4 === 0; + if (isAOneElement || isBOneElement) { + assignment = output.setByOffset( + "global_idx", + expressionVector( + isAOneElement ? `${a.type.value}(${a.getByOffset("0")}.x)` : a.getByOffset("global_idx"), + isBOneElement ? `${b.type.value}(${b.getByOffset("0")}.x)` : b.getByOffset("global_idx") + ) + ); + } else { + assignment = ` + let outputIndices = ${output.offsetToIndices("global_idx * 4u")}; + let offsetA = ${a.broadcastedIndicesToOffset("outputIndices", output)}; + let offsetB = ${b.broadcastedIndicesToOffset("outputIndices", output)}; + ${output.setByOffset( + "global_idx", + expressionVector( + sharedDimensionDivisibleBy4 || aLastDimDivisibleBy4 ? a.getByOffset("offsetA / 4u") : `${a.type.value}(${a.getByOffset("offsetA / 4u")}[offsetA % 4u])`, + sharedDimensionDivisibleBy4 || bLastDimDivisibleBy4 ? b.getByOffset("offsetB / 4u") : `${b.type.value}(${b.getByOffset("offsetB / 4u")}[offsetB % 4u])` + ) + )} + `; + } + } else { + assignment = output.setByOffset( + "global_idx", + expressionVector(a.getByOffset("global_idx"), b.getByOffset("global_idx")) + ); + } + } else { + if (!doBroadcast) { + throw new Error("no necessary to use scalar implementation for element-wise binary op implementation."); + } + const singleAssignment = (resStr, x, typeCast = "") => { + const expressionA = `aData[indexA${x}][componentA${x}]`; + const expressionB = `bData[indexB${x}][componentB${x}]`; + return ` + let outputIndices${x} = ${output.offsetToIndices(`global_idx * 4u + ${x}u`)}; + let offsetA${x} = ${a.broadcastedIndicesToOffset(`outputIndices${x}`, output)}; + let offsetB${x} = ${b.broadcastedIndicesToOffset(`outputIndices${x}`, output)}; + let indexA${x} = offsetA${x} / 4u; + let indexB${x} = offsetB${x} / 4u; + let componentA${x} = offsetA${x} % 4u; + let componentB${x} = offsetB${x} % 4u; + ${resStr}[${x}] = ${typeCast}(${expressionScalar(expressionA, expressionB)}); + `; + }; + if (typeOutput === 9 /* bool */) { + assignment = ` + var data = vec4(0); + ${singleAssignment("data", 0, "u32")} + ${singleAssignment("data", 1, "u32")} + ${singleAssignment("data", 2, "u32")} + ${singleAssignment("data", 3, "u32")} + outputData[global_idx] = dot(vec4(0x1, 0x100, 0x10000, 0x1000000), vec4(data));`; + } else { + assignment = ` + ${singleAssignment("outputData[global_idx]", 0)} + ${singleAssignment("outputData[global_idx]", 1)} + ${singleAssignment("outputData[global_idx]", 2)} + ${singleAssignment("outputData[global_idx]", 3)} + `; + } + } + return ` + ${shaderHelper.registerUniform("vec_size", "u32").declareVariables(a, b, output)} + + ${additionalImplementation ?? ""} + + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.vec_size")} + ${assignment} + }`; + }; + createBinaryOpProgramInfo = (name, cacheKey, a, b, funcCall, additionalImplementation, outputDataType = a.dataType) => { + const isBroadcast = !ShapeUtil.areEqual(a.dims, b.dims); + let outputShape = a.dims; + let outputSize = ShapeUtil.size(a.dims); + let vectorize = false; + let sharedDimensionDivisibleBy4 = false; + const cacheKeyAux = [isBroadcast]; + if (isBroadcast) { + const calculatedShape = BroadcastUtil.calcShape(a.dims, b.dims, false); + if (!calculatedShape) { + throw new Error("Can't perform binary op on the given tensors"); + } + outputShape = calculatedShape; + outputSize = ShapeUtil.size(outputShape); + const isAOneElement = ShapeUtil.size(a.dims) === 1; + const isBOneElement = ShapeUtil.size(b.dims) === 1; + const aLastDimDivisibleBy4 = a.dims.length > 0 && a.dims[a.dims.length - 1] % 4 === 0; + const bLastDimDivisibleBy4 = b.dims.length > 0 && b.dims[b.dims.length - 1] % 4 === 0; + cacheKeyAux.push(isAOneElement); + cacheKeyAux.push(isBOneElement); + cacheKeyAux.push(aLastDimDivisibleBy4); + cacheKeyAux.push(bLastDimDivisibleBy4); + let sharedDimension = 1; + for (let i = 1; i < outputShape.length; i++) { + const dimA = a.dims[a.dims.length - i] ?? 1; + const dimB = b.dims[b.dims.length - i] ?? 1; + if (dimA === dimB) { + sharedDimension *= dimA; + } else { + break; + } + } + if (sharedDimension % 4 === 0) { + sharedDimensionDivisibleBy4 = true; + vectorize = true; + } else if (isAOneElement || isBOneElement || aLastDimDivisibleBy4 || bLastDimDivisibleBy4) { + vectorize = true; + } + } else { + vectorize = true; + } + cacheKeyAux.push(vectorize); + return { + name, + shaderCache: { + hint: cacheKey + cacheKeyAux.map((x) => x.toString()).join("_"), + inputDependencies: ["rank", "rank"] + }, + getShaderSource: (shaderHelper) => createBinaryOpProgramShader( + shaderHelper, + a.dims, + b.dims, + outputShape, + vectorize, + isBroadcast, + sharedDimensionDivisibleBy4, + funcCall, + a.dataType, + b.dataType, + outputDataType, + additionalImplementation + ), + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: outputDataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 / 4 + /* component size */ + ) }, + programUniforms: [ + { type: 12 /* uint32 */, data: Math.ceil(ShapeUtil.size(outputShape) / 4) }, + ...createTensorShapeVariables(a.dims, b.dims, outputShape) + ] + }) + }; + }; + runBinaryOp = (context, name, funcCall, additionalImplementation, cacheKey, outputDataType) => { + context.compute(createBinaryOpProgramInfo( + name, + cacheKey ?? "", + context.inputs[0], + context.inputs[1], + funcCall, + additionalImplementation, + outputDataType + )); + }; + add = (context) => { + runBinaryOp(context, "Add", (a, b) => `${a}+${b}`); + }; + div = (context) => { + runBinaryOp(context, "Div", (a, b) => `${a}/${b}`); + }; + equal = (context) => { + runBinaryOp( + context, + "Equal", + { scalar: (a, b) => `u32(${a}==${b})`, vector: (a, b) => `vec4(${a}==${b})` }, + void 0, + void 0, + 9 /* bool */ + ); + }; + mul = (context) => { + runBinaryOp(context, "Mul", (a, b) => `${a}*${b}`); + }; + pow = (context) => { + const type = inputVariable("input", context.inputs[0].dataType, context.inputs[0].dims).type.value; + const roundStr = type === "i32" ? "round" : ""; + runBinaryOp( + context, + "Pow", + { scalar: (a, b) => `pow_custom(${a},${b})`, vector: (a, b) => `pow_vector_custom(${a},${b})` }, + ` + fn pow_custom(a : ${type}, b : ${type}) -> ${type} { + if (b == ${type}(0.0)) { + return ${type}(1.0); + } else if (a < ${type}(0.0) && f32(b) != floor(f32(b))) { + return ${type}(pow(f32(a), f32(b))); // NaN + } + return select(sign(a), ${type}(1.0), round(f32(abs(b) % ${type}(2.0))) != 1.0) * ${type}(${roundStr}(pow(f32(abs(a)), f32(b)))); + } + fn pow_vector_custom(a : vec4<${type}>, b : vec4<${type}>) -> vec4<${type}> { + // TODO: implement vectorized pow + return vec4<${type}>(pow_custom(a.x, b.x), pow_custom(a.y, b.y), pow_custom(a.z, b.z), pow_custom(a.w, b.w)); + } + ` + ); + }; + sub = (context) => { + runBinaryOp(context, "Sub", (a, b) => `${a}-${b}`); + }; + greater = (context) => { + runBinaryOp( + context, + "Greater", + { scalar: (a, b) => `u32(${a}>${b})`, vector: (a, b) => `vec4(${a}>${b})` }, + void 0, + void 0, + 9 /* bool */ + ); + }; + less = (context) => { + runBinaryOp( + context, + "Less", + { scalar: (a, b) => `u32(${a}<${b})`, vector: (a, b) => `vec4(${a}<${b})` }, + void 0, + void 0, + 9 /* bool */ + ); + }; + greaterOrEqual = (context) => { + runBinaryOp( + context, + "GreaterOrEqual", + { scalar: (a, b) => `u32(${a}>=${b})`, vector: (a, b) => `vec4(${a}>=${b})` }, + void 0, + void 0, + 9 /* bool */ + ); + }; + lessOrEqual = (context) => { + runBinaryOp( + context, + "LessOrEqual", + { scalar: (a, b) => `u32(${a}<=${b})`, vector: (a, b) => `vec4(${a}<=${b})` }, + void 0, + void 0, + 9 /* bool */ + ); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/fuse-utils.ts +var getActivationSnippet, appendActivationUniformsData, appendActivationUniforms, parseInternalActivationAttributes; +var init_fuse_utils = __esm({ + "web/lib/wasm/jsep/webgpu/ops/fuse-utils.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + getActivationSnippet = (attributes, valueType, baseType = "f32") => { + switch (attributes.activation) { + case "Relu": + return `value = max(value, ${valueType}(0.0));`; + case "Sigmoid": + return `value = (${valueType}(1.0) / (${valueType}(1.0) + exp(-value)));`; + case "Clip": + return `value = clamp(value, ${valueType}(${baseType}(uniforms.clip_min)), ${valueType}(${baseType}(uniforms.clip_max)));`; + case "HardSigmoid": + return `value = max(${valueType}(0.0), min(${valueType}(1.0), ${baseType}(uniforms.alpha) * value + ${baseType}(uniforms.beta)));`; + case "LeakyRelu": + return `value = select(${baseType}(uniforms.alpha) * value, value, value >= ${valueType}(0.0));`; + case "": + return ""; + default: + throw new Error(`Unsupported activation ${attributes.activation}`); + } + }; + appendActivationUniformsData = (attributes, programUniform) => { + if (attributes.activation === "Clip") { + programUniform.push( + { type: 1 /* float */, data: attributes.clipMax }, + { type: 1 /* float */, data: attributes.clipMin } + ); + } else if (attributes.activation === "HardSigmoid") { + programUniform.push( + { type: 1 /* float */, data: attributes.alpha }, + { type: 1 /* float */, data: attributes.beta } + ); + } else if (attributes.activation === "LeakyRelu") { + programUniform.push({ type: 1 /* float */, data: attributes.alpha }); + } + }; + appendActivationUniforms = (attributes, uniforms) => { + if (attributes.activation === "Clip") { + uniforms.push({ name: "clip_max", type: "f32" }, { name: "clip_min", type: "f32" }); + } else if (attributes.activation === "HardSigmoid") { + uniforms.push({ name: "alpha", type: "f32" }, { name: "beta", type: "f32" }); + } else if (attributes.activation === "LeakyRelu") { + uniforms.push({ name: "alpha", type: "f32" }); + } + }; + parseInternalActivationAttributes = (attributes) => { + const activation = attributes?.activation || ""; + if (activation === "HardSigmoid") { + const [alpha, beta] = attributes?.activation_params || [0.2, 0.5]; + return { activation, alpha, beta }; + } else if (activation === "Clip") { + const [clipMin, clipMax] = attributes?.activation_params || [MIN_CLIP, MAX_CLIP]; + return { activation, clipMax, clipMin }; + } else if (activation === "LeakyRelu") { + const [alpha] = attributes?.activation_params || [0.01]; + return { activation, alpha }; + } + return { activation }; + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/3rd-party/activation_util.ts +var typeSnippet, biasSnippet; +var init_activation_util = __esm({ + "web/lib/wasm/jsep/webgpu/ops/3rd-party/activation_util.ts"() { + "use strict"; + typeSnippet = (component, dataType) => { + switch (component) { + case 1: + return dataType; + case 2: + return `vec2<${dataType}>`; + case 3: + return `vec3<${dataType}>`; + case 4: + return `vec4<${dataType}>`; + default: + throw new Error(`${component}-component is not supported.`); + } + }; + biasSnippet = (hasBias) => ` + ${hasBias ? "value = value + getBiasByOutputCoords(coords);" : ""} + `; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_util.ts +var utilFunctions; +var init_conv_util = __esm({ + "web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_util.ts"() { + "use strict"; + utilFunctions = (strideStr) => ` +fn getIndexFromCoords4D(coords : vec4, shape : vec4) -> i32 { + return dot(coords, vec4( + shape.y * shape.z * shape.w, shape.z * shape.w, shape.w, 1)); +} +fn getOutputIndexFromCoords(coords : vec4) -> i32 { + return dot(coords, vec4( + i32(${strideStr}.x), i32(${strideStr}.y), i32(${strideStr}.z), 1)); +} +`; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/3rd-party/matmul_packed_webgpu.ts +var writeDataToSubAVec4Snippet, calculateResultSnippet, makeMatMulPackedVec4Source, writeDataToSubASnippet, readDataFromSubASnippet, makeMatMulPackedSource, matMulReadWriteFnSource, createMatmulProgramInfo; +var init_matmul_packed_webgpu = __esm({ + "web/lib/wasm/jsep/webgpu/ops/3rd-party/matmul_packed_webgpu.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_common(); + init_fuse_utils(); + init_activation_util(); + writeDataToSubAVec4Snippet = (transpose2, batchDims) => { + if (transpose2) { + return ` + mm_Asub[inputRow][inputCol] = mm_readA(batch, + kStart + inputRow, + globalRowStart / innerElementSize + inputCol${batchDims ? ", batchIndices" : ""}); + `; + } else { + return ` + mm_Asub[inputRow][inputCol] = mm_readA(batch, + globalRow + innerRow, + kStart / innerElementSize + inputCol${batchDims ? ", batchIndices" : ""}); + `; + } + }; + calculateResultSnippet = (transposeA, innerElementSize) => { + if (transposeA) { + return ` + let ACached0 = mm_Asub[k * innerElementSize][localRow]; + let ACached1 = mm_Asub[k * innerElementSize + 1][localRow]; + let ACached2 = mm_Asub[k * innerElementSize + 2][localRow]; + ${innerElementSize === 3 ? "" : "let ACached3 = mm_Asub[k * innerElementSize + 3][localRow];"} + for (var i = 0; i < rowPerThread; i = i + 1) { + acc[i] = BCached0 * ACached0[i] + acc[i]; + acc[i] = BCached1 * ACached1[i] + acc[i]; + acc[i] = BCached2 * ACached2[i] + acc[i]; + ${innerElementSize === 3 ? "" : "acc[i] = BCached3 * ACached3[i] + acc[i];"} + }`; + } else { + return ` + for (var i = 0; i < rowPerThread; i = i + 1) { + let ACached = mm_Asub[tileRow + i][k]; + acc[i] = BCached0 * ACached.x + acc[i]; + acc[i] = BCached1 * ACached.y + acc[i]; + acc[i] = BCached2 * ACached.z + acc[i]; + ${innerElementSize === 3 ? "" : "acc[i] = BCached3 * ACached.w + acc[i];"} + }`; + } + }; + makeMatMulPackedVec4Source = (workPerThread, workgroupSize, type = "f32", batchDims, transposeA = false, tileInner = 32, splitK = false, splitedDimInner = 32) => { + const tileAOuter = workgroupSize[1] * workPerThread[1]; + const tileBOuter = workgroupSize[0] * workPerThread[0]; + const tileAWidth = transposeA ? tileAOuter : tileInner; + const tileAHight = transposeA ? tileInner : tileAOuter; + const innerElementSize = tileAWidth / workgroupSize[0]; + const rowPerThreadB = tileInner / workgroupSize[1]; + if (!((transposeA && innerElementSize === 4 && workPerThread[1] === 4 || !transposeA && (innerElementSize === 3 || innerElementSize === 4)) && tileAWidth % workgroupSize[0] === 0 && tileInner % workgroupSize[1] === 0 && workPerThread[0] === 4)) { + throw new Error(`If transposeA ${transposeA} is true, innerElementSize ${innerElementSize} and workPerThread[1] ${workPerThread[1]} must be 4. + Otherwise, innerElementSize ${innerElementSize} must be 3 or 4. + tileAWidth ${tileAWidth} must be divisible by workgroupSize[0]${workgroupSize[0]}. tileInner ${tileInner} must be divisible by workgroupSize[1] ${workgroupSize[1]}. colPerThread ${workPerThread[0]} must be 4.`); + } + return ` +var mm_Asub: array, ${tileAWidth / innerElementSize}>, ${tileAHight}>; +var mm_Bsub: array, ${tileBOuter / workPerThread[0]}>, ${tileInner}>; + +const rowPerThread = ${workPerThread[1]}; +const colPerThread = ${workPerThread[0]}; +const innerElementSize = ${innerElementSize}; +const tileInner = ${tileInner}; + +@compute @workgroup_size(${workgroupSize[0]}, ${workgroupSize[1]}, ${workgroupSize[2]}) +fn main(@builtin(local_invocation_id) localId : vec3, + @builtin(global_invocation_id) globalId : vec3, + @builtin(workgroup_id) workgroupId : vec3) { + let localRow = i32(localId.y); + let tileRow = localRow * rowPerThread; + let tileCol = i32(localId.x); + + let globalRow =i32(globalId.y) * rowPerThread; + let globalCol = i32(globalId.x); + let batch = ${splitK ? "0" : "i32(globalId.z)"}; + ${batchDims ? `let batchIndices = ${batchDims.offsetToIndices("u32(batch)")};` : ""} + let globalRowStart = i32(workgroupId.y) * ${tileAOuter}; + + let num_tiles = ${splitK ? `${Math.ceil(splitedDimInner / tileInner)}` : "(uniforms.dim_inner - 1) / tileInner + 1"}; + var kStart = ${splitK ? `i32(globalId.z) * ${splitedDimInner}` : "0"}; + + var acc: array, rowPerThread>; + + // Loop over shared dimension. + let tileRowB = localRow * ${rowPerThreadB}; + for (var t = 0; t < num_tiles; t = t + 1) { + // Load one tile of A into local memory. + for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) { + let inputRow = tileRow + innerRow; + let inputCol = tileCol; + ${writeDataToSubAVec4Snippet(transposeA, batchDims)} + } + + // Load one tile of B into local memory. + for (var innerRow = 0; innerRow < ${rowPerThreadB}; innerRow = innerRow + 1) { + let inputRow = tileRowB + innerRow; + let inputCol = tileCol; + mm_Bsub[inputRow][inputCol] = mm_readB(batch, kStart + inputRow, globalCol${batchDims ? ", batchIndices" : ""}); + } + kStart = kStart + tileInner; + workgroupBarrier(); + + // Compute acc values for a single thread. + for (var k = 0; k < tileInner / innerElementSize; k = k + 1) { + let BCached0 = mm_Bsub[k * innerElementSize][tileCol]; + let BCached1 = mm_Bsub[k * innerElementSize + 1][tileCol]; + let BCached2 = mm_Bsub[k * innerElementSize + 2][tileCol]; + ${innerElementSize === 3 ? "" : "let BCached3 = mm_Bsub[k * innerElementSize + 3][tileCol];"} + + ${calculateResultSnippet(transposeA, innerElementSize)} + } + + workgroupBarrier(); + } + + for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) { + mm_write(batch, globalRow + innerRow, globalCol, acc[innerRow]); + } +}`; + }; + writeDataToSubASnippet = (transpose2, batchDims) => { + if (transpose2) { + return ` + mm_Asub[inputRow][inputCol] = mm_readA(batch, + kStart + inputRow, + globalRowStart + inputCol${batchDims ? ", batchIndices" : ""}); + `; + } else { + return ` + mm_Asub[inputRow][inputCol] = mm_readA(batch, + globalRowStart + inputRow, + kStart + inputCol${batchDims ? ", batchIndices" : ""}); + `; + } + }; + readDataFromSubASnippet = (transposeA) => transposeA ? "let ACached = mm_Asub[k][tileRow + innerRow];" : "let ACached = mm_Asub[tileRow + innerRow][k];"; + makeMatMulPackedSource = (workPerThread, workgroupSize, type = "f32", batchDims, transposeA = false, tileInner = 32, splitK = false, splitedDimInner = 32, sequentialAccessByThreads = false) => { + const tileAOuter = workPerThread[1] * workgroupSize[1]; + const tileBOuter = workPerThread[0] * workgroupSize[0]; + const tileAWidth = transposeA ? tileAOuter : tileInner; + const tileAHight = transposeA ? tileInner : tileAOuter; + if (!(tileAHight % workgroupSize[1] === 0 && tileAWidth % workgroupSize[0] === 0 && tileInner % workgroupSize[1] === 0)) { + throw new Error(`tileAHight ${tileAHight} must be divisible by workgroupSize[1]${workgroupSize[1]}, tileAWidth ${tileAWidth} must be divisible by workgroupSize[0]${workgroupSize[0]}, tileInner ${tileInner} must be divisible by workgroupSize[1]${workgroupSize[1]}`); + } + const rowPerThreadA = tileAHight / workgroupSize[1]; + const colPerThreadA = tileAWidth / workgroupSize[0]; + const rowPerThreadB = tileInner / workgroupSize[1]; + const matmulSnippet = sequentialAccessByThreads ? ` + let localRow = i32(localId.y); + let localCol = i32(localId.x); + let globalRowStart = i32(workgroupId.y) * ${tileAOuter}; + let globalColStart = i32(workgroupId.x) * ${tileBOuter}; + + // Loop over shared dimension. + for (var t = 0; t < num_tiles; t = t + 1) { + // Load one tile of A into local memory. + for (var inputRow = localRow; inputRow < ${tileAHight}; inputRow = inputRow + ${workgroupSize[1]}) { + for (var inputCol = localCol; inputCol < ${tileAWidth}; inputCol = inputCol + ${workgroupSize[0]}) { + ${writeDataToSubASnippet(transposeA, batchDims)} + } + } + // Load one tile of B into local memory. + for (var inputRow = localRow; inputRow < ${tileInner}; inputRow = inputRow + ${workgroupSize[1]}) { + for (var inputCol = localCol; inputCol < ${tileBOuter}; inputCol = inputCol + ${workgroupSize[0]}) { + mm_Bsub[inputRow][inputCol] = mm_readB(batch, + kStart + inputRow, + globalColStart + inputCol${batchDims ? ", batchIndices" : ""}); + } + } + kStart = kStart + tileInner; + workgroupBarrier(); + + // Compute acc values for a single thread. + var BCached : array<${type}, colPerThread>; + for (var k = 0; k < tileInner; k = k + 1) { + for (var inner = 0; inner < colPerThread; inner = inner + 1) { + BCached[inner] = mm_Bsub[k][localCol + inner * ${workgroupSize[0]}]; + } + for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) { + let ACached = ${transposeA ? `mm_Asub[k][localRow + innerRow * ${workgroupSize[1]}];` : `mm_Asub[localRow + innerRow * ${workgroupSize[1]}][k];`} + for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) { + acc[innerRow][innerCol] = acc[innerRow][innerCol] + + ACached * BCached[innerCol]; + } + } + } + workgroupBarrier(); + } + for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) { + let gRow = globalRowStart + localRow + innerRow * ${workgroupSize[1]}; + for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) { + let gCol = globalColStart + localCol + innerCol * ${workgroupSize[0]}; + mm_write(batch, gRow, gCol, acc[innerRow][innerCol]); + } + } + ` : ` +let tileRow = i32(localId.y) * rowPerThread; +let tileCol = i32(localId.x) * colPerThread; + +let globalRow = i32(globalId.y) * rowPerThread; +let globalCol = i32(globalId.x) * colPerThread; +let globalRowStart = i32(workgroupId.y) * ${tileAOuter}; + +let tileRowA = i32(localId.y) * ${rowPerThreadA}; +let tileColA = i32(localId.x) * ${colPerThreadA}; +let tileRowB = i32(localId.y) * ${rowPerThreadB}; +// Loop over shared dimension. +for (var t = 0; t < num_tiles; t = t + 1) { + // Load one tile of A into local memory. + for (var innerRow = 0; innerRow < ${rowPerThreadA}; innerRow = innerRow + 1) { + for (var innerCol = 0; innerCol < ${colPerThreadA}; innerCol = innerCol + 1) { + let inputRow = tileRowA + innerRow; + let inputCol = tileColA + innerCol; + ${writeDataToSubASnippet(transposeA, batchDims)} + } + } + + // Load one tile of B into local memory. + for (var innerRow = 0; innerRow < ${rowPerThreadB}; innerRow = innerRow + 1) { + for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) { + let inputRow = tileRowB + innerRow; + let inputCol = tileCol + innerCol; + mm_Bsub[inputRow][inputCol] = mm_readB(batch, + kStart + inputRow, + globalCol + innerCol${batchDims ? ", batchIndices" : ""}); + } + } + kStart = kStart + tileInner; + workgroupBarrier(); + + // Compute acc values for a single thread. + var BCached : array<${type}, colPerThread>; + for (var k = 0; k < tileInner; k = k + 1) { + for (var inner = 0; inner < colPerThread; inner = inner + 1) { + BCached[inner] = mm_Bsub[k][tileCol + inner]; + } + + for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) { + ${readDataFromSubASnippet(transposeA)} + for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) { + acc[innerRow][innerCol] = acc[innerRow][innerCol] + ACached * BCached[innerCol]; + } + } + } + + workgroupBarrier(); +} + +for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) { + for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) { + mm_write(batch, globalRow + innerRow, globalCol + innerCol, + acc[innerRow][innerCol]); + } +} +`; + return ` + var mm_Asub : array, ${tileAHight}>; + var mm_Bsub : array, ${tileInner}>; + const rowPerThread = ${workPerThread[1]}; + const colPerThread = ${workPerThread[0]}; + const tileInner = ${tileInner}; + +@compute @workgroup_size(${workgroupSize[0]}, ${workgroupSize[1]}, ${workgroupSize[2]}) +fn main(@builtin(local_invocation_id) localId : vec3, + @builtin(global_invocation_id) globalId : vec3, + @builtin(workgroup_id) workgroupId : vec3) { + let batch = ${splitK ? "0" : "i32(globalId.z)"}; + ${batchDims ? `let batchIndices = ${batchDims.offsetToIndices("u32(batch)")};` : ""} + let num_tiles = ${splitK ? `${Math.ceil(splitedDimInner / tileInner)}` : "(uniforms.dim_inner - 1) / tileInner + 1"}; + var kStart = ${splitK ? `i32(globalId.z) * ${splitedDimInner}` : "0"}; + + var acc : array, rowPerThread>; + + // Without this initialization strange values show up in acc. + for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) { + for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) { + acc[innerRow][innerCol] = 0.0; + } + } + ${matmulSnippet} + } +`; + }; + matMulReadWriteFnSource = (component, hasBias, applyActivation, variables, batchShapes, isChannelsLast = false) => { + const [batchAShape, batchBShape, batchShape] = batchShapes; + const [batchVariable, aVariable, bVariable, outputVariable2] = variables; + const broadCastADims = getBroadcastDims(batchAShape, batchShape); + const broadCastBDims = getBroadcastDims(batchBShape, batchShape); + const dataType = tensorTypeToWsglStorageType(variables[0].type.tensor); + const getAIndices = () => { + const aRank = aVariable.rank; + const batchRank = batchVariable.rank; + let resStr = `var aIndices: ${aVariable.type.indices};`; + for (let i = aRank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) { + resStr += ` +aIndices[${i}] = ${batchRank > 1 ? `batchIndices[${j}]` : "batchIndices"};`; + } + broadCastADims.forEach((i) => { + resStr += ` +aIndices[${i}] = 0;`; + }); + resStr += ` +aIndices[${aRank - 2}] = u32(row); + aIndices[${aRank - 1}] = u32(colIn);`; + return resStr; + }; + const getBIndices = () => { + const bRank = bVariable.rank; + const batchRank = batchVariable.rank; + let resStr = `var bIndices: ${bVariable.type.indices};`; + for (let i = bRank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) { + resStr += ` +bIndices[${i}] = ${batchRank > 1 ? `batchIndices[${j}]` : "batchIndices"};`; + } + broadCastBDims.forEach((i) => { + resStr += ` +bIndices[${i}] = 0;`; + }); + resStr += ` +bIndices[${bRank - 2}] = u32(row); + bIndices[${bRank - 1}] = u32(colIn);`; + return resStr; + }; + const source = ` + fn mm_readA(batch: i32, row: i32, colIn: i32, batchIndices: ${batchVariable.type.indices}) -> ${typeSnippet(component, dataType)} { + var value = ${typeSnippet(component, dataType)}(0.0); + let col = colIn * ${component}; + if(row < uniforms.dim_a_outer && col < uniforms.dim_inner) + { + ${getAIndices()} + value = ${aVariable.getByIndices("aIndices")}; + } + return value; + } + + fn mm_readB(batch: i32, row: i32, colIn: i32, batchIndices: ${batchVariable.type.indices}) -> ${typeSnippet(component, dataType)} { + var value = ${typeSnippet(component, dataType)}(0.0); + let col = colIn * ${component}; + if(row < uniforms.dim_inner && col < uniforms.dim_b_outer) + { + ${getBIndices()} + value = ${bVariable.getByIndices("bIndices")}; + } + return value; + } + + fn mm_write(batch: i32, row: i32, colIn: i32, valueIn: ${typeSnippet(component, dataType)}) { + let col = colIn * ${component}; + if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer) { + var value = valueIn; + let coords = vec3(batch, row, colIn); + ${hasBias ? `value = value + ${isChannelsLast ? "bias[colIn]" : `${typeSnippet(component, dataType)}(bias[row])`};` : ""} + ${applyActivation} + ${outputVariable2.setByIndices("vec3(coords)", "value")} + } + } + `; + return source; + }; + createMatmulProgramInfo = (inputs, activationAttributes, outputShape, reshapedOutputShape, isChannelsLast = false) => { + const aShape = inputs[0].dims; + const bShape = inputs[1].dims; + const outerDimsA = aShape.slice(0, -2); + const outerDimsB = bShape.slice(0, -2); + const outerDims = reshapedOutputShape ? reshapedOutputShape.slice(0, -2) : outputShape.slice(0, -2); + const batchSize = ShapeUtil.size(outerDims); + const dimAOuter = aShape[aShape.length - 2]; + const dimInner = aShape[aShape.length - 1]; + const dimBOuter = bShape[bShape.length - 1]; + const isVec4 = dimInner % 4 === 0 && dimBOuter % 4 === 0; + const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1]; + const workgroupSize = [8, 8, 1]; + const dispatch = [ + Math.ceil(dimBOuter / workgroupSize[0] / elementsPerThread[0]), + Math.ceil(dimAOuter / workgroupSize[1] / elementsPerThread[1]), + Math.ceil(batchSize / workgroupSize[2] / elementsPerThread[2]) + ]; + const components = isVec4 ? 4 : 1; + const aShapeTemp = [...outerDimsA, dimAOuter, dimInner / components]; + const aRank = aShapeTemp.length; + const bShapeTemp = [...outerDimsB, dimInner, dimBOuter / components]; + const bRank = bShapeTemp.length; + const outputShapeTemp = [batchSize, dimAOuter, dimBOuter / components]; + const programUniforms = [ + { type: 6 /* int32 */, data: dimAOuter }, + { type: 6 /* int32 */, data: dimBOuter }, + { type: 6 /* int32 */, data: dimInner } + ]; + appendActivationUniformsData(activationAttributes, programUniforms); + programUniforms.push(...createTensorShapeVariables(outerDims, aShapeTemp, bShapeTemp)); + const inputDependencies = ["rank", "rank"]; + const hasBias = inputs.length > 2; + if (hasBias) { + programUniforms.push(...createTensorShapeVariables(inputs[2].dims)); + inputDependencies.push("rank"); + } + programUniforms.push(...createTensorShapeVariables(outputShapeTemp)); + const getShaderSource = (shaderHelper) => { + const batchRank = outerDims.length; + const batchDims = internalVariable("batchDims", inputs[0].dataType, batchRank, 1); + const dataType = tensorTypeToWsglStorageType(inputs[0].dataType); + const A = inputVariable("a", inputs[0].dataType, aRank, components); + const B = inputVariable("b", inputs[1].dataType, bRank, components); + const output = outputVariable("result", inputs[0].dataType, outputShapeTemp.length, components); + const inputVariables = [A, B]; + if (hasBias) { + const biasComponents = isChannelsLast ? components : 1; + inputVariables.push(inputVariable("bias", inputs[2].dataType, inputs[2].dims.length, biasComponents)); + } + const uniforms = [{ name: "dim_a_outer", type: "i32" }, { name: "dim_b_outer", type: "i32" }, { name: "dim_inner", type: "i32" }]; + appendActivationUniforms(activationAttributes, uniforms); + const baseType = tensorTypeToWsglStorageType(output.type.tensor); + const applyActivation = getActivationSnippet(activationAttributes, output.type.value, baseType); + const declareFunctions = matMulReadWriteFnSource( + components, + hasBias, + applyActivation, + [batchDims, A, B, output], + [outerDimsA, outerDimsB, outerDims], + isChannelsLast + ); + return ` + ${shaderHelper.registerUniforms(uniforms).registerInternalVariables(batchDims).declareVariables( + ...inputVariables, + output + )} + ${declareFunctions} + ${isVec4 ? makeMatMulPackedVec4Source(elementsPerThread, workgroupSize, dataType, batchDims) : makeMatMulPackedSource(elementsPerThread, workgroupSize, dataType, batchDims)} + `; + }; + return { + name: "MatMul", + shaderCache: { + hint: `${elementsPerThread};${activationAttributes.activation};${isVec4};${isChannelsLast}`, + inputDependencies + }, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: inputs[0].dataType }], + dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] }, + programUniforms + }), + getShaderSource + }; + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/3rd-party/conv2d_mm_webgpu.ts +var conv2dCommonSnippet, createConv2DMatMulProgramInfo; +var init_conv2d_mm_webgpu = __esm({ + "web/lib/wasm/jsep/webgpu/ops/3rd-party/conv2d_mm_webgpu.ts"() { + "use strict"; + init_wasm_common(); + init_log(); + init_common(); + init_fuse_utils(); + init_activation_util(); + init_conv_util(); + init_matmul_packed_webgpu(); + conv2dCommonSnippet = (isChannelsLast, fitAOuter, fitBOuter, fitInner, addBias = false, attributes, innerElementSizeX = 4, innerElementSizeW = 4, innerElementSize = 4, dataType = "f32") => { + const getXSnippet = (innerElementSize2) => { + switch (innerElementSize2) { + case 1: + return "resData = x[xIndex];"; + case 3: + return `resData = vec3<${dataType}>(x[xIndex], x[xIndex + 1], x[xIndex + 2]);`; + case 4: + return "resData = x[xIndex / 4];"; + default: + throw new Error(`innerElementSize ${innerElementSize2} is not supported.`); + } + }; + const getWSnippet = (innerElementSize2) => { + switch (innerElementSize2) { + case 1: + return "return w[row * i32(uniforms.w_shape[3]) + colIn];"; + case 4: + return "return w[row * i32(uniforms.w_shape[3]) / 4 + colIn];"; + default: + throw new Error(`innerElementSize ${innerElementSize2} is not supported.`); + } + }; + const coordASnippet = isChannelsLast ? ` + let coord = vec4(batch, xRow, xCol, xCh); + ` : ` + let coord = vec4(batch, xCh, xRow, xCol); + `; + const coordResSnippet = isChannelsLast ? ` + let coords = vec4( + batch, + row / outWidth, + row % outWidth, + col); + ` : ` + let coords = vec4( + batch, + row, + col / outWidth, + col % outWidth); + `; + const xHeight = isChannelsLast ? "i32(uniforms.x_shape[1])" : "i32(uniforms.x_shape[2])"; + const xWidth = isChannelsLast ? "i32(uniforms.x_shape[2])" : "i32(uniforms.x_shape[3])"; + const row = isChannelsLast ? "row" : "col"; + const col = isChannelsLast ? "col" : "row"; + const readXSnippet = ` + let inChannels = i32(uniforms.w_shape[2]); + let outWidth = ${isChannelsLast ? "i32(uniforms.result_shape[2])" : "i32(uniforms.result_shape[3])"}; + let outRow = ${row} / outWidth; + let outCol = ${row} % outWidth; + + let WRow = ${col} / (i32(uniforms.w_shape[1]) * inChannels); + let WCol = ${col} / inChannels % i32(uniforms.w_shape[1]); + let xRow = outRow * uniforms.stride[0] + uniforms.dilation[0] * WRow - uniforms.pad[0]; + let xCol = outCol * uniforms.stride[1] + uniforms.dilation[1] * WCol - uniforms.pad[1]; + let xCh = ${col} % inChannels; + var resData = ${typeSnippet(innerElementSizeX, dataType)}(0.0); + // The bounds checking is always needed since we use it to pad zero for + // the 'same' padding type. + if (xRow >= 0 && xRow < ${xHeight} && xCol >= 0 && xCol < ${xWidth}) { + ${coordASnippet} + let xIndex = getIndexFromCoords4D(coord, vec4(uniforms.x_shape)); + ${getXSnippet(innerElementSizeX)} + } + return resData;`; + const sampleX = isChannelsLast ? fitAOuter && fitInner ? ` + let col = colIn * ${innerElementSizeX}; + ${readXSnippet}` : ` + let col = colIn * ${innerElementSizeX}; + if (row < uniforms.dim_a_outer && col < uniforms.dim_inner) { + ${readXSnippet} + } + return ${typeSnippet(innerElementSizeX, dataType)}(0.0);` : fitInner && fitBOuter ? ` + let col = colIn * ${innerElementSizeX}; + ${readXSnippet}` : ` + let col = colIn * ${innerElementSizeX}; + if (row < uniforms.dim_inner && col < uniforms.dim_b_outer) { + ${readXSnippet} + } + return ${typeSnippet(innerElementSizeX, dataType)}(0.0);`; + const sampleW = `${getWSnippet(innerElementSizeW)}`; + const resType = typeSnippet(innerElementSize, dataType); + const aType = isChannelsLast ? typeSnippet(innerElementSizeX, dataType) : typeSnippet(innerElementSizeW, dataType); + const bType = isChannelsLast ? typeSnippet(innerElementSizeW, dataType) : typeSnippet(innerElementSizeX, dataType); + const applyActivation = getActivationSnippet(attributes, resType, dataType); + const userCode = ` + fn mm_readA(batch: i32, row : i32, colIn : i32) -> ${aType} { + ${isChannelsLast ? sampleX : sampleW} + } + + fn mm_readB(batch: i32, row : i32, colIn : i32) -> ${bType} { + ${isChannelsLast ? sampleW : sampleX} + } + + fn mm_write(batch: i32, row : i32, colIn : i32, valueIn : ${resType}) { + let col = colIn * ${innerElementSize}; + if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer) + { + var value = valueIn; + let outWidth = ${isChannelsLast ? "i32(uniforms.result_shape[2])" : "i32(uniforms.result_shape[3])"}; + ${coordResSnippet} + ${biasSnippet(addBias)} + ${applyActivation} + setOutputAtCoords(coords[0], coords[1], coords[2], coords[3], value); + } + }`; + return userCode; + }; + createConv2DMatMulProgramInfo = (inputs, attributes, outputShape, dimAOuter, dimBOuter, dimInner, hasBias, sequentialAccessByThreads) => { + const isChannelsLast = attributes.format === "NHWC"; + const inChannels = isChannelsLast ? inputs[0].dims[3] : inputs[0].dims[1]; + const batchSize = outputShape[0]; + const outWidth = isChannelsLast ? outputShape[2] : outputShape[3]; + const outHeight = isChannelsLast ? outputShape[1] : outputShape[2]; + const outChannels = isChannelsLast ? outputShape[3] : outputShape[1]; + const isVec4 = isChannelsLast && (inChannels % 4 === 0 || inChannels % 3 === 0) && outChannels % 4 === 0; + const dispatchX = isChannelsLast ? outChannels : outWidth * outHeight; + const dispatchY = isChannelsLast ? outWidth * outHeight : outChannels; + const workGroupSize = [8, 8, 1]; + const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1]; + const dispatch = [ + Math.ceil(dispatchX / workGroupSize[0] / elementsPerThread[0]), + Math.ceil(dispatchY / workGroupSize[1] / elementsPerThread[1]), + Math.ceil(batchSize / workGroupSize[2] / elementsPerThread[2]) + ]; + LOG_DEBUG("verbose", () => `[conv2d_mm_webgpu] dispatch = ${dispatch}`); + const innerElementSize = isVec4 ? isChannelsLast && inChannels % 4 !== 0 ? 3 : 4 : 1; + const tileAOuter = workGroupSize[1] * elementsPerThread[1]; + const tileBOuter = workGroupSize[0] * elementsPerThread[0]; + const tileInner = Math.max(workGroupSize[0] * innerElementSize, workGroupSize[1]); + const fitAOuter = dimAOuter % tileAOuter === 0; + const fitBOuter = dimBOuter % tileBOuter === 0; + const fitInner = dimInner % tileInner === 0; + const elementsSize = isVec4 ? [innerElementSize, 4, 4] : [1, 1, 1]; + const programUniforms = [ + { type: 6 /* int32 */, data: dimAOuter }, + { type: 6 /* int32 */, data: dimBOuter }, + { type: 6 /* int32 */, data: dimInner }, + { type: 6 /* int32 */, data: [attributes.pads[0], attributes.pads[1]] }, + { type: 6 /* int32 */, data: attributes.strides }, + { type: 6 /* int32 */, data: attributes.dilations } + ]; + appendActivationUniformsData(attributes, programUniforms); + programUniforms.push(...createTensorShapeVariables(inputs[0].dims, inputs[1].dims)); + const inputDependencies = ["rank", "rank"]; + if (hasBias) { + programUniforms.push(...createTensorShapeVariables(inputs[2].dims)); + inputDependencies.push("rank"); + } + programUniforms.push(...createTensorShapeVariables(outputShape)); + const getShaderSource = (shaderHelper) => { + const uniforms = [ + { name: "dim_a_outer", type: "i32" }, + { name: "dim_b_outer", type: "i32" }, + { name: "dim_inner", type: "i32" }, + { name: "pad", type: "i32", length: 2 }, + { name: "stride", type: "i32", length: 2 }, + { name: "dilation", type: "i32", length: 2 } + ]; + appendActivationUniforms(attributes, uniforms); + const components = isVec4 ? 4 : 1; + const t = tensorTypeToWsglStorageType(inputs[0].dataType); + let declareFunctions = ` + fn setOutputAtIndex(flatIndex : i32, value : ${isVec4 ? `vec4<${t}>` : t}) { + result[flatIndex] = ${isVec4 ? `vec4<${t}>` : t}(value); + } + fn setOutputAtCoords(d0 : i32, d1 : i32, d2 : i32, d3 : i32, value : ${isVec4 ? `vec4<${t}>` : t}) { + let flatIndex = getOutputIndexFromCoords(vec4(d0, d1, d2, d3)); + setOutputAtIndex(flatIndex ${isVec4 ? "/ 4" : ""}, value); + }`; + const x = inputVariable( + "x", + inputs[0].dataType, + inputs[0].dims.length, + innerElementSize === 3 ? 1 : innerElementSize + ); + const w = inputVariable("w", inputs[1].dataType, inputs[1].dims.length, components); + const inputVariables = [x, w]; + const output = outputVariable("result", inputs[0].dataType, outputShape.length, components); + if (hasBias) { + const bias = inputVariable("bias", inputs[2].dataType, inputs[2].dims.length, components); + inputVariables.push(bias); + declareFunctions += ` + fn getBiasByOutputCoords(coords : vec4) -> ${isVec4 ? `vec4<${t}>` : t} { + return bias[coords.${isChannelsLast ? "w" : "y"}${isVec4 ? "/ 4" : ""}]; + }`; + } + return ` + ${utilFunctions("uniforms.result_strides")} + //struct Uniforms { xShape : vec4, wShape : vec4, outShape : vec4, + // outShapeStrides: vec3, filterDims : vec2, pad : vec2, stride : vec2, + // dilation : vec2, dimAOuter : i32, dimBOuter : i32, dimInner : i32 }; + ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)} + ${declareFunctions} + ${conv2dCommonSnippet( + isChannelsLast, + fitAOuter, + fitBOuter, + fitInner, + hasBias, + attributes, + elementsSize[0], + elementsSize[1], + elementsSize[2], + t + )} + ${isVec4 ? makeMatMulPackedVec4Source(elementsPerThread, workGroupSize, t, void 0, !isChannelsLast, tileInner) : makeMatMulPackedSource( + elementsPerThread, + workGroupSize, + t, + void 0, + !isChannelsLast, + tileInner, + false, + void 0, + sequentialAccessByThreads + )}`; + }; + return { + name: "Conv2DMatMul", + shaderCache: { + hint: `${attributes.cacheKey};${innerElementSize};${isVec4};${fitAOuter};${fitBOuter};${fitInner};${tileAOuter};${tileBOuter};${tileInner}`, + inputDependencies + }, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: inputs[0].dataType }], + dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] }, + programUniforms + }), + getShaderSource + }; + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/conv-grouped.ts +var createGroupedConvProgramInfo, createGroupedConvVectorizeProgramInfo; +var init_conv_grouped = __esm({ + "web/lib/wasm/jsep/webgpu/ops/conv-grouped.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_common(); + init_conv(); + init_fuse_utils(); + createGroupedConvProgramInfo = (inputs, attributes, squeezeOutputShapeFunction) => { + const hasBias = inputs.length > 2; + const processBias = hasBias ? "value += b[output_channel];" : ""; + const xShape = inputs[0].dims; + const wShape = inputs[1].dims; + const outputChannelsPerGroup = wShape[0] / attributes.group; + const isChannelLast = attributes.format === "NHWC"; + const outputShape = calculateOutputShape( + xShape, + wShape, + attributes.dilations, + attributes.pads, + attributes.strides, + isChannelLast + ); + const outputSize = ShapeUtil.size(outputShape); + const programUniforms = [ + { type: 12 /* uint32 */, data: outputSize }, + { type: 12 /* uint32 */, data: attributes.dilations }, + { type: 12 /* uint32 */, data: [attributes.strides[0], attributes.strides[1]] }, + { type: 12 /* uint32 */, data: [attributes.pads[0], attributes.pads[1]] }, + { type: 12 /* uint32 */, data: outputChannelsPerGroup } + ]; + appendActivationUniformsData(attributes, programUniforms); + programUniforms.push(...createTensorShapeVariables(xShape, wShape)); + const inputDependencies = ["rank", "rank"]; + if (hasBias) { + programUniforms.push(...createTensorShapeVariables(inputs[2].dims)); + inputDependencies.push("rank"); + } + programUniforms.push(...createTensorShapeVariables(outputShape)); + const getShaderSource = (shaderHelper) => { + const output = outputVariable("output", inputs[0].dataType, outputShape.length); + const baseType = tensorTypeToWsglStorageType(output.type.tensor); + const applyActivation = getActivationSnippet(attributes, output.type.value, baseType); + const x = inputVariable("x", inputs[0].dataType, xShape.length); + const w = inputVariable("w", inputs[1].dataType, wShape.length); + const inputVars = [x, w]; + if (hasBias) { + inputVars.push(inputVariable("b", inputs[2].dataType, inputs[2].dims.length)); + } + const uniforms = [ + { name: "output_size", type: "u32" }, + { name: "dilations", type: "u32", length: attributes.dilations.length }, + { name: "strides", type: "u32", length: 2 }, + { name: "pads", type: "u32", length: 2 }, + { name: "output_channels_per_group", type: "u32" } + ]; + appendActivationUniforms(attributes, uniforms); + return ` + ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)} + + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")} + + let outputIndices = ${output.offsetToIndices("global_idx")}; + let batch: u32 = outputIndices[0]; + let output_channel: u32 = outputIndices[${isChannelLast ? 3 : 1}]; + let xRCCorner: vec2 = vec2(outputIndices[${isChannelLast ? 1 : 2}], outputIndices[${isChannelLast ? 2 : 3}]) * uniforms.strides - uniforms.pads; + let group_id: u32 = output_channel / uniforms.output_channels_per_group; + + var value: ${output.type.value} = ${output.type.value}(0); + for (var wInChannel: u32 = 0u; wInChannel < uniforms.w_shape[1]; wInChannel++) { + let input_channel = group_id * uniforms.w_shape[1] + wInChannel; + for (var wHeight: u32 = 0u; wHeight < uniforms.w_shape[2]; wHeight++) { + let xHeight = xRCCorner.x + wHeight * uniforms.dilations[0]; + + if (xHeight < 0u || xHeight >= uniforms.x_shape[${isChannelLast ? 1 : 2}]) { + continue; + } + + for (var wWidth: u32 = 0u; wWidth < uniforms.w_shape[3]; wWidth++) { + let xWidth = xRCCorner.y + wWidth * uniforms.dilations[1]; + if (xWidth < 0u || xWidth >= uniforms.x_shape[${isChannelLast ? 2 : 3}]) { + continue; + } + + let xVal = ${isChannelLast ? x.get("batch", "xHeight", "xWidth", "input_channel") : x.get("batch", "input_channel", "xHeight", "xWidth")}; + let wVal = ${w.get("output_channel", "wInChannel", "wHeight", "wWidth")}; + value += xVal*wVal; + } + } + } + ${processBias} + ${applyActivation} + ${output.setByOffset("global_idx", "value")} + }`; + }; + return { + name: "GroupedConv", + shaderCache: { hint: attributes.cacheKey, inputDependencies }, + getRunData: () => ({ + outputs: [{ + dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape, + dataType: inputs[0].dataType + }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms + }), + getShaderSource + }; + }; + createGroupedConvVectorizeProgramInfo = (inputs, attributes, outputShape) => { + const hasBias = inputs.length > 2; + const components = getMaxComponents(outputShape[3]); + const outputNumber = getMaxComponents(outputShape[2]); + const outputSize = ShapeUtil.size(outputShape) / components / outputNumber; + const xShape = [inputs[0].dims[0], inputs[0].dims[1], inputs[0].dims[2], inputs[0].dims[3] / components]; + const wShape = [inputs[1].dims[0], inputs[1].dims[1], inputs[1].dims[2], inputs[1].dims[3] / components]; + const outputShapeInShader = [outputShape[0], outputShape[1], outputShape[2], outputShape[3] / components]; + const programUniforms = [ + { type: 12 /* uint32 */, data: outputSize }, + { type: 6 /* int32 */, data: [attributes.strides[0], attributes.strides[1]] }, + { type: 6 /* int32 */, data: [attributes.pads[0], attributes.pads[1]] } + ]; + appendActivationUniformsData(attributes, programUniforms); + programUniforms.push(...createTensorShapeVariables(xShape, wShape, outputShapeInShader)); + const xNumber = (outputNumber - 1) * attributes.strides[1] + wShape[1]; + const getShaderSource = (shaderHelper) => { + const output = outputVariable("output", inputs[0].dataType, outputShapeInShader.length, components); + const baseType = tensorTypeToWsglStorageType(output.type.tensor); + const applyActivation = getActivationSnippet(attributes, output.type.value, baseType); + const x = inputVariable("x", inputs[0].dataType, xShape.length, components); + const w = inputVariable("w", inputs[1].dataType, wShape.length, components); + const inputVars = [x, w]; + if (hasBias) { + inputVars.push(inputVariable("b", inputs[2].dataType, inputs[2].dims, components)); + } + const processBias = hasBias ? "value += b[output_channel];" : ""; + const uniforms = [ + { name: "output_size", type: "u32" }, + { name: "strides", type: "i32", length: 2 }, + { name: "pads", type: "i32", length: 2 } + ]; + appendActivationUniforms(attributes, uniforms); + return ` + ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)} + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")} + let width0 = uniforms.output_shape[3]; + let output_channel = global_idx % width0; + var index1 = global_idx / width0; + let width1 = uniforms.output_shape[2] / ${outputNumber}u; + let col = (index1 % width1) * ${outputNumber}u; + index1 = index1 / width1; + let row = index1 % uniforms.output_shape[1]; + let batch = index1 / uniforms.output_shape[1]; + + let x_corner = vec2(i32(row), i32(col)) * uniforms.strides - uniforms.pads; + + var x_vals: array<${x.type.value}, ${xNumber}>; + var values: array<${output.type.value}, ${outputNumber}>; + let input_channel = output_channel; + // Use constant instead of uniform can give better performance for w's height/width. + for (var w_height: u32 = 0u; w_height < ${wShape[0]}; w_height++) { + let x_height = x_corner.x + i32(w_height); + if (x_height >= 0 && u32(x_height) < uniforms.x_shape[1]) { + for (var i = 0; i < ${xNumber}; i++) { + let x_width = x_corner.y + i; + if (x_width >= 0 && u32(x_width) < uniforms.x_shape[2]) { + x_vals[i] = ${x.get("batch", "u32(x_height)", "u32(x_width)", "input_channel")}; + } else { + x_vals[i] = ${x.type.value}(0); + } + } + for (var w_width: u32 = 0u; w_width < ${wShape[1]}; w_width++) { + let w_val = ${w.get("w_height", "w_width", "0", "output_channel")}; + for (var i = 0u; i < ${outputNumber}u; i++) { + values[i] = fma(x_vals[i * u32(uniforms.strides[1]) + w_width], w_val, values[i]); + } + } + } + } + + for (var i = 0u; i < ${outputNumber}u; i++) { + var value = values[i]; + ${processBias} + ${applyActivation} + ${output.set("batch", "row", "col + i", "output_channel", "value")}; + } + }`; + }; + return { + name: "GroupedConv-Vectorize", + shaderCache: { + hint: `${attributes.cacheKey};${components};${outputNumber};${xNumber};${wShape[0]};${wShape[1]}`, + inputDependencies: hasBias ? ["rank", "rank", "type"] : ["rank", "rank"] + }, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: inputs[0].dataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms + }), + getShaderSource + }; + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/matmul.ts +var createNaiveMatmulProgramInfo, validateInputs8, matMul; +var init_matmul = __esm({ + "web/lib/wasm/jsep/webgpu/ops/matmul.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_matmul_packed_webgpu(); + init_common(); + init_fuse_utils(); + createNaiveMatmulProgramInfo = (inputs, activationAttributes, outputShape, reshapedOutputShape, isChannelsLast = false) => { + const aShape = inputs[0].dims; + const bShape = inputs[1].dims; + const M = aShape[aShape.length - 2]; + const N = bShape[bShape.length - 1]; + const K = aShape[aShape.length - 1]; + const components = getMaxComponents(N); + const aComponents = getMaxComponents(K); + const outputNumber = getMaxComponents(M); + const outputSize = ShapeUtil.size(outputShape) / components / outputNumber; + const hasBias = inputs.length > 2; + const outerDims = reshapedOutputShape ? reshapedOutputShape.slice(0, -2) : outputShape.slice(0, -2); + const batchSize = ShapeUtil.size(outerDims); + const outputShapeInShader = [batchSize, M, N]; + const programUniforms = [ + { type: 12 /* uint32 */, data: outputSize }, + { type: 12 /* uint32 */, data: M }, + { type: 12 /* uint32 */, data: N }, + { type: 12 /* uint32 */, data: K } + ]; + appendActivationUniformsData(activationAttributes, programUniforms); + programUniforms.push(...createTensorShapeVariables(outerDims, aShape, bShape)); + if (hasBias) { + programUniforms.push(...createTensorShapeVariables(inputs[2].dims)); + } + programUniforms.push(...createTensorShapeVariables(outputShapeInShader)); + const getShaderSource = (shaderHelper) => { + const batchDims = internalVariable("batch_dims", inputs[0].dataType, outerDims.length); + const a = inputVariable("a", inputs[0].dataType, aShape.length, aComponents); + const b = inputVariable("b", inputs[1].dataType, bShape.length, components); + const output = outputVariable("output", inputs[0].dataType, outputShapeInShader.length, components); + const baseType = tensorTypeToWsglStorageType(output.type.tensor); + const applyActivation = getActivationSnippet(activationAttributes, output.type.value, baseType); + const inputVariables = [a, b]; + let processBias = ""; + if (hasBias) { + const biasComponents = isChannelsLast ? components : 1; + inputVariables.push(inputVariable("bias", inputs[2].dataType, inputs[2].dims.length, biasComponents)); + processBias = `${isChannelsLast ? `value += bias[col / ${biasComponents}];` : `value += ${output.type.value}(bias[row + i]);`}`; + } + const outerDimsA = aShape.slice(0, -2); + const outerDimsB = bShape.slice(0, -2); + const broadCastADims = getBroadcastDims(outerDimsA, outerDims); + const broadCastBDims = getBroadcastDims(outerDimsB, outerDims); + const uniforms = [ + { name: "output_size", type: "u32" }, + { name: "M", type: "u32" }, + { name: "N", type: "u32" }, + { name: "K", type: "u32" } + ]; + appendActivationUniforms(activationAttributes, uniforms); + const getIndices = (variable, broadCastDims) => { + const rank = variable.rank; + const name = variable.name; + if (rank === 2) { + return `var ${name}_indices = ${variable.type.indices}(0u, 0u);`; + } + const batchRank = batchDims.rank; + let resStr = `var ${name}_indices: ${variable.type.indices};`; + for (let i = rank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) { + resStr += ` +${name}_indices[${i}] = ${batchRank > 1 ? `batch_indices[${j}]` : "batch_indices"};`; + } + broadCastDims.forEach((i) => { + resStr += ` +${name}_indices[${i}] = 0;`; + }); + resStr += `${name}_indices[${rank - 2}] = 0u; + ${name}_indices[${rank - 1}] = 0u;`; + return resStr; + }; + const calcResult = () => { + let calcStr = `var a_data: ${a.type.value};`; + for (let i = 0; i < aComponents; i++) { + calcStr += ` + let b_data${i} = b[(b_offset + (k + ${i}) * uniforms.N + col) / ${components}];`; + } + for (let i = 0; i < outputNumber; i++) { + calcStr += `a_data = a[(a_offset + (row + ${i}) * uniforms.K + k) / ${aComponents}];`; + for (let j = 0; j < aComponents; j++) { + calcStr += ` + values[${i}] = fma(${b.type.value}(a_data${aComponents === 1 ? "" : `[${j}]`}), b_data${j}, values[${i}]); +`; + } + } + return calcStr; + }; + return ` + ${shaderHelper.registerUniforms(uniforms).registerInternalVariables(batchDims).declareVariables( + ...inputVariables, + output + )} + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")} + let col = (global_idx % (uniforms.N / ${components})) * ${components}; + var index1 = global_idx / (uniforms.N / ${components}); + let stride1 = uniforms.M / ${outputNumber}; + let row = (index1 % stride1) * ${outputNumber}; + let batch = index1 / stride1; + + ${outputShape.length === 2 ? "" : `let batch_indices = ${batchDims.offsetToIndices("batch")};`} + ${getIndices(a, broadCastADims)} + let a_offset = ${a.indicesToOffset("a_indices")}; + ${getIndices(b, broadCastBDims)} + let b_offset = ${b.indicesToOffset("b_indices")}; + var values: array<${output.type.value}, ${outputNumber}>; + for (var k: u32 = 0u; k < uniforms.K; k = k + ${aComponents}) { + ${calcResult()} + } + for (var i = 0u; i < ${outputNumber}u; i++) { + var value = values[i]; + ${processBias} + ${applyActivation} + let cur_indices = ${output.type.indices}(batch, row + i, col); + let offset = ${output.indicesToOffset("cur_indices")}; + ${output.setByOffset(`offset / ${components}`, "value")}; + } + } + `; + }; + return { + name: "MatMulNaive", + shaderCache: { + hint: `${activationAttributes.activation};${components};${aComponents};${outputNumber};${isChannelsLast}`, + inputDependencies: hasBias ? ["rank", "rank", "rank"] : ["rank", "rank"] + }, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: inputs[0].dataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms + }), + getShaderSource + }; + }; + validateInputs8 = (inputs) => { + if (!inputs || inputs.length !== 2) { + throw new Error("MatMul requires 2 inputs."); + } + if (inputs[0].dims[inputs[0].dims.length - 1] !== inputs[1].dims[inputs[1].dims.length - 2]) { + throw new Error("shared dimension does not match."); + } + }; + matMul = (context) => { + validateInputs8(context.inputs); + const outputShape = BroadcastUtil.calcShape(context.inputs[0].dims, context.inputs[1].dims, true); + if (!outputShape) { + throw new Error("Can't use matmul on the given tensors"); + } + const N = outputShape[outputShape.length - 1]; + const K = context.inputs[0].dims[context.inputs[0].dims.length - 1]; + if (N < 8 && K < 8) { + context.compute(createNaiveMatmulProgramInfo(context.inputs, { activation: "" }, outputShape)); + } else { + context.compute(createMatmulProgramInfo(context.inputs, { activation: "" }, outputShape)); + } + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/conv.ts +var calculateOutputShape, weightTransposeAttribute, validateInputs9, getAdjustedConvAttributes, parseConvAttributes, conv2d, conv1d, conv; +var init_conv = __esm({ + "web/lib/wasm/jsep/webgpu/ops/conv.ts"() { + "use strict"; + init_util(); + init_conv2d_mm_webgpu(); + init_matmul_packed_webgpu(); + init_conv_grouped(); + init_fuse_utils(); + init_matmul(); + init_transpose(); + calculateOutputShape = (inputShape, kernelShape, dilations, adjustPads, strides, isChannelLast) => { + const batchSize = inputShape[0]; + const inputSpatialShape = inputShape.slice(isChannelLast ? 1 : 2, isChannelLast ? 3 : 4); + const spatialRank = inputSpatialShape.length; + const outChannels = kernelShape[0]; + const kernelSpatialShape = kernelShape.slice(2); + const dilatedKernelShape = kernelSpatialShape.map((v, i) => v + (v - 1) * (dilations[i] - 1)); + const inputSpatialShapeWithPad = inputSpatialShape.map((v, i) => v + adjustPads[i] + adjustPads[i + spatialRank]); + const outputShape = inputSpatialShapeWithPad.map((v, i) => Math.floor((v - dilatedKernelShape[i] + strides[i]) / strides[i])); + outputShape.splice(0, 0, batchSize); + outputShape.splice(isChannelLast ? 3 : 1, 0, outChannels); + return outputShape; + }; + weightTransposeAttribute = [2, 3, 1, 0]; + validateInputs9 = (inputs, attributes) => { + if (!inputs || inputs.length !== 2 && inputs.length !== 3) { + throw new Error("Conv requires 2 or 3 inputs"); + } + if (inputs[0].dims.length !== 4 && inputs[0].dims.length !== 3) { + throw new Error("currently only support conv 1D and 2D"); + } + if (inputs[0].dims.length !== inputs[1].dims.length) { + throw new Error("filter does not have same dimension as input"); + } + const dataChannel = inputs[0].dims[attributes.format === "NHWC" ? inputs[0].dims.length - 1 : 1]; + const filterInChannel = inputs[1].dims[1] * attributes.group; + if (dataChannel !== filterInChannel) { + throw new Error("FILTER_IN_CHANNEL should be equal to DATA_CHANNEL"); + } + if (inputs.length === 3 && (inputs[2].dims.length !== 1 || inputs[1].dims[0] !== inputs[2].dims[0])) { + throw new Error("invalid bias"); + } + const spatialRank = inputs[0].dims.length - 2; + if (attributes.dilations.length !== spatialRank) { + throw new Error(`dilations should be ${spatialRank}D`); + } + if (attributes.strides.length !== spatialRank) { + throw new Error(`strides should be ${spatialRank}D`); + } + if (attributes.pads.length !== spatialRank * 2) { + throw new Error(`pads should be ${spatialRank * 2}D`); + } + if (attributes.kernelShape.length !== 0 && attributes.kernelShape.length !== inputs[1].dims.length - 2) { + throw new Error("invalid kernel shape"); + } + }; + getAdjustedConvAttributes = (attributes, inputs) => { + const kernelShape = attributes.kernelShape.slice(); + for (let i = 2; i < inputs[1].dims.length; ++i) { + if (kernelShape[i - 2] === 0) { + kernelShape[i - 2] = inputs[1].dims[i]; + } + } + const pads = attributes.pads.slice(); + PoolConvUtil.adjustPadsBasedOnAutoPad( + inputs[0].dims, + attributes.strides, + attributes.dilations, + kernelShape, + pads, + attributes.format === "NHWC", + attributes.autoPad + ); + const newAttributes = Object.assign({}, attributes); + Object.assign(newAttributes, { kernelShape, pads }); + return newAttributes; + }; + parseConvAttributes = (attributes) => { + const activationAttributes = parseInternalActivationAttributes(attributes); + const format = attributes.format; + const autoPad = ["NOTSET", "VALID", "SAME_UPPER", "SAME_LOWER"][attributes.auto_pad]; + const dilations = attributes.dilations; + const group = attributes.group; + const kernelShape = attributes.kernel_shape; + const pads = attributes.pads; + const strides = attributes.strides; + const wIsConst = attributes.w_is_const(); + return { + autoPad, + format, + dilations, + group, + kernelShape, + pads, + strides, + wIsConst, + ...activationAttributes, + cacheKey: `${attributes.format};${activationAttributes.activation};` + }; + }; + conv2d = (context, inputs, attributes) => { + const adjustedAttributes = getAdjustedConvAttributes(attributes, inputs); + const isChannelsLast = attributes.format === "NHWC"; + if (attributes.group !== 1) { + const enableGroupedConvVectorize = !context.adapterInfo.isArchitecture("ampere"); + if (enableGroupedConvVectorize && isChannelsLast && inputs[1].dims[0] === attributes.group && inputs[1].dims[1] === 1 && attributes.dilations[0] === 1 && attributes.dilations[1] === 1) { + const outputShape2 = calculateOutputShape( + inputs[0].dims, + inputs[1].dims, + attributes.dilations, + adjustedAttributes.pads, + attributes.strides, + isChannelsLast + ); + const transposedWeight2 = context.kernelCustomData.wT ?? context.compute( + createTransposeProgramInfo(inputs[1], weightTransposeAttribute), + { inputs: [1], outputs: [attributes.wIsConst ? -2 : -1] } + )[0]; + if (attributes.wIsConst && !context.kernelCustomData.wT) { + context.kernelCustomData.wT = transposedWeight2; + } + const convInputs2 = [inputs[0], transposedWeight2]; + if (inputs.length === 3) { + convInputs2.push(inputs[2]); + } + context.compute( + createGroupedConvVectorizeProgramInfo(convInputs2, adjustedAttributes, outputShape2), + { inputs: convInputs2 } + ); + } else { + context.compute(createGroupedConvProgramInfo(inputs, adjustedAttributes)); + } + return; + } + const hasBias = inputs.length === 3; + const inputHeight = inputs[0].dims[isChannelsLast ? 1 : 2]; + const inputWidth = inputs[0].dims[isChannelsLast ? 2 : 3]; + const inputChannels = inputs[0].dims[isChannelsLast ? 3 : 1]; + const weightHeight = inputs[1].dims[2]; + const weightWidth = inputs[1].dims[3]; + const outputShape = calculateOutputShape( + inputs[0].dims, + inputs[1].dims, + attributes.dilations, + adjustedAttributes.pads, + attributes.strides, + isChannelsLast + ); + const outHeight = outputShape[isChannelsLast ? 1 : 2]; + const outWidth = outputShape[isChannelsLast ? 2 : 3]; + const outChannels = outputShape[isChannelsLast ? 3 : 1]; + const sameSize = isChannelsLast && weightHeight === inputHeight && weightWidth === inputWidth && attributes.pads[0] === 0 && attributes.pads[1] === 0; + if (sameSize || weightHeight === 1 && weightWidth === 1 && attributes.dilations[0] === 1 && attributes.dilations[1] === 1 && attributes.strides[0] === 1 && attributes.strides[1] === 1 && attributes.pads[0] === 0 && attributes.pads[1] === 0) { + const batch = outputShape[0]; + let xReshaped, wReshaped, matmulOutputShape; + const matmulInputs = []; + if (isChannelsLast) { + const transposedWeight2 = context.kernelCustomData.wT ?? context.compute( + createTransposeProgramInfo(inputs[1], weightTransposeAttribute), + { inputs: [1], outputs: [attributes.wIsConst ? -2 : -1] } + )[0]; + if (attributes.wIsConst && !context.kernelCustomData.wT) { + context.kernelCustomData.wT = transposedWeight2; + } + if (sameSize) { + const sharedDim = inputHeight * inputWidth * inputChannels; + xReshaped = inputs[0].reshape([1, batch, sharedDim]); + wReshaped = transposedWeight2.reshape([1, sharedDim, outChannels]); + matmulOutputShape = [1, batch, outChannels]; + } else { + xReshaped = inputs[0].reshape([batch, inputHeight * inputWidth, inputChannels]); + wReshaped = transposedWeight2.reshape([1, inputChannels, outChannels]); + matmulOutputShape = [batch, outHeight * outWidth, outChannels]; + } + matmulInputs.push(xReshaped); + matmulInputs.push(wReshaped); + } else { + xReshaped = inputs[0].reshape([batch, inputChannels, inputHeight * inputWidth]); + wReshaped = inputs[1].reshape([1, outChannels, inputChannels]); + matmulOutputShape = [batch, outChannels, outHeight * outWidth]; + matmulInputs.push(wReshaped); + matmulInputs.push(xReshaped); + } + if (hasBias) { + matmulInputs.push(inputs[2]); + } + const N = matmulOutputShape[2]; + const K = matmulInputs[0].dims[matmulInputs[0].dims.length - 1]; + if (N < 8 && K < 8) { + context.compute( + createNaiveMatmulProgramInfo( + matmulInputs, + adjustedAttributes, + outputShape, + matmulOutputShape, + isChannelsLast + ), + { inputs: matmulInputs } + ); + } else { + context.compute( + createMatmulProgramInfo(matmulInputs, adjustedAttributes, outputShape, matmulOutputShape, isChannelsLast), + { inputs: matmulInputs } + ); + } + return; + } + const sequentialAccessByThreads = ( + /* backend.adapterInfo.isIntel() */ + true + ); + const transposedWeight = context.kernelCustomData.wT ?? context.compute( + createTransposeProgramInfo(inputs[1], weightTransposeAttribute), + { inputs: [1], outputs: [attributes.wIsConst ? -2 : -1] } + )[0]; + if (attributes.wIsConst && !context.kernelCustomData.wT) { + context.kernelCustomData.wT = transposedWeight; + } + const convInputs = [inputs[0], transposedWeight]; + if (hasBias) { + convInputs.push(inputs[2]); + } + const dimAOuter = isChannelsLast ? outHeight * outWidth : outChannels; + const dimBOuter = isChannelsLast ? outChannels : outHeight * outWidth; + const dimInner = weightHeight * weightWidth * inputChannels; + context.compute( + createConv2DMatMulProgramInfo( + convInputs, + adjustedAttributes, + outputShape, + dimAOuter, + dimBOuter, + dimInner, + hasBias, + sequentialAccessByThreads + ), + { inputs: convInputs } + ); + }; + conv1d = (context, attributes) => { + const isChannelLast = attributes.format === "NHWC"; + const inputs = [ + context.inputs[0].reshape( + isChannelLast ? ( + // [N, W, C] -> [N, H=1, W, C] + [context.inputs[0].dims[0], 1, context.inputs[0].dims[1], context.inputs[0].dims[2]] + ) : ( + // [N, C, W] -> [N, C, H=1, W] + [context.inputs[0].dims[0], context.inputs[0].dims[1], 1, context.inputs[0].dims[2]] + ) + ), + //[FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kW] -> [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kH=1, kW] + context.inputs[1].reshape([context.inputs[1].dims[0], context.inputs[1].dims[1], 1, context.inputs[1].dims[2]]) + ]; + if (context.inputs.length === 3) { + inputs.push(context.inputs[2]); + } + const pads = [0, attributes.pads[0], 0, attributes.pads[1]]; + const strides = [1].concat(attributes.strides); + const dilations = [1].concat(attributes.dilations); + const kernelShape = [1].concat(attributes.kernelShape); + const adjustedAttributes = getAdjustedConvAttributes({ ...attributes, pads, strides, dilations, kernelShape }, inputs); + context.compute(createGroupedConvProgramInfo( + inputs, + adjustedAttributes, + (outputShape) => isChannelLast ? [outputShape[0], outputShape[2], outputShape[3]] : [] + )); + }; + conv = (context, attributes) => { + validateInputs9(context.inputs, attributes); + if (context.inputs[0].dims.length === 3) { + conv1d(context, attributes); + } else { + conv2d(context, context.inputs, attributes); + } + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_mm_webgpu.ts +var conv2dTransposeCommonSnippet, createConv2DTransposeMatMulProgramInfo; +var init_conv_backprop_mm_webgpu = __esm({ + "web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_mm_webgpu.ts"() { + "use strict"; + init_wasm_common(); + init_log(); + init_common(); + init_fuse_utils(); + init_activation_util(); + init_conv_util(); + init_matmul_packed_webgpu(); + conv2dTransposeCommonSnippet = (isChannelsLast, addBias = false, attributes, type, innerElementSize = 4) => { + const getWSnippet = (innerElementSize2) => { + switch (innerElementSize2) { + case 1: + return "return w[getIndexFromCoords4D(coord, vec4(uniforms.w_shape))];"; + case 4: + return ` + let coord1 = vec4(coordX, coordY, col + 1, rowInner); + let coord2 = vec4(coordX, coordY, col + 2, rowInner); + let coord3 = vec4(coordX, coordY, col + 3, rowInner); + let v0 = w[getIndexFromCoords4D(coord, vec4(uniforms.w_shape))]; + let v1 = w[getIndexFromCoords4D(coord1, vec4(uniforms.w_shape))]; + let v2 = w[getIndexFromCoords4D(coord2, vec4(uniforms.w_shape))]; + let v3 = w[getIndexFromCoords4D(coord3, vec4(uniforms.w_shape))]; + return ${type}(v0, v1, v2, v3); + `; + default: + throw new Error(`innerElementSize ${innerElementSize2} is not supported.`); + } + }; + const coordASnippet = isChannelsLast ? ` + let coord = vec4(batch, iXR, iXC, xCh); + ` : ` + let coord = vec4(batch, xCh, iXR, iXC); + `; + const coordResSnippet = isChannelsLast ? ` + let coords = vec4( + batch, + row / outWidth, + row % outWidth, + col); + ` : ` + let coords = vec4( + batch, + row, + col / outWidth, + col % outWidth); + `; + const xHeight = isChannelsLast ? "i32(uniforms.x_shape[1])" : "i32(uniforms.x_shape[2])"; + const xWidth = isChannelsLast ? "i32(uniforms.x_shape[2])" : "i32(uniforms.x_shape[3])"; + const row = isChannelsLast ? "row" : "col"; + const col = isChannelsLast ? "col" : "row"; + const readASnippet = ` + let inChannels = ${isChannelsLast ? "i32(uniforms.x_shape[3])" : "i32(uniforms.x_shape[1])"}; + let outWidth = ${isChannelsLast ? "i32(uniforms.result_shape[2])" : "i32(uniforms.result_shape[3])"}; + let outRow = ${row} / outWidth; + let outCol = ${row} % outWidth; + + let WRow = ${col} / (uniforms.filter_dims[1] * inChannels); + let WCol = ${col} / inChannels % uniforms.filter_dims[1]; + let xR = f32(outRow - uniforms.pads[0] + uniforms.dilations[0] * WRow) / f32(uniforms.strides[0]); + let xC = f32(outCol - uniforms.pads[1] + uniforms.dilations[1] * WCol) / f32(uniforms.strides[1]); + if (xR < 0.0 || xR >= f32(${xHeight}) || fract(xR) > 0.0) { + return ${type}(0.0); + } + if (xC < 0.0 || xC >= f32(${xWidth}) || fract(xC) > 0.0) { + return ${type}(0.0); + } + let iXR = i32(xR); + let iXC = i32(xC); + let xCh = ${col} % inChannels; + ${coordASnippet} + return x[getIndexFromCoords4D(coord, vec4(uniforms.x_shape))/${innerElementSize}];`; + const sampleA = isChannelsLast ? ` + let col = colIn * ${innerElementSize}; + if (row < uniforms.dim_a_outer && col < uniforms.dim_inner) { + ${readASnippet} + } + return ${type}(0.0);` : ` + let col = colIn * ${innerElementSize}; + if (row < uniforms.dim_inner && col < uniforms.dim_b_outer) { + ${readASnippet} + } + return ${type}(0.0);`; + const sampleW = ` + let col = colIn * ${innerElementSize}; + let inChannels = ${isChannelsLast ? "i32(uniforms.x_shape[3])" : "i32(uniforms.x_shape[1])"}; + let coordX = uniforms.filter_dims[0] - 1 - row / (uniforms.filter_dims[1] * inChannels); + let coordY = uniforms.filter_dims[1] - 1 - (row / inChannels) % uniforms.filter_dims[1]; + if (${isChannelsLast ? "row < uniforms.dim_inner && col < uniforms.dim_b_outer" : "row < uniforms.dim_inner && col < uniforms.dim_a_outer"} && coordX >= 0 && coordY >= 0) { + let rowInner = row % inChannels; + let coord = vec4(coordX, coordY, col, rowInner); + ${getWSnippet(innerElementSize)} + } + return ${type}(0.0); + `; + const applyActivation = getActivationSnippet(attributes, type); + const userCode = ` + fn mm_readA(batch: i32, row : i32, colIn : i32) -> ${type} { + ${isChannelsLast ? sampleA : sampleW} + } + + fn mm_readB(batch: i32, row : i32, colIn : i32) -> ${type} { + ${isChannelsLast ? sampleW : sampleA} + } + + fn mm_write(batch: i32, row : i32, colIn : i32, valueInput : ${type}) { + let col = colIn * ${innerElementSize}; + if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer) { + var value = valueInput; + let outWidth = ${isChannelsLast ? "i32(uniforms.result_shape[2])" : "i32(uniforms.result_shape[3])"}; + ${coordResSnippet} + ${biasSnippet(addBias)} + ${applyActivation} + result[getIndexFromCoords4D(coords, vec4(uniforms.result_shape))/${innerElementSize}] = value; + } + }`; + return userCode; + }; + createConv2DTransposeMatMulProgramInfo = (inputs, attributes, outputShape, dimAOuter, dimBOuter, dimInner, hasBias, sequentialAccessByThreads) => { + const isChannelsLast = attributes.format === "NHWC"; + const inChannels = isChannelsLast ? inputs[0].dims[3] : inputs[0].dims[1]; + const batchSize = outputShape[0]; + const outWidth = isChannelsLast ? outputShape[2] : outputShape[3]; + const outHeight = isChannelsLast ? outputShape[1] : outputShape[2]; + const outChannels = isChannelsLast ? outputShape[3] : outputShape[1]; + const isVec4 = isChannelsLast && (inChannels % 4 === 0 && inChannels % 3) && outChannels % 4 === 0; + const dispatchX = isChannelsLast ? outChannels : outWidth * outHeight; + const dispatchY = isChannelsLast ? outWidth * outHeight : outChannels; + const workGroupSize = [8, 8, 1]; + const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1]; + const dispatch = [ + Math.ceil(dispatchX / workGroupSize[0] / elementsPerThread[0]), + Math.ceil(dispatchY / workGroupSize[1] / elementsPerThread[1]), + Math.ceil(batchSize / workGroupSize[2] / elementsPerThread[2]) + ]; + LOG_DEBUG("verbose", () => `[conv_backprop_mm_webgpu] dispatch = ${dispatch}`); + const innerElementSize = isVec4 ? 4 : 1; + const tileInner = Math.max(workGroupSize[0] * innerElementSize, workGroupSize[1]); + const components = isVec4 ? 4 : 1; + const filterDims = [attributes.kernelShape[isChannelsLast ? 1 : 2], attributes.kernelShape[isChannelsLast ? 2 : 3]]; + const effectiveFilterDims = [ + filterDims[0] + (attributes.dilations[0] <= 1 ? 0 : (filterDims[0] - 1) * (attributes.dilations[0] - 1)), + filterDims[1] + (attributes.dilations[1] <= 1 ? 0 : (filterDims[1] - 1) * (attributes.dilations[1] - 1)) + ]; + const pads = [ + effectiveFilterDims[0] - 1 - Math.floor((attributes.pads[0] + attributes.pads[2]) / 2), + effectiveFilterDims[1] - 1 - Math.floor((attributes.pads[1] + attributes.pads[3]) / 2) + ]; + const programUniforms = [ + { type: 6 /* int32 */, data: dimAOuter }, + { type: 6 /* int32 */, data: dimBOuter }, + { type: 6 /* int32 */, data: dimInner }, + { type: 6 /* int32 */, data: attributes.strides }, + { type: 6 /* int32 */, data: attributes.dilations }, + { type: 6 /* int32 */, data: filterDims }, + { type: 6 /* int32 */, data: pads } + ]; + appendActivationUniformsData(attributes, programUniforms); + programUniforms.push(...createTensorShapeVariables(inputs[0].dims, inputs[1].dims)); + const inputDependencies = ["rank", "rank"]; + if (hasBias) { + programUniforms.push(...createTensorShapeVariables(inputs[2].dims)); + inputDependencies.push("rank"); + } + programUniforms.push(...createTensorShapeVariables(outputShape)); + const getShaderSource = (shaderHelper) => { + const x = inputVariable("x", inputs[0].dataType, inputs[0].dims.length, components); + const w = inputVariable("w", inputs[1].dataType, inputs[1].dims.length, 1); + const output = outputVariable("result", inputs[0].dataType, outputShape.length, components); + const inputVariables = [x, w]; + let declareFunctions = ""; + if (hasBias) { + const bias = inputVariable("bias", inputs[2].dataType, inputs[2].dims.length, components); + inputVariables.push(bias); + declareFunctions += ` + fn getBiasByOutputCoords(coords : vec4) -> ${bias.type.value} { + return bias[coords.${isChannelsLast ? "w" : "y"}${isVec4 ? "/ 4" : ""}]; + }`; + } + const uniforms = [ + { name: "dim_a_outer", type: "i32" }, + { name: "dim_b_outer", type: "i32" }, + { name: "dim_inner", type: "i32" }, + { name: "strides", type: "i32", length: 2 }, + { name: "dilations", type: "i32", length: 2 }, + { name: "filter_dims", type: "i32", length: filterDims.length }, + { name: "pads", type: "i32", length: pads.length } + ]; + appendActivationUniforms(attributes, uniforms); + const elemType = tensorTypeToWsglStorageType(inputs[0].dataType, 1); + if (elemType !== "f16" && elemType !== "f32") { + throw new Error(`elemType ${elemType} is not supported.`); + } + return ` + ${utilFunctions("uniforms.result_strides")} + ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}; + ${declareFunctions} + ${conv2dTransposeCommonSnippet(isChannelsLast, hasBias, attributes, x.type.value, innerElementSize)} + ${isVec4 ? makeMatMulPackedVec4Source( + elementsPerThread, + workGroupSize, + elemType, + void 0, + !isChannelsLast, + tileInner + ) : makeMatMulPackedSource( + elementsPerThread, + workGroupSize, + elemType, + void 0, + !isChannelsLast, + tileInner, + false, + void 0, + sequentialAccessByThreads + )}`; + }; + return { + name: "Conv2DTransposeMatMul", + shaderCache: { hint: `${attributes.cacheKey};${elementsPerThread};${workGroupSize};${isVec4}`, inputDependencies }, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: inputs[0].dataType }], + dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] }, + programUniforms + }), + getShaderSource + }; + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_webgpu.ts +var createConvTranspose2DOpProgramShaderSource, createConvTranspose2DProgramInfo; +var init_conv_backprop_webgpu = __esm({ + "web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_webgpu.ts"() { + "use strict"; + init_wasm_common(); + init_log(); + init_util(); + init_common(); + createConvTranspose2DOpProgramShaderSource = (shaderHelper, inputs, outputShape, hasBias, is1DimensionDispatch, isVec4 = false, dataType, uniforms, isChannelsLast = false) => { + const rowDim = isChannelsLast ? 1 : 2; + const colDim = isChannelsLast ? 2 : 3; + const channelDim = isChannelsLast ? 3 : 1; + const workPerThread = isVec4 ? 2 : 1; + let declareFunctions = ` + fn setOutputAtIndex(flatIndex : u32, value : ${isVec4 ? `vec4<${dataType}>` : dataType}) { + result[flatIndex] = ${isVec4 ? `vec4<${dataType}>` : dataType}(value); + }`; + if (hasBias) { + declareFunctions += ` + fn getBiasByOutputCoords(coords : vec4) -> ${isVec4 ? `vec4<${dataType}>` : dataType} { + return bias[coords.${isChannelsLast ? "w" : "y"}${isVec4 ? "/ 4" : ""}]; + }`; + } + const components = isVec4 ? 4 : 1; + const w = inputVariable("W", inputs[1].dataType, inputs[1].dims.length, components); + const dy = inputVariable("Dy", inputs[0].dataType, inputs[0].dims.length, components); + const inputVariables = [dy, w]; + if (hasBias) { + inputVariables.push(inputVariable("bias", inputs[2].dataType, [outputShape[channelDim]].length, components)); + } + const output = outputVariable("result", inputs[0].dataType, outputShape.length, components); + const codeSnippet4 = `{ + let batch: u32 = ${is1DimensionDispatch ? "global_id.z" : "workgroup_id.z"} / uniforms.result_shape[1]; + let r = ${is1DimensionDispatch ? "global_id.z" : "workgroup_id.z"} % uniforms.result_shape[1]; + let c = ${is1DimensionDispatch ? "global_id.y" : "workgroup_id.y"} * ${workPerThread}; + let d1: u32 = ${is1DimensionDispatch ? "global_id.x" : "workgroup_id.x"} * 4; + + let dyCorner = vec2(i32(r), i32(c)) - vec2(uniforms.pads); + + // Convolve dy(?, ?, d2) with w(:, :, d1, d2) to compute dx(xR, xC, d1). + // ? = to be determined. : = across all values in that axis. + var dotProd: array, ${workPerThread}>; + for (var i = 0; i < ${workPerThread}; i++) { + dotProd[i] = vec4<${dataType}>(0.0); + } + for (var wR: u32 = 0; wR < uniforms.filter_dims[0]; wR = wR + 1) { + var dyR = (${dataType}(dyCorner.x) + ${dataType}(wR)) / ${dataType}(uniforms.strides.x); + let wRPerm = uniforms.filter_dims[0] - 1 - wR; + if (dyR < 0.0 || dyR >= ${dataType}(uniforms.Dy_shape[1]) || + fract(dyR) > 0.0 || wRPerm < 0) { + continue; + } + let idyR: u32 = u32(dyR); + + for (var wC: u32 = 0; wC < uniforms.filter_dims[1]; wC = wC + 1) { + let dyC = (${dataType}(dyCorner.y) + ${dataType}(wC)) / ${dataType}(uniforms.strides.y); + let dyC2 = (${dataType}(dyCorner.y) + 1.0 + ${dataType}(wC)) / ${dataType}(uniforms.strides.y); + let wCPerm = uniforms.filter_dims[1] - 1 - wC; + if (wCPerm < 0) { + continue; + } + var bDyCVal = true; + var bDyCVal2 = true; + if (dyC < 0.0 || dyC >= ${dataType}(uniforms.Dy_shape[2]) || + fract(dyC) > 0.0) { + bDyCVal = false; + } + if (dyC2 < 0.0 || dyC2 >= ${dataType}(uniforms.Dy_shape[2]) || + fract(dyC2) > 0.0) { + bDyCVal2 = false; + } + + let idyC: u32 = u32(dyC); + let idyC2: u32 = u32(dyC2); + if (bDyCVal && bDyCVal2) { + let d2Length = uniforms.Dy_shape[3]; + for (var d2 :u32 = 0; d2 < d2Length; d2 = d2 + 4) { + let wValue0 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1", "d2")}; + let wValue1 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 1", "d2")}; + let wValue2 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 2", "d2")}; + let wValue3 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 3", "d2")}; + + var xValue = ${dy.get("batch", "idyR", "idyC", "d2")}; + let tmpval = vec4<${dataType}>(dot(xValue, wValue0), + dot(xValue, wValue1), + dot(xValue, wValue2), + dot(xValue, wValue3)); + dotProd[0] = dotProd[0] + tmpval; + + xValue = ${dy.get("batch", "idyR", "idyC2", "d2")}; + + dotProd[1] = dotProd[1] + vec4<${dataType}>(dot(xValue, wValue0), + dot(xValue, wValue1), + dot(xValue, wValue2), + dot(xValue, wValue3)); + } + } else if (bDyCVal) { + let d2Length = uniforms.Dy_shape[${channelDim}]; + for (var d2: u32 = 0; d2 < d2Length; d2 = d2 + 4) { + let wValue0 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1", "d2")}; + let wValue1 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 1", "d2")}; + let wValue2 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 2", "d2")}; + let wValue3 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 3", "d2")}; + + var xValue = ${dy.get("batch", "idyR", "idyC", "d2")}; + let tmpval = vec4<${dataType}>(dot(xValue, wValue0), + dot(xValue, wValue1), + dot(xValue, wValue2), + dot(xValue, wValue3)); + dotProd[0] = dotProd[0] + tmpval; + } + } else if (bDyCVal2) { + let d2Length = uniforms.Dy_shape[3]; + for (var d2: u32 = 0; d2 < d2Length; d2 = d2 + 4) { + let wValue0 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1", "d2")}; + let wValue1 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 1", "d2")}; + let wValue2 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 2", "d2")}; + let wValue3 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 3", "d2")}; + + var xValue = ${dy.get("batch", "idyR", "idyC2", "d2")}; + let tmpval = vec4<${dataType}>(dot(xValue, wValue0), + dot(xValue, wValue1), + dot(xValue, wValue2), + dot(xValue, wValue3)); + dotProd[1] = dotProd[1] + tmpval; + } + } + } + } + + for (var i: u32 = 0; i < ${workPerThread}; i = i + 1) { + let value = dotProd[i] + ${hasBias ? "bias[c+i]" : `vec4<${dataType}>(0.0)`}; + ${output.set("batch", "r", "c + i", "d1", "value")}; + } + }`; + const codeSnippet = ` + let outputIndices = ${output.offsetToIndices("global_idx")}; + let batch = ${output.indicesGet("outputIndices", 0)}; + let d1 = ${output.indicesGet("outputIndices", channelDim)}; + let r = ${output.indicesGet("outputIndices", rowDim)}; + let c = ${output.indicesGet("outputIndices", colDim)}; + let dyCorner = vec2(i32(r), i32(c)) - uniforms.pads; + let dyRCorner = dyCorner.x; + let dyCCorner = dyCorner.y; + let groupId = d1 / uniforms.output_channels_per_group; + let wOutChannel = d1 - groupId * uniforms.output_channels_per_group; + // Convolve dy(?, ?, d2) with w(:, :, d1, d2) to compute dx(xR, xC, d1). + // ? = to be determined. : = across all values in that axis. + var dotProd = ${dataType}(0.0); + for (var wR: u32 = 0; wR < uniforms.effective_filter_dims.x; wR = wR + 1) { + if (wR % uniforms.dilations.x != 0) { + continue; + } + let dyR = (${dataType}(dyRCorner) + ${dataType}(wR)) / ${dataType}(uniforms.strides[0]); + let wRPerm = uniforms.filter_dims.x - 1 - wR / uniforms.dilations.x; + if (dyR < 0.0 || dyR >= ${dataType}(uniforms.Dy_shape[${rowDim}]) || fract(dyR) > 0.0 || + wRPerm < 0) { + continue; + } + let idyR: u32 = u32(dyR); + + for (var wC: u32 = 0; wC < uniforms.effective_filter_dims.y; wC = wC + 1) { + if (wC % uniforms.dilations.y != 0) { + continue; + } + let dyC = (${dataType}(dyCCorner) + ${dataType}(wC)) / ${dataType}(uniforms.strides.y); + let wCPerm = uniforms.filter_dims.y - 1 - wC / uniforms.dilations.y; + if (dyC < 0.0 || dyC >= ${dataType}(uniforms.Dy_shape[${colDim}]) || + fract(dyC) > 0.0 || wCPerm < 0) { + continue; + } + let idyC: u32 = u32(dyC); + var inputChannel = groupId * uniforms.input_channels_per_group; + for (var d2: u32 = 0; d2 < uniforms.input_channels_per_group; d2 = d2 + 1) { + let xValue = ${isChannelsLast ? dy.get("batch", "idyR", "idyC", "inputChannel") : dy.get("batch", "inputChannel", "idyR", "idyC")}; + let wValue = ${w.get("inputChannel", "wOutChannel", "u32(wRPerm)", "u32(wCPerm)")}; + dotProd = dotProd + xValue * wValue; + inputChannel = inputChannel + 1; + } + } + } + let value = dotProd + ${hasBias ? "bias[d1]" : `${dataType}(0.0)`}; + ${output.setByOffset("global_idx", "value")}; + `; + return ` + ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)} + ${declareFunctions} + + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}; + ${isVec4 ? codeSnippet4 : codeSnippet}}`; + }; + createConvTranspose2DProgramInfo = (inputs, attributes, squeezeOutputShapeFunction) => { + const hasBias = inputs.length > 2; + const outputShape = attributes.outputShape; + const outputSize = ShapeUtil.size(outputShape); + const dispatch = [ + Math.ceil(outputSize / 64), + 1, + 1 + ]; + LOG_DEBUG("verbose", () => `[conv2d_backprop_webgpu] dispatch = ${dispatch}`); + const isChannelsLast = attributes.format === "NHWC"; + const inputDependencies = ["rank", "rank"]; + const strides = [attributes.strides[0], attributes.strides[1]]; + const filterDims = [attributes.kernelShape[isChannelsLast ? 1 : 2], attributes.kernelShape[isChannelsLast ? 2 : 3]]; + const dilations = [attributes.dilations[0], attributes.dilations[1]]; + const effectiveFilterDims = [ + filterDims[0] + (attributes.dilations[0] <= 1 ? 0 : (attributes.kernelShape[isChannelsLast ? 1 : 2] - 1) * (attributes.dilations[0] - 1)), + filterDims[1] + (attributes.dilations[1] <= 1 ? 0 : (attributes.kernelShape[isChannelsLast ? 2 : 3] - 1) * (attributes.dilations[1] - 1)) + ]; + const pads = [ + effectiveFilterDims[0] - 1 - Math.floor((attributes.pads[0] + attributes.pads[2]) / 2), + effectiveFilterDims[1] - 1 - Math.floor(attributes.pads[1] + attributes.pads[3]) / 2 + ]; + const isVec4 = false; + const group = attributes.group; + const wShape = inputs[1].dims; + const inputChannelsPerGroup = wShape[0] / group; + const outputChannelsPerGroup = wShape[1]; + const programUniforms = [ + { type: 12 /* uint32 */, data: outputSize }, + { type: 12 /* uint32 */, data: strides }, + { type: 12 /* uint32 */, data: filterDims }, + { type: 12 /* uint32 */, data: dilations }, + { type: 12 /* uint32 */, data: effectiveFilterDims }, + { type: 6 /* int32 */, data: pads }, + { type: 12 /* uint32 */, data: inputChannelsPerGroup }, + { type: 12 /* uint32 */, data: outputChannelsPerGroup }, + ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims) + ]; + if (hasBias) { + programUniforms.push(...createTensorShapeVariables(inputs[2].dims)); + inputDependencies.push("rank"); + } + programUniforms.push(...createTensorShapeVariables(outputShape)); + const is1DimensionDispatch = dispatch[1] === 1 && dispatch[2] === 1; + const getShaderSource = (shaderHelper) => { + const uniforms = [ + { name: "output_size", type: "u32" }, + { name: "strides", type: "u32", length: strides.length }, + { name: "filter_dims", type: "u32", length: filterDims.length }, + { name: "dilations", type: "u32", length: filterDims.length }, + { name: "effective_filter_dims", type: "u32", length: effectiveFilterDims.length }, + { name: "pads", type: "i32", length: pads.length }, + { name: "input_channels_per_group", type: "u32" }, + { name: "output_channels_per_group", type: "u32" } + ]; + const dataType = tensorTypeToWsglStorageType(inputs[0].dataType); + return `${createConvTranspose2DOpProgramShaderSource( + shaderHelper, + inputs, + outputShape, + hasBias, + is1DimensionDispatch, + isVec4, + dataType, + uniforms, + isChannelsLast + )}`; + }; + return { + name: "ConvTranspose2D", + shaderCache: { hint: `${attributes.cacheKey};`, inputDependencies }, + getRunData: () => ({ + dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] }, + outputs: [{ + dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape, + dataType: inputs[0].dataType + }], + programUniforms + }), + getShaderSource + }; + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/conv-transpose.ts +var computeTotalPad, distributePadding, calculateOutputShapeAndPads, getAdjustedConvTransposeAttributes, parseConvTransposeAttributes, validateInputs10, weightTransposePerm, convTranspose2d, convTranspose1d, convTranspose; +var init_conv_transpose = __esm({ + "web/lib/wasm/jsep/webgpu/ops/conv-transpose.ts"() { + "use strict"; + init_conv_backprop_mm_webgpu(); + init_conv_backprop_webgpu(); + init_fuse_utils(); + init_transpose(); + computeTotalPad = (inDim, stride, adj, kernel, dilation, outSize) => (inDim - 1) * stride + adj + (kernel - 1) * dilation + 1 - outSize; + distributePadding = (totalPad, autoPad, pads, head, tail) => { + const smallPad = Math.floor(totalPad / 2); + if (autoPad === "SAME_UPPER") { + pads[head] = smallPad; + pads[tail] = totalPad - smallPad; + } else if (autoPad === "SAME_LOWER") { + pads[head] = totalPad - smallPad; + pads[tail] = smallPad; + } + }; + calculateOutputShapeAndPads = (inputShape, kernelShape, dilations, autoPad, group, pads, strides, isChannelLast, outputPadding, outputShape) => { + const spatialRank = inputShape.length - 2; + const updateOutputShape = outputShape.length === 0; + if (outputPadding.length === 0) { + for (let i = 0; i < spatialRank; ++i) { + outputPadding.push(0); + } + } + const batchSize = inputShape[0]; + const outChannels = kernelShape[isChannelLast ? 3 : 1] * group; + for (let i = 0, j = inputShape.length - spatialRank - (isChannelLast ? 1 : 0); i < spatialRank; ++i, ++j) { + const inSize = inputShape[j]; + const outSize = updateOutputShape ? inSize * strides[i] : outputShape[i]; + const totalPad = computeTotalPad(inSize, strides[i], pads[i], kernelShape[j], dilations[i], outSize); + distributePadding(totalPad, autoPad, pads, i, i + spatialRank); + if (updateOutputShape) { + outputShape.push( + strides[i] * (inSize - 1) + outputPadding[i] + (kernelShape[j] - 1) * dilations[i] + 1 - pads[i] - pads[i + spatialRank] + ); + } + } + outputShape.splice(0, 0, batchSize); + outputShape.splice(isChannelLast ? 3 : 1, 0, outChannels); + }; + getAdjustedConvTransposeAttributes = (attributes, inputs) => { + const kernelShape = attributes.kernelShape.slice(); + if (attributes.kernelShape.length === 0 || attributes.kernelShape.reduce((a, b) => a * b, 1) === 0) { + kernelShape.length = 0; + for (let i = 2; i < inputs[1].dims.length; ++i) { + kernelShape.push(inputs[1].dims[i]); + } + } + const isChannelsLast = attributes.format === "NHWC"; + kernelShape.splice(0, 0, inputs[1].dims[0]); + kernelShape.splice(isChannelsLast ? 3 : 1, 0, inputs[1].dims[1]); + const pads = attributes.pads.slice(); + const outputShape = attributes.outputShape.slice(); + const outputPadding = attributes.outputPadding.slice(); + const inputShape = inputs[0].dims; + let dilations = attributes.dilations.slice(); + if (dilations.reduce((a, b) => a + b, 0) === 0) { + const spatialRank = inputs[0].dims.length - 2; + dilations = new Array(spatialRank).fill(1); + } + let strides = attributes.strides.slice(); + if (strides.reduce((a, b) => a + b, 0) === 0) { + const spatialRank = inputs[0].dims.length - 2; + strides = new Array(spatialRank).fill(1); + } + calculateOutputShapeAndPads( + inputShape, + kernelShape, + dilations, + attributes.autoPad, + attributes.group, + pads, + strides, + isChannelsLast, + outputPadding, + outputShape + ); + const newAttributes = Object.assign({}, attributes); + Object.assign(newAttributes, { kernelShape, pads, outputPadding, outputShape, dilations, strides }); + return newAttributes; + }; + parseConvTransposeAttributes = (attributes) => { + const activationAttributes = parseInternalActivationAttributes(attributes); + const format = attributes.format; + const autoPad = [ + "NOTSET", + "VALID", + "SAME_UPPER", + "SAME_LOWER" + ][typeof attributes.autoPad == "undefined" ? 0 : attributes.autoPad]; + const dilations = attributes.dilations; + const group = attributes.group; + const kernelShape = attributes.kernelShape; + const pads = attributes.pads; + const strides = attributes.strides; + const wIsConst = attributes.wIsConst(); + const outputPadding = attributes.outputPadding; + const outputShape = attributes.outputShape; + return { + autoPad, + format, + dilations, + group, + kernelShape, + outputPadding, + outputShape, + pads, + strides, + wIsConst, + ...activationAttributes, + cacheKey: `${attributes.format};${activationAttributes.activation};` + }; + }; + validateInputs10 = (inputs, attributes) => { + if (!inputs || inputs.length !== 2 && inputs.length !== 3) { + throw new Error("Conv requires 2 or 3 inputs"); + } + if (inputs[0].dims.length !== 4 && inputs[0].dims.length !== 3) { + throw new Error("currently only support 2-dimensional conv"); + } + if (inputs[0].dims.length !== inputs[1].dims.length) { + throw new Error("filter does not have same dimension as input"); + } + const dataChannel = inputs[0].dims[attributes.format === "NHWC" ? inputs[0].dims.length - 1 : 1]; + const filterInChannel = inputs[1].dims[0]; + if (dataChannel !== filterInChannel) { + throw new Error("FILTER_IN_CHANNEL should be equal to DATA_CHANNEL"); + } + const featureMaps = inputs[1].dims[1] * attributes.group; + if (inputs.length === 3 && (inputs[2].dims.length !== 1 || inputs[2].dims[0] !== featureMaps)) { + throw new Error("invalid bias"); + } + const spatialRank = inputs[0].dims.length - 2; + const dilationsSet = attributes.dilations.reduce((a, b) => a + b, 0) > 0; + if (dilationsSet && attributes.dilations.length !== spatialRank) { + throw new Error(`dilations should be ${spatialRank}D`); + } + const stridesSet = attributes.strides.reduce((a, b) => a + b, 0) > 0; + if (stridesSet && attributes.strides.length !== spatialRank) { + throw new Error(`strides should be ${spatialRank}D`); + } + const padsSet = attributes.pads.reduce((a, b) => a + b, 0) > 0; + if (padsSet && attributes.pads.length !== spatialRank * 2) { + throw new Error(`pads should be ${spatialRank * 2}D`); + } + if (attributes.outputPadding.length !== spatialRank && attributes.outputPadding.length !== 0) { + throw new Error(`output_padding should be ${spatialRank}D`); + } + const kernelShapeSet = attributes.kernelShape.reduce((a, b) => a + b, 0) > 0; + if (kernelShapeSet && attributes.kernelShape.length !== 0 && attributes.kernelShape.length !== inputs[1].dims.length - 2) { + throw new Error("invalid kernel shape"); + } + if (attributes.outputShape.length !== 0 && attributes.outputShape.length !== inputs[0].dims.length - 2) { + throw new Error("invalid output shape"); + } + }; + weightTransposePerm = [2, 3, 1, 0]; + convTranspose2d = (context, inputs, attributes) => { + const adjustedAttributes = getAdjustedConvTransposeAttributes(attributes, inputs); + const isChannelsLast = attributes.format === "NHWC"; + const outputShape = adjustedAttributes.outputShape; + const outChannels = outputShape[isChannelsLast ? 3 : 1]; + const inputChannels = inputs[0].dims[isChannelsLast ? 3 : 1]; + if (adjustedAttributes.group !== 1 || outChannels === 1 && inputChannels === 1) { + context.compute(createConvTranspose2DProgramInfo(inputs, adjustedAttributes)); + return; + } + const outHeight = outputShape[isChannelsLast ? 1 : 2]; + const outWidth = outputShape[isChannelsLast ? 2 : 3]; + const weightHeight = inputs[1].dims[2]; + const weightWidth = inputs[1].dims[3]; + const dimAOuter = isChannelsLast ? outHeight * outWidth : outChannels; + const dimBOuter = isChannelsLast ? outChannels : outHeight * outWidth; + const dimInner = weightHeight * weightWidth * inputChannels; + const sequentialAccessByThreads = ( + /* backend.adapterInfo.isIntel() */ + true + ); + const transposedWeight = context.kernelCustomData.wT ?? context.compute( + createTransposeProgramInfo(inputs[1], weightTransposePerm), + { inputs: [1], outputs: [attributes.wIsConst ? -2 : -1] } + )[0]; + if (attributes.wIsConst && !context.kernelCustomData.wT) { + context.kernelCustomData.wT = transposedWeight; + } + const convTransposeInputs = [inputs[0], transposedWeight]; + const hasBias = inputs.length === 3; + if (hasBias) { + if (!isChannelsLast && inputs[2].dims.length === 1) { + convTransposeInputs.push(inputs[2].reshape([inputs[2].dims[0], 1, 1])); + } else { + convTransposeInputs.push(inputs[2]); + } + } + context.compute( + createConv2DTransposeMatMulProgramInfo( + convTransposeInputs, + adjustedAttributes, + outputShape, + dimAOuter, + dimBOuter, + dimInner, + hasBias, + sequentialAccessByThreads + ), + { inputs: convTransposeInputs } + ); + }; + convTranspose1d = (context, attributes) => { + const isChannelLast = attributes.format === "NHWC"; + const inputs = [ + context.inputs[0].reshape( + isChannelLast ? ( + // [N, W, C] -> [N, H=1, W, C] + [context.inputs[0].dims[0], 1, context.inputs[0].dims[1], context.inputs[0].dims[2]] + ) : ( + // [N, C, W] -> [N, C, H=1, W] + [context.inputs[0].dims[0], context.inputs[0].dims[1], 1, context.inputs[0].dims[2]] + ) + ), + //[FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kW] -> [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kH=1, kW] + context.inputs[1].reshape([context.inputs[1].dims[0], context.inputs[1].dims[1], 1, context.inputs[1].dims[2]]) + ]; + if (context.inputs.length === 3) { + inputs.push(context.inputs[2]); + } + let kernelShape = attributes.kernelShape; + if (kernelShape.length === 0 || kernelShape[0] === 0) { + kernelShape = [context.inputs[1].dims[2]]; + } + let dilations = attributes.dilations; + if (dilations.length === 0 || dilations[0] === 0) { + dilations = [1]; + } + let strides = attributes.strides; + if (strides.length === 0 || strides[0] === 0) { + strides = [1]; + } + let pads = attributes.pads; + if (pads.length === 0) { + pads = [0, 0]; + } + pads = [0, pads[0], 0, pads[1]]; + strides = [1].concat(strides); + dilations = [1].concat(dilations); + kernelShape = [1].concat(kernelShape); + const adjustedAttributes = getAdjustedConvTransposeAttributes({ ...attributes, pads, strides, dilations, kernelShape }, inputs); + context.compute(createConvTranspose2DProgramInfo( + inputs, + adjustedAttributes, + (outputShape) => isChannelLast ? [outputShape[0], outputShape[2], outputShape[3]] : [outputShape[0], outputShape[1], outputShape[3]] + )); + }; + convTranspose = (context, attributes) => { + validateInputs10(context.inputs, attributes); + if (context.inputs[0].dims.length === 3) { + convTranspose1d(context, attributes); + } else { + convTranspose2d(context, context.inputs, attributes); + } + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/cumsum.ts +var createCumsumProgramInfo, cumsum, parseCumSumAttributes; +var init_cumsum = __esm({ + "web/lib/wasm/jsep/webgpu/ops/cumsum.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_attribute_with_cache_key(); + init_common(); + createCumsumProgramInfo = (inputType, inputShape, axisInput, attributes) => { + const outputSize = ShapeUtil.size(inputShape); + const rank = inputShape.length; + const input = inputVariable("input", inputType, rank); + const output = outputVariable("output", inputType, rank); + const axisValue = axisInput.dataType === 6 /* int32 */ ? axisInput.getInt32Array()[0] : Number(axisInput.getBigInt64Array()[0]); + const axis = ShapeUtil.normalizeAxis(axisValue, rank); + const getShaderSource = (shaderHelper) => { + const index = ` i32(${input.indicesGet("inputIndices", "uniforms.axis")}) `; + const max = getElementAt("uniforms.input_shape", "uniforms.axis", rank); + const lowerLimit = attributes.reverse ? index + (attributes.exclusive ? " + 1" : "") : "0"; + const upperLimit = attributes.reverse ? max : index + (attributes.exclusive ? "" : " + 1"); + return ` + ${shaderHelper.registerUniform("outputSize", "u32").registerUniform("axis", "u32").declareVariables(input, output)} + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")} + var inputIndices = ${output.offsetToIndices("global_idx")}; + var sum = ${output.type.value}(0); + let first : i32 = ${lowerLimit}; + let last : i32 = ${upperLimit}; + for (var i : i32 = first; i < last; i++) { + ${input.indicesSet("inputIndices", "uniforms.axis", "u32(i)")}; + sum = sum + ${input.getByIndices("inputIndices")}; + } + ${output.setByOffset("global_idx", "sum")}; + }`; + }; + return { + name: "CumSum", + shaderCache: { hint: attributes.cacheKey, inputDependencies: ["rank"] }, + getRunData: () => ({ + outputs: [{ dims: inputShape, dataType: inputType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms: [ + { type: 12 /* uint32 */, data: outputSize }, + { type: 12 /* uint32 */, data: axis }, + ...createTensorShapeVariables(inputShape, inputShape) + ] + }), + getShaderSource + }; + }; + cumsum = (context, attributes) => { + const inputShape = context.inputs[0].dims; + const inputType = context.inputs[0].dataType; + const axis = context.inputs[1]; + context.compute(createCumsumProgramInfo(inputType, inputShape, axis, attributes), { inputs: [0] }); + }; + parseCumSumAttributes = (attributes) => { + const exclusive = attributes.exclusive === 1; + const reverse = attributes.reverse === 1; + return createAttributeWithCacheKey({ exclusive, reverse }); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/depth-to-space.ts +var validateInputs11, permFunctionBody2, createDepthToSpaceProgramInfo, depthToSpace, parseDepthToSpaceAttributes; +var init_depth_to_space = __esm({ + "web/lib/wasm/jsep/webgpu/ops/depth-to-space.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_attribute_with_cache_key(); + init_common(); + validateInputs11 = (inputs) => { + if (!inputs || inputs.length !== 1) { + throw new Error("DepthToSpace requires 1 input."); + } + if (inputs[0].dims.length !== 4) { + throw new Error("DepthToSpace requires 4D input."); + } + }; + permFunctionBody2 = (perm, rank, input, output) => { + const reverseFunc = []; + reverseFunc.push(`fn perm(i: ${output.type.indices}) -> ${input.type.indices} { + var a: ${input.type.indices};`); + for (let i = 0; i < rank; ++i) { + reverseFunc.push(input.indicesSet("a", perm[i], `i[${i}]`)); + } + reverseFunc.push("return a;}"); + return reverseFunc.join("\n"); + }; + createDepthToSpaceProgramInfo = (inputTensor, attributes) => { + let n, h, w, c; + let shape; + let perm; + const isChannelLast = attributes.format === "NHWC"; + const blocksize = attributes.blocksize; + const isDCRmode = attributes.mode === "DCR"; + if (isChannelLast) { + [n, h, w, c] = inputTensor.dims; + shape = isDCRmode ? [n, h, w, blocksize, blocksize, c / blocksize ** 2] : [n, h, w, c / blocksize ** 2, blocksize, blocksize]; + perm = isDCRmode ? [0, 1, 3, 2, 4, 5] : [0, 1, 4, 2, 5, 3]; + } else { + [n, h, w, c] = [inputTensor.dims[0], inputTensor.dims[2], inputTensor.dims[3], inputTensor.dims[1]]; + shape = isDCRmode ? [n, blocksize, blocksize, c / blocksize ** 2, h, w] : [n, c / blocksize ** 2, blocksize, blocksize, h, w]; + perm = isDCRmode ? [0, 3, 4, 1, 5, 2] : [0, 1, 4, 2, 5, 3]; + } + const reshapedInputTensor = inputTensor.reshape(shape); + const reshapedInputRank = reshapedInputTensor.dims.length; + const inputDataType = inputTensor.dataType; + const reshapedInput = inputVariable("a", inputDataType, reshapedInputRank); + const permedOutput = outputVariable("output", inputDataType, reshapedInputRank); + const getShaderSource = (shaderHelper) => ` + ${shaderHelper.registerUniform("output_size", "u32").declareVariables(reshapedInput, permedOutput)} + + ${permFunctionBody2(perm, reshapedInputRank, reshapedInput, permedOutput)} + + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")} + + let indices = ${permedOutput.offsetToIndices("global_idx")}; + let aIndices = perm(indices); + + ${permedOutput.setByOffset("global_idx", reshapedInput.getByIndices("aIndices"))} + }`; + return { + name: "DepthToSpace", + shaderCache: { hint: `${inputTensor.dims};${attributes.blocksize};${attributes.mode}`, inputDependencies: ["rank"] }, + getRunData: (inputs) => { + const outputShape = isChannelLast ? [n, h * blocksize, w * blocksize, c / blocksize ** 2] : [n, c / blocksize ** 2, h * blocksize, w * blocksize]; + const outputSize = ShapeUtil.size(outputShape); + const shapeBeforePerm = reshapedInputTensor.dims; + const shapeAfterPerm = ShapeUtil.sortBasedOnPerm(shapeBeforePerm, perm); + return { + outputs: [{ dims: outputShape, dataType: inputs[0].dataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms: [{ type: 12 /* uint32 */, data: outputSize }, ...createTensorShapeVariables(shapeBeforePerm, shapeAfterPerm)] + }; + }, + getShaderSource + }; + }; + depthToSpace = (context, attributes) => { + validateInputs11(context.inputs); + context.compute(createDepthToSpaceProgramInfo(context.inputs[0], attributes)); + }; + parseDepthToSpaceAttributes = (attributes) => createAttributeWithCacheKey({ + blocksize: attributes.blocksize, + mode: attributes.mode, + format: attributes.format + }); + } +}); + +// web/lib/wasm/jsep/webgpu/ops/einsum.ts +var symbolPattern, termPattern, termPatternOnly, lhsPattern, lhsPatternOnly, EinsumTerm, EinsumEquation, appendMax, createEinsumProgramInfo, einsum, parseEinsumAttributes; +var init_einsum = __esm({ + "web/lib/wasm/jsep/webgpu/ops/einsum.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_attribute_with_cache_key(); + init_common(); + symbolPattern = "[a-zA-Z]|\\.\\.\\."; + termPattern = "(" + symbolPattern + ")+"; + termPatternOnly = "^" + termPattern + "$"; + lhsPattern = "(" + termPattern + ",)*" + termPattern; + lhsPatternOnly = "^" + lhsPattern + "$"; + EinsumTerm = class { + constructor(inputIndex = -1) { + this.symbolToIndices = /* @__PURE__ */ new Map(); + this.inputIndex = inputIndex; + } + // Add a symbol to the term + addSymbol(symbol, index) { + let value = this.symbolToIndices.get(symbol); + if (value === void 0) { + value = [index]; + } else { + value.push(index); + } + this.symbolToIndices.set(symbol, value); + } + // -1 for output and 0, 1, 2, ... for inputs + }; + EinsumEquation = class { + constructor(inputs, equation) { + this.equation = equation; + this.hasEllipsis = false; + this.symbolToInfo = /* @__PURE__ */ new Map(); + this.lhs = new Array(); + this.outputDims = []; + let [lhs, rhs] = equation.includes("->") ? equation.split("->", 2) : [equation, ""]; + if (!lhs.match(RegExp(lhsPatternOnly))) { + throw new Error("Invalid LHS term"); + } + const inputTerms = lhs.split(","); + inputTerms.forEach((inputTerm, index) => { + const dims = inputs[index].dims.slice(); + if (!inputTerm.match(RegExp(termPatternOnly))) { + throw new Error("Invalid LHS term"); + } + const einsumTerm = this.processTerm(inputTerm, true, dims, index); + this.lhs.push(einsumTerm); + }); + if (rhs === "") { + rhs += [...this.symbolToInfo.entries()].filter(([sym, info]) => info.count === 1 || sym === "...").map(([sym]) => sym).join(""); + } else { + if (!rhs.match(RegExp(termPattern))) { + throw new Error("Invalid RHS"); + } + } + const rhsSymbols = rhs.match(RegExp(symbolPattern, "g")); + rhsSymbols?.forEach((symbol) => { + if (symbol === "...") { + this.outputDims = this.outputDims.concat(this.ellipsisDims); + } else { + const info = this.symbolToInfo.get(symbol); + if (info === void 0) { + throw new Error("Invalid RHS symbol"); + } + this.outputDims.push(info.dimValue); + } + }); + this.rhs = this.processTerm(rhs, false, this.outputDims); + } + // End of EinsumEqation constructor + // Add a symbol to the equation + addSymbol(symbol, dimValue, inputIndex) { + let info = this.symbolToInfo.get(symbol); + if (info !== void 0) { + if (info.dimValue !== dimValue && info.count !== 1) { + throw new Error("Dimension mismatch"); + } else { + info.count++; + info.inputIndices.push(inputIndex); + } + } else { + info = { count: 1, dimValue, inputIndices: [inputIndex] }; + } + this.symbolToInfo.set(symbol, info); + } + // Process one input/output term + processTerm(term, isInput, dims, index = -1) { + const rank = dims.length; + let ellipsis = false; + let ellipsisDims = []; + let nextDim = 0; + if (!term.match(RegExp(termPatternOnly)) && (!isInput && term !== "")) { + throw new Error("Invalid LHS term"); + } + const indexSymbols = term.match(RegExp(symbolPattern, "g")); + const einsumTerm = new EinsumTerm(index); + indexSymbols?.forEach((symbol, i) => { + if (symbol === "...") { + if (ellipsis) { + throw new Error("Only one ellipsis is allowed per input term"); + } + ellipsis = true; + const ellipsisDimLength = rank - indexSymbols.length + 1; + if (ellipsisDimLength < 0) { + throw new Error("Ellipsis out of bounds"); + } + ellipsisDims = dims.slice(nextDim, nextDim + ellipsisDimLength); + if (this.hasEllipsis) { + if (this.ellipsisDims.length !== ellipsisDims.length || this.ellipsisDims.toString() !== ellipsisDims.toString()) { + throw new Error("Ellipsis dimensions mismatch"); + } + } else if (isInput) { + this.hasEllipsis = true; + this.ellipsisDims = ellipsisDims; + } else { + throw new Error("Ellipsis must be specified in the LHS"); + } + for (let j = 0; j < ellipsisDims.length; j++) { + const symbol2 = String.fromCharCode("0".charCodeAt(0) + j); + einsumTerm.addSymbol(symbol2, i + j); + this.addSymbol(symbol2, dims[nextDim++], index); + } + } else { + einsumTerm.addSymbol(symbol, i + (this.hasEllipsis ? this.ellipsisDims.length - 1 : 0)); + this.addSymbol(symbol, dims[nextDim++], index); + } + }); + return einsumTerm; + } + // Output dimensions of the equation + }; + appendMax = (name) => name + "_max"; + createEinsumProgramInfo = (inputShapes, dataType, einsumEquation, outputShape) => { + const ranks = inputShapes.map((dims) => dims.length); + const inputVars = ranks.map((rank, index) => inputVariable(`input${index}`, dataType, rank)); + const outputSize = ShapeUtil.size(outputShape); + const output = outputVariable("output", dataType, outputShape.length); + const uniformsSymbols = [...einsumEquation.symbolToInfo.keys()].filter((symbol) => !einsumEquation.rhs.symbolToIndices.has(symbol)); + const getShaderSource = (shaderHelper) => { + const idxCopy = []; + const initProd = "var prod = 1.0;"; + const initSum = "var sum = 0.0;"; + const updateSum = "sum += prod;"; + const reduceOpsSetIndices = []; + const reduceOpsLoopHeaders = []; + const reduceOpsLoopFooters = []; + const reduceOpCompute = []; + const isReduceOpsWithoutLoop = einsumEquation.symbolToInfo.size === einsumEquation.rhs.symbolToIndices.size; + einsumEquation.symbolToInfo.forEach((info, symbol) => { + if (einsumEquation.rhs.symbolToIndices.has(symbol)) { + const outputIndex = einsumEquation.rhs.symbolToIndices.get(symbol)?.[0]; + if (outputIndex !== void 0) { + einsumEquation.lhs.forEach((term, i) => { + if (info.inputIndices.includes(i)) { + const indices = term.symbolToIndices.get(symbol); + if (indices === void 0) { + throw new Error("Invalid symbol error"); + } + indices.forEach((index) => { + idxCopy.push(`${inputVars[i].indicesSet( + `input${i}Indices`, + index, + output.indicesGet("outputIndices", outputIndex) + )}`); + }); + } + }); + } + } else { + einsumEquation.lhs.forEach((term, i) => { + if (info.inputIndices.includes(i)) { + const indices = term.symbolToIndices.get(symbol); + if (indices === void 0) { + throw new Error("Invalid symbol error"); + } + indices.forEach((index) => { + reduceOpsSetIndices.push(`${inputVars[i].indicesSet(`input${i}Indices`, index, `${symbol}`)}`); + }); + reduceOpCompute.push(`prod *= ${inputVars[i].getByIndices(`input${i}Indices`)};`); + } + }); + reduceOpsLoopHeaders.push( + `for(var ${symbol}: u32 = 0; ${symbol} < uniforms.${appendMax(symbol)}; ${symbol}++) {` + ); + reduceOpsLoopFooters.push("}"); + } + }); + const reduceOps2 = isReduceOpsWithoutLoop ? [ + ...idxCopy, + `let sum = ${inputVars.map((inputVar, i) => inputVar.getByIndices(`input${i}Indices`)).join(" * ")};` + ] : [ + ...idxCopy, + initSum, + ...reduceOpsLoopHeaders, + ...reduceOpsSetIndices, + initProd, + ...reduceOpCompute, + updateSum, + ...reduceOpsLoopFooters + ]; + return ` + ${shaderHelper.registerUniforms(uniformsSymbols.map((symbol) => ({ name: `${appendMax(symbol)}`, type: "u32" }))).registerUniform("outputSize", "u32").declareVariables(...inputVars, output)} + + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")} + var outputIndices = ${output.offsetToIndices("global_idx")}; + ${inputVars.map((_var, i) => `var input${i}Indices: ${inputVars[i].type.indices};`).join("\n")} + ${reduceOps2.join("\n")}; + ${output.setByOffset("global_idx", "sum")}; + }`; + }; + return { + name: "Einsum", + shaderCache: { hint: einsumEquation.equation, inputDependencies: inputShapes.map(() => "rank") }, + getRunData: () => { + const programUniformsInit = uniformsSymbols.filter((symbol) => einsumEquation.symbolToInfo.has(symbol)).map( + (symbol) => ({ type: 12 /* uint32 */, data: einsumEquation.symbolToInfo.get(symbol)?.dimValue || 0 }) + ); + programUniformsInit.push({ type: 12 /* uint32 */, data: outputSize }); + const programUniforms = inputShapes.map((dims, _) => [...createTensorShapeVariables(dims)]).reduce((acc, inputProgramUniforms) => acc.concat(inputProgramUniforms), programUniformsInit); + programUniforms.push(...createTensorShapeVariables(outputShape)); + return { + outputs: [{ dims: outputShape, dataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms + }; + }, + getShaderSource + }; + }; + einsum = (context, attributes) => { + const einsumEquation = new EinsumEquation(context.inputs, attributes.equation); + const outputShape = einsumEquation.outputDims; + const inputShapes = context.inputs.map((input, _) => input.dims); + context.compute(createEinsumProgramInfo(inputShapes, context.inputs[0].dataType, einsumEquation, outputShape)); + }; + parseEinsumAttributes = (attributes) => { + const equation = attributes.equation.replace(/\s+/g, ""); + return createAttributeWithCacheKey({ equation }); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/expand.ts +var validateInputs12, getAdjustedShape, calculateOutputShape2, createExpandProgramInfo, expand; +var init_expand = __esm({ + "web/lib/wasm/jsep/webgpu/ops/expand.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_common(); + validateInputs12 = (inputs) => { + if (!inputs || inputs.length !== 2) { + throw new Error("Expand requires 2 input."); + } + const inputShape = inputs[0].dims; + const shape = Array.from(inputs[1].getBigInt64Array(), Number); + let shapeIndex = shape.length < inputShape.length ? 0 : shape.length - inputShape.length; + let inputShapeIndex = inputShape.length < shape.length ? 0 : inputShape.length - shape.length; + for (; shapeIndex < shape.length && inputShapeIndex < inputShape.length; ++shapeIndex, ++inputShapeIndex) { + if (shape[shapeIndex] !== inputShape[inputShapeIndex] && shape[shapeIndex] !== 1 && inputShape[inputShapeIndex] !== 1) { + throw new Error("Expand requires shape to be broadcastable to input"); + } + } + }; + getAdjustedShape = (shape1, shape2) => { + const diff = shape1.length - shape2.length; + const shape = []; + for (let i = 0; i < diff; ++i) { + shape.push(shape1[i]); + } + for (let i = 0; i < shape2.length; ++i) { + shape.push(shape2[i] === 1 ? shape1[i + diff] : shape2[i]); + } + return shape; + }; + calculateOutputShape2 = (inputShape, shape) => inputShape.length > shape.length ? getAdjustedShape(inputShape, shape) : getAdjustedShape(shape, inputShape); + createExpandProgramInfo = (inputs) => { + const inputShape = inputs[0].dims; + const shape = Array.from(inputs[1].getBigInt64Array(), Number); + const outputShape = calculateOutputShape2(inputShape, shape); + const dataType = inputs[0].dataType; + const components = dataType === 9 /* bool */ ? 4 : 1; + const outputSize = Math.ceil(ShapeUtil.size(outputShape) / components); + const getShaderSource = (shaderHelper) => { + const input = inputVariable("input", dataType, inputShape.length, components); + const output = outputVariable("output", dataType, outputShape.length, components); + let assignment; + if (dataType === 9 /* bool */) { + const singleAssignment = (resStr, x, typeCast = "") => ` + let outputIndices${x} = ${output.offsetToIndices(`outputOffset + ${x}u`)}; + let offset${x} = ${input.broadcastedIndicesToOffset(`outputIndices${x}`, output)}; + let index${x} = offset${x} / 4u; + let component${x} = offset${x} % 4u; + ${resStr}[${x}] = ${typeCast}(${input.getByOffset(`index${x}`)}[component${x}]); + `; + assignment = ` + let outputOffset = global_idx * ${components}; + var data = vec4(0); + ${singleAssignment("data", 0, "u32")} + ${singleAssignment("data", 1, "u32")} + ${singleAssignment("data", 2, "u32")} + ${singleAssignment("data", 3, "u32")} + ${output.setByOffset("global_idx", "data")} + }`; + } else { + assignment = ` + let outputIndices = ${output.offsetToIndices("global_idx")}; + let inputOffset = ${input.broadcastedIndicesToOffset("outputIndices", output)}; + ${output.setByOffset("global_idx", input.getByOffset("inputOffset"))} + }`; + } + return ` + ${shaderHelper.registerUniform("vec_size", "u32").declareVariables(input, output)} + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.vec_size")} + ${assignment}`; + }; + const programUniforms = [{ type: 12 /* uint32 */, data: outputSize }, ...createTensorShapeVariables(inputShape, outputShape)]; + return { + name: "Expand", + shaderCache: { hint: `${outputShape.length}`, inputDependencies: ["rank"] }, + getShaderSource, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: inputs[0].dataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms + }) + }; + }; + expand = (context) => { + validateInputs12(context.inputs); + context.compute(createExpandProgramInfo(context.inputs), { inputs: [0] }); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/fast-gelu.ts +var createFastGeluProgramInfo, fastGelu2; +var init_fast_gelu = __esm({ + "web/lib/wasm/jsep/webgpu/ops/fast-gelu.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_common(); + init_unary_op(); + createFastGeluProgramInfo = (inputTensors) => { + const dataType = inputTensors[0].dataType; + const outputSize = ShapeUtil.size(inputTensors[0].dims); + const biasLength = ShapeUtil.size(inputTensors[1].dims); + const useVec4 = biasLength % 4 === 0; + const getShaderSource = (shaderHelper) => { + const x = inputVariable("x", dataType, [1], 4); + const bias = inputVariable("bias", dataType, [1], 4); + const y = outputVariable("y", dataType, [1], 4); + const uniforms = [{ name: "output_vec_size", type: "u32" }, { name: "bias_size", type: "u32" }]; + const singleElementBias = (i) => ` + let bias${i}_offset: u32 = (global_idx * 4 + ${i}) % uniforms.bias_size; + let bias${i} = ${bias.getByOffset(`bias${i}_offset / 4`)}[bias${i}_offset % 4];`; + const biasGetExpression = useVec4 ? ` + let bias = ${bias.getByOffset("global_idx % (uniforms.bias_size / 4)")};` : `${singleElementBias(0)}${singleElementBias(1)}${singleElementBias(2)}${singleElementBias(3)} + let bias = ${x.type.value}(bias0, bias1, bias2, bias3);`; + return `${shaderHelper.registerUniforms(uniforms).declareVariables(x, bias, y)} + + ${fastGeluImpl(tensorTypeToWsglValueType(dataType))} + + ${shaderHelper.mainStart(WORKGROUP_SIZE)} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_vec_size")} + + let x = ${x.getByOffset("global_idx")}; + ${biasGetExpression} + let x_in = x + bias; + ${y.setByOffset("global_idx", fastGeluExpression("x_in"))} + }`; + }; + return { + name: "FastGeluWithBias", + shaderCache: { hint: `${useVec4}`, inputDependencies: ["type", "type"] }, + getShaderSource, + getRunData: (inputs) => ({ + outputs: [{ dims: inputs[0].dims, dataType: inputs[0].dataType }], + programUniforms: [{ type: 12 /* uint32 */, data: Math.ceil(outputSize / 4) }, { type: 12 /* uint32 */, data: biasLength }], + dispatchGroup: { x: Math.ceil(outputSize / WORKGROUP_SIZE / 4) } + }) + }; + }; + fastGelu2 = (context) => { + if (context.inputs.length < 2 || ShapeUtil.size(context.inputs[1].dims) === 0) { + fastGelu(context); + } else { + context.compute(createFastGeluProgramInfo(context.inputs)); + } + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/gather.ts +var validateInputs13, createGatherProgramInfo, parseGatherAttributes, gather; +var init_gather = __esm({ + "web/lib/wasm/jsep/webgpu/ops/gather.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_attribute_with_cache_key(); + init_common(); + validateInputs13 = (inputs) => { + if (!inputs || inputs.length !== 2) { + throw new Error("Gather requires 2 inputs."); + } + }; + createGatherProgramInfo = (inputs, attributes) => { + const inputShape = inputs[0].dims; + const indicesShape = inputs[1].dims; + const inputRank = inputShape.length; + const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank); + const outputShape = inputShape.slice(0); + outputShape.splice(axis, 1, ...indicesShape); + const axisDimLimit = inputShape[axis]; + const components = inputs[0].dataType === 9 /* bool */ ? 4 : 1; + const outputSize = Math.ceil(ShapeUtil.size(outputShape) / components); + const programUniforms = [ + { type: 12 /* uint32 */, data: outputSize }, + { type: 6 /* int32 */, data: axisDimLimit }, + { type: 12 /* uint32 */, data: axis }, + ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims, outputShape) + ]; + const getShaderSource = (shaderHelper) => { + const data = inputVariable("data", inputs[0].dataType, inputs[0].dims.length, components); + const indices = inputVariable("inputIndices", inputs[1].dataType, inputs[1].dims.length); + const output = outputVariable("output", inputs[0].dataType, outputShape.length, components); + const calcDataIndices = (x) => { + const indicesRank = indicesShape.length; + let calcStr = `var indicesIndices${x} = ${indices.type.indices}(0);`; + for (let i = 0; i < indicesRank; i++) { + calcStr += `${indicesRank > 1 ? `indicesIndices${x}[${i}]` : `indicesIndices${x}`} = ${outputShape.length > 1 ? `outputIndices${x}[uniforms.axis + ${i}]` : `outputIndices${x}`};`; + } + calcStr += ` + var idx${x} = ${indices.getByIndices(`indicesIndices${x}`)}; + if (idx${x} < 0) { + idx${x} = idx${x} + uniforms.axisDimLimit; + } + var dataIndices${x} : ${data.type.indices}; + `; + for (let i = 0, j = 0; i < inputRank; i++) { + if (i === axis) { + calcStr += `${inputRank > 1 ? `dataIndices${x}[${i}]` : `dataIndices${x}`} = u32(idx${x});`; + j += indicesRank; + } else { + calcStr += `${inputRank > 1 ? `dataIndices${x}[${i}]` : `dataIndices${x}`} = ${outputShape.length > 1 ? `outputIndices${x}[${j}]` : `outputIndices${x}`};`; + j++; + } + } + return calcStr; + }; + let assignment; + if (inputs[0].dataType === 9 /* bool */) { + const singleAssignment = (resStr, x, typeCast = "") => ` + let outputIndices${x} = ${output.offsetToIndices(`outputOffset + ${x}u`)}; + ${calcDataIndices(x)}; + let offset${x} = ${data.indicesToOffset(`dataIndices${x}`)}; + let index${x} = offset${x} / 4u; + let component${x} = offset${x} % 4u; + ${resStr}[${x}] = ${typeCast}(${data.getByOffset(`index${x}`)}[component${x}]); + `; + assignment = ` + let outputOffset = global_idx * ${components}; + var value = vec4(0); + ${singleAssignment("value", 0, "u32")} + ${singleAssignment("value", 1, "u32")} + ${singleAssignment("value", 2, "u32")} + ${singleAssignment("value", 3, "u32")} + ${output.setByOffset("global_idx", "value")} + `; + } else { + assignment = ` + let outputIndices = ${output.offsetToIndices("global_idx")}; + ${calcDataIndices("")}; + let value = ${data.getByIndices("dataIndices")}; + ${output.setByOffset("global_idx", "value")}; + `; + } + return ` + ${shaderHelper.registerUniform("outputSize", "u32").registerUniform("axisDimLimit", "i32").registerUniform("axis", "u32").declareVariables(data, indices, output)} + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")} + ${assignment} + }`; + }; + return { + name: "Gather", + shaderCache: { hint: attributes.cacheKey, inputDependencies: ["rank", "rank"] }, + getRunData: () => ({ + outputs: [ + { dims: outputShape, dataType: inputs[0].dataType } + ], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms + }), + getShaderSource + }; + }; + parseGatherAttributes = (attributes) => createAttributeWithCacheKey({ axis: attributes.axis }); + gather = (context, attributes) => { + const inputs = context.inputs; + validateInputs13(inputs); + context.compute(createGatherProgramInfo(context.inputs, attributes)); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/gather-elements.ts +var validateInputs14, createGatherElementsProgramInfo, parseGatherElementsAttributes, gatherElements; +var init_gather_elements = __esm({ + "web/lib/wasm/jsep/webgpu/ops/gather-elements.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_attribute_with_cache_key(); + init_common(); + validateInputs14 = (inputs) => { + if (!inputs || inputs.length !== 2) { + throw new Error("GatherElements requires 2 inputs."); + } + if (inputs[0].dims.length < 1) { + throw new Error("GatherElements requires that the data input be rank >= 1."); + } + if (inputs[0].dims.length !== inputs[1].dims.length) { + throw new Error(`GatherElements requires that the data input and + indices input tensors be of same rank.`); + } + }; + createGatherElementsProgramInfo = (inputs, attributes) => { + const inputShape = inputs[0].dims; + const inputOutputDataType = inputs[0].dataType; + const inputRank = inputShape.length; + const indicesShape = inputs[1].dims; + const indicesDataType = inputs[1].dataType; + const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank); + const axisDimLimit = inputShape[axis]; + const outputShape = indicesShape.slice(0); + const outputSize = ShapeUtil.size(outputShape); + const input = inputVariable("input", inputOutputDataType, inputRank); + const indices = inputVariable("indicesInput", indicesDataType, indicesShape.length); + const output = outputVariable("output", inputOutputDataType, outputShape.length); + const programUniforms = [ + { type: 12 /* uint32 */, data: outputSize }, + { type: 6 /* int32 */, data: axisDimLimit }, + { type: 12 /* uint32 */, data: axis } + ]; + programUniforms.push(...createTensorShapeVariables(inputShape, indicesShape, outputShape)); + const inputDependencies = ["rank", "rank"]; + const getShaderSource = (shaderHelper) => ` + ${shaderHelper.registerUniform("outputSize", "u32").registerUniform("axisDimLimit", "i32").registerUniform("axis", "u32").declareVariables(input, indices, output)} + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")} + + let outputIndices = ${output.offsetToIndices("global_idx")}; + + var idx = ${indices.getByOffset("global_idx")}; + if (idx < 0) { + idx = idx + uniforms.axisDimLimit; + } + var inputIndices = ${input.type.indices}(outputIndices); + ${input.indicesSet("inputIndices", "uniforms.axis", "u32(idx)")}; + let value = ${input.getByIndices("inputIndices")}; + + ${output.setByOffset("global_idx", "value")}; + }`; + return { + name: "GatherElements", + shaderCache: { inputDependencies }, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: inputs[0].dataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms + }), + getShaderSource + }; + }; + parseGatherElementsAttributes = (attributes) => createAttributeWithCacheKey({ axis: attributes.axis }); + gatherElements = (context, attributes) => { + const inputs = context.inputs; + validateInputs14(inputs); + context.compute(createGatherElementsProgramInfo(context.inputs, attributes)); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/gemm.ts +var validateInputs15, createGemmProgramInfo, parseGemmAttributes, gemm; +var init_gemm = __esm({ + "web/lib/wasm/jsep/webgpu/ops/gemm.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_common(); + validateInputs15 = (inputs) => { + if (!inputs) { + throw new Error("Input is missing"); + } + if (inputs.length < 2 || inputs.length > 3) { + throw new Error("Invaid input number."); + } + if (inputs.length === 3 && inputs[2].dims.length > 2) { + throw new Error("Invalid input shape of C"); + } + if (inputs[0].dataType !== inputs[1].dataType || inputs.length === 3 && inputs[0].dataType !== inputs[2].dataType) { + throw new Error("Input types are mismatched"); + } + }; + createGemmProgramInfo = (inputs, attributes) => { + const aShape = inputs[0].dims.slice(); + const bShape = inputs[1].dims.slice(); + const [M, N, K] = GemmUtil.getShapeOfGemmResult( + aShape, + attributes.transA, + bShape, + attributes.transB, + inputs.length === 3 ? inputs[2].dims : void 0 + ); + const outputShape = [M, N]; + if (!outputShape) { + throw new Error("Can't use gemm on the given tensors"); + } + const outputSize = ShapeUtil.size(outputShape); + const programUniforms = [ + { type: 12 /* uint32 */, data: outputSize }, + { type: 12 /* uint32 */, data: M }, + { type: 12 /* uint32 */, data: N }, + { type: 12 /* uint32 */, data: K }, + { type: 1 /* float */, data: attributes.alpha }, + { type: 1 /* float */, data: attributes.beta } + ]; + const inputDependencies = ["type", "type"]; + if (inputs.length === 3) { + programUniforms.push(...createTensorShapeVariables(inputs[2].dims)); + inputDependencies.push("rank"); + } + programUniforms.push(...createTensorShapeVariables(outputShape)); + const getShaderSource = (shaderHelper) => { + let line = ""; + if (attributes.transA && attributes.transB) { + line = "value += a[k * uniforms.M + m] * b[n * uniforms.K + k];"; + } else if (attributes.transA && !attributes.transB) { + line = "value += a[k * uniforms.M + m] * b[k * uniforms.N + n];"; + } else if (!attributes.transA && attributes.transB) { + line = "value += a[m * uniforms.K + k] * b[n * uniforms.K + k];"; + } else if (!attributes.transA && !attributes.transB) { + line = "value += a[m * uniforms.K + k] * b[k * uniforms.N + n];"; + } + const calculateAlpha = attributes.alpha === 1 ? "" : "value *= uniforms.alpha;"; + const a = inputVariable("a", inputs[0].dataType, inputs[0].dims); + const b = inputVariable("b", inputs[1].dataType, inputs[1].dims); + const dataType = a.type.value; + let c = null; + const variables = [a, b]; + if (inputs.length === 3) { + c = inputVariable("c", inputs[2].dataType, inputs[2].dims.length); + variables.push(c); + } + const output = outputVariable("output", inputs[0].dataType, outputShape.length); + variables.push(output); + const uniforms = [ + { name: "output_size", type: "u32" }, + { name: "M", type: "u32" }, + { name: "N", type: "u32" }, + { name: "K", type: "u32" }, + { name: "alpha", type: "f32" }, + { name: "beta", type: "f32" } + ]; + return ` + ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)} + + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")} + + let m = global_idx / uniforms.N; + let n = global_idx % uniforms.N; + + var value = ${dataType}(0); + for (var k: u32 = 0u; k < uniforms.K; k++) { + ${line} + } + + ${calculateAlpha} + ${(() => { + if (c != null) { + return `let cOffset = ${c.broadcastedIndicesToOffset("vec2(m, n)", output)}; value += ${dataType}(uniforms.beta) * ${c.getByOffset("cOffset")};`; + } + return ""; + })()} + output[global_idx] = value; + }`; + }; + return { + name: "Gemm", + shaderCache: { hint: `${attributes.cacheKey}`, inputDependencies }, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: inputs[0].dataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms + }), + getShaderSource + }; + }; + parseGemmAttributes = (attributes) => { + const transA = attributes.transA; + const transB = attributes.transB; + const alpha = attributes.alpha; + const beta = attributes.beta; + return { transA, transB, alpha, beta, cacheKey: `${attributes.transA};${attributes.transB};${attributes.alpha === 1}` }; + }; + gemm = (context, attributes) => { + validateInputs15(context.inputs); + context.compute(createGemmProgramInfo(context.inputs, attributes)); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/instance-norm.ts +var createInstanceNormProgramInfo, computeMean, createInstanceNormNHWCProgramInfo, instanceNorm; +var init_instance_norm = __esm({ + "web/lib/wasm/jsep/webgpu/ops/instance-norm.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_common(); + createInstanceNormProgramInfo = (inputs, attributes) => { + const xShape = inputs[0].dims; + const outputShape = xShape; + const axis = 2; + const normCount = ShapeUtil.sizeToDimension(xShape, axis); + const normSize = ShapeUtil.sizeFromDimension(xShape, axis); + const components = getMaxComponents(normSize); + const normPackedSize = normSize / components; + const inputShape = [xShape[0], xShape[1], normPackedSize]; + const inputDependencies = ["rank", "type", "type"]; + const programUniforms = [{ type: 12 /* uint32 */, data: normSize }, { type: 12 /* uint32 */, data: normPackedSize }]; + programUniforms.push(...createTensorShapeVariables(inputShape, inputShape)); + const getShaderSource = (shaderHelper) => { + const x = inputVariable("x", inputs[0].dataType, inputShape.length, components); + const scale = inputVariable("scale", inputs[1].dataType, inputs[1].dims); + const bias = inputVariable("bias", inputs[2].dataType, inputs[2].dims); + const output = outputVariable("output", inputs[0].dataType, inputShape.length, components); + const variables = [x, scale, bias, output]; + const dataType = x.type.value; + const f32Type = components === 1 ? "f32" : `vec${components}`; + const workgroupSize = 64; + const uniforms = [{ name: "normSize", type: "u32" }, { name: "normPackedSize", type: "u32" }]; + return ` + var meanShared : f32; + var squaredNormShared : f32; + var workgroupShared : array<${f32Type}, ${workgroupSize}>; + const workgroupSize = ${workgroupSize}u; + ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)} + ${shaderHelper.mainStart(workgroupSize)} + let norm = global_idx / workgroupSize; + let batch = norm / uniforms.x_shape[1]; + let channel = norm % uniforms.x_shape[1]; + let localIndex = local_id.x; + + // initialize workgroup memory + var initial = ${f32Type}(0); + for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) { + initial = initial + ${f32Type}(${x.get("batch", "channel", "h")}); + } + workgroupShared[localIndex] = initial; + workgroupBarrier(); + + // Calculate the mean of current channel data. + for (var currSize = workgroupSize >> 1; currSize > 0; currSize = currSize >> 1) { + if (localIndex < currSize) { + workgroupShared[localIndex] = workgroupShared[localIndex] + workgroupShared[localIndex + currSize]; + } + workgroupBarrier(); + } + if (localIndex == 0) { + meanShared = ${sumVector("workgroupShared[0]", components)} / f32(uniforms.normSize); + } + workgroupBarrier(); + + // reinitialize workgroup memory. + initial = ${f32Type}(0); + for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) { + let deviation = ${f32Type}(${x.get("batch", "channel", "h")}) - ${f32Type}(meanShared); + initial = initial + deviation * deviation; + } + workgroupShared[localIndex] = initial; + workgroupBarrier(); + + // Calculate the sum of square of deviation of current channel data. + for (var currSize = workgroupSize >> 1; currSize > 0; currSize = currSize >> 1) { + if (localIndex < currSize) { + workgroupShared[localIndex] = workgroupShared[localIndex] + workgroupShared[localIndex + currSize]; + } + workgroupBarrier(); + } + if (localIndex == 0) { + squaredNormShared = ${sumVector("workgroupShared[0]", components)}; + } + workgroupBarrier(); + + let invStdDev = inverseSqrt(squaredNormShared / f32(uniforms.normSize) + f32(${attributes.epsilon})); + let channelScale = invStdDev * f32(${scale.getByOffset("channel")}); + let channelShift = f32(${bias.getByOffset("channel")}) - meanShared * channelScale; + for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) { + let value = ${x.get("batch", "channel", "h")} * ${dataType}(${f32Type}(channelScale)) + ${dataType}(${f32Type}(channelShift)); + ${output.set("batch", "channel", "h", "value")}; + } + }`; + }; + return { + ...{ name: "InstanceNormalization" }, + // TODO: use epsilon as uniform. Currently epsilon as uniform fails test_instancenorm_epsilon. + shaderCache: { hint: `${attributes.epsilon};${components}`, inputDependencies }, + getRunData: () => ({ + outputs: [ + { dims: outputShape, dataType: inputs[0].dataType } + ], + dispatchGroup: { x: normCount }, + programUniforms + }), + getShaderSource + }; + }; + computeMean = (context, input, scale, bias, n, h, c, epsilon) => { + const components = getMaxComponents(c); + const WG = 64; + const outputType = components === 1 ? "vec2f" : `mat2x${components}f`; + const sumCastType = components === 1 ? "f32" : `vec${components}f`; + const setOutputValue = (var1, var2) => `${outputType}(${var1}, ${var2})`; + const unitsOfWork = n * c / components; + const wgSize = Math.ceil(h / WG); + const meanInputDependencies = ["type"]; + const meanProgramUniforms = [ + { type: 12 /* uint32 */, data: wgSize }, + { type: 12 /* uint32 */, data: h }, + { type: 12 /* uint32 */, data: Math.floor(c / components) }, + { type: 12 /* uint32 */, data: Math.floor(h * c / components) } + ]; + const getMeanShaderSource = (shaderHelper) => { + const inputHelper = inputVariable("input", input.dataType, input.dims, components); + return ` + ${shaderHelper.declareVariables(inputHelper)} + @group(0) @binding(1) var output : array<${outputType}>; + struct Uniforms {wg_size:u32, H:u32, C:u32, image_size:u32}; + @group(0) @binding(2) var uniforms: Uniforms; + + ${shaderHelper.mainStart(WG)} + let currentImageNumber = global_idx / ${WG} / uniforms.C; + let currentChannelNumber = (global_idx / ${WG}) % uniforms.C; + let wgOffset = local_id.x * uniforms.wg_size; + if (wgOffset >= uniforms.H) { + return; + } + let wgMax = min(wgOffset + uniforms.wg_size, uniforms.H); + + let offset = currentImageNumber * uniforms.image_size + currentChannelNumber; + var sum = ${fillVector("f32", components)}; + var squaredSum = ${fillVector("f32", components)}; + for (var i: u32 = wgOffset; i < wgMax; i++) { + let value = ${sumCastType}(input[offset + i * uniforms.C]); + sum += value; + squaredSum += value * value; + } + output[global_idx] = ${setOutputValue("sum", "squaredSum")}; + }`; + }; + const meanValues = context.compute( + { + name: "InstanceNormComputeMean", + shaderCache: { hint: `${components}`, inputDependencies: meanInputDependencies }, + getRunData: () => ({ + outputs: [ + { dims: [n, c, WG, 2], dataType: 1 /* float */ } + ], + dispatchGroup: { x: n * c / components }, + programUniforms: meanProgramUniforms + }), + getShaderSource: getMeanShaderSource + }, + { inputs: [input], outputs: [-1] } + )[0]; + const programUniforms = [ + { type: 12 /* uint32 */, data: unitsOfWork }, + { type: 12 /* uint32 */, data: h }, + { type: 12 /* uint32 */, data: Math.floor(c / components) }, + { type: 12 /* uint32 */, data: Math.floor(WG * c / components) } + ]; + const inputDependencies = ["type", "type", "type"]; + const getShaderSource = (shaderHelper) => { + const scaleHelper = inputVariable("scale", scale.dataType, scale.dims, components); + const biasHelper = inputVariable("bias", bias.dataType, bias.dims, components); + return ` + @group(0) @binding(0) var input : array<${outputType}>; + @group(0) @binding(1) var scale : array<${scaleHelper.type.storage}>; + @group(0) @binding(2) var bias : array<${biasHelper.type.storage}>; + @group(0) @binding(3) var output : array<${outputType}>; + struct Uniforms {units_of_work : u32, H: u32, C : u32, image_size : u32}; + @group(0) @binding(4) var uniforms: Uniforms; + + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.units_of_work")} + let currentImageNumber = global_idx / uniforms.C; + let currentChannelNumber = global_idx % uniforms.C; + + let offset = currentImageNumber * uniforms.image_size; + var sum = ${fillVector("f32", components)}; + var squaredSum = ${fillVector("f32", components)}; + for (var i: u32 = 0; i < min(${WG}, uniforms.H); i++) { + let value = input[offset + i + currentChannelNumber * ${WG}]; + sum += value[0]; + squaredSum += value[1]; + } + sum = sum / f32(uniforms.H); + squaredSum = squaredSum / f32(uniforms.H); + let invStdDev = inverseSqrt(squaredSum - sum * sum + f32(${epsilon})); + let channelScale = invStdDev * ${sumCastType}(scale[currentChannelNumber]); + let channelShift = ${sumCastType}(bias[currentChannelNumber]) - sum * channelScale; + + output[global_idx] = ${setOutputValue("channelScale", "channelShift")}; + }`; + }; + return context.compute( + { + name: "InstanceNormComputeChannelScaleShift", + // TODO: use epsilon as uniform. Currently epsilon as uniform fails test_instancenorm_epsilon. + shaderCache: { hint: `${components};${epsilon}`, inputDependencies }, + getRunData: () => ({ + outputs: [ + { dims: [n, c, 2], dataType: 1 /* float */ } + ], + dispatchGroup: { x: Math.ceil( + unitsOfWork / 64 + /* workgroup size */ + ) }, + programUniforms + }), + getShaderSource + }, + { inputs: [meanValues, scale, bias], outputs: [-1] } + )[0]; + }; + createInstanceNormNHWCProgramInfo = (context, inputs, attributes) => { + const xShape = inputs[0].dims; + const outputShape = xShape; + const N = xShape[0]; + const C = xShape[xShape.length - 1]; + const H = ShapeUtil.sizeFromDimension(xShape, 1) / C; + const components = getMaxComponents(C); + const outputSize = ShapeUtil.size(outputShape) / components; + const programUniforms = [{ type: 12 /* uint32 */, data: H }, { type: 12 /* uint32 */, data: Math.floor(C / components) }]; + const inputDependencies = ["type", "type"]; + const channelScaleShift = computeMean(context, inputs[0], inputs[1], inputs[2], N, H, C, attributes.epsilon); + const getShaderSource = (shaderHelper) => { + const dataType = tensorTypeToWsglStorageType(inputs[0].dataType); + const scaleType = components === 1 ? "vec2f" : `mat2x${components}f`; + const scaleCastType = components === 1 ? dataType : `vec${components}<${dataType}>`; + const inputHelper = inputVariable("input", inputs[0].dataType, inputs[0].dims, components); + const outputHelper = outputVariable("output", inputs[0].dataType, outputShape, components); + return ` + @group(0) @binding(0) var input : array<${inputHelper.type.storage}>; + @group(0) @binding(1) var scaleInput : array<${scaleType}>; + @group(0) @binding(2) var output : array<${outputHelper.type.storage}>; + struct Uniforms {H: u32, C : u32}; + @group(0) @binding(3) var uniforms: Uniforms; + + ${shaderHelper.mainStart()} + let currentImageNumber = global_idx / (uniforms.C * uniforms.H); + let currentChannelNumber = global_idx % uniforms.C; + + let scaleOffset = currentImageNumber * uniforms.C + currentChannelNumber; + let scale = scaleInput[scaleOffset]; + output[global_idx] = fma(input[global_idx], ${scaleCastType}(scale[0]), ${scaleCastType}(scale[1])); + }`; + }; + context.compute( + { + name: "InstanceNormalizationNHWC", + shaderCache: { hint: `${components}`, inputDependencies }, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: inputs[0].dataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms + }), + getShaderSource + }, + { inputs: [inputs[0], channelScaleShift] } + ); + }; + instanceNorm = (context, attributes) => { + if (attributes.format === "NHWC") { + createInstanceNormNHWCProgramInfo(context, context.inputs, attributes); + } else { + context.compute(createInstanceNormProgramInfo(context.inputs, attributes)); + } + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/layer-norm.ts +var validateInputs16, createLayerNormProgramInfo, layerNorm; +var init_layer_norm = __esm({ + "web/lib/wasm/jsep/webgpu/ops/layer-norm.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_common(); + validateInputs16 = (inputs) => { + if (!inputs || inputs.length < 2) { + throw new Error("layerNorm requires at least 2 inputs."); + } + }; + createLayerNormProgramInfo = (inputs, attributes, outputCount) => { + const simplified = attributes.simplified; + const xShape = inputs[0].dims; + const scale = inputs[1]; + const bias = !simplified && inputs[2]; + const outputShape = xShape; + const axis = ShapeUtil.normalizeAxis(attributes.axis, xShape.length); + const normCount = ShapeUtil.sizeToDimension(xShape, axis); + const normSize = ShapeUtil.sizeFromDimension(xShape, axis); + const scaleSize = ShapeUtil.size(scale.dims); + const biasSize = bias ? ShapeUtil.size(bias.dims) : 0; + if (scaleSize !== normSize || bias && biasSize !== normSize) { + throw new Error(`Size of X.shape()[axis:] == ${normSize}. + Size of scale and bias (if provided) must match this. + Got scale size of ${scaleSize} and bias size of ${biasSize}`); + } + const meanInvStdDevDim = []; + for (let i = 0; i < xShape.length; ++i) { + if (i < axis) { + meanInvStdDevDim.push(xShape[i]); + } else { + meanInvStdDevDim.push(1); + } + } + const components = getMaxComponents(normSize); + const inputDependencies = ["type", "type"]; + const programUniforms = [ + { type: 12 /* uint32 */, data: normCount }, + { type: 1 /* float */, data: normSize }, + { type: 12 /* uint32 */, data: Math.floor(normSize / components) }, + { type: 1 /* float */, data: attributes.epsilon } + ]; + if (bias) { + inputDependencies.push("type"); + } + const hasMeanDataOutput = outputCount > 1; + const hasInvStdOutput = outputCount > 2; + const getShaderSource = (shaderHelper) => { + const dataType = tensorTypeToWsglStorageType(inputs[0].dataType); + const variables = [ + inputVariable("x", inputs[0].dataType, inputs[0].dims, components), + inputVariable("scale", scale.dataType, scale.dims, components) + ]; + if (bias) { + variables.push(inputVariable("bias", bias.dataType, bias.dims, components)); + } + variables.push(outputVariable("output", inputs[0].dataType, outputShape, components)); + if (hasMeanDataOutput) { + variables.push(outputVariable("mean_data_output", 1 /* float */, meanInvStdDevDim)); + } + if (hasInvStdOutput) { + variables.push(outputVariable("inv_std_output", 1 /* float */, meanInvStdDevDim)); + } + const uniforms = [ + { name: "norm_count", type: "u32" }, + { name: "norm_size", type: "f32" }, + { name: "norm_size_vectorized", type: "u32" }, + { name: "epsilon", type: "f32" } + ]; + return ` + ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)} + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.norm_count")} + let offset = global_idx * uniforms.norm_size_vectorized; + var mean_vector = ${fillVector("f32", components)}; + var mean_square_vector = ${fillVector("f32", components)}; + + for (var h: u32 = 0u; h < uniforms.norm_size_vectorized; h++) { + let value = ${castToF32(dataType, components, "x[h + offset]")}; + mean_vector += value; + mean_square_vector += value * value; + } + let mean = ${sumVector("mean_vector", components)} / uniforms.norm_size; + let inv_std_dev = inverseSqrt(${sumVector("mean_square_vector", components)} / uniforms.norm_size ${simplified ? "" : "- mean * mean"} + uniforms.epsilon); + + for (var j: u32 = 0; j < uniforms.norm_size_vectorized; j++) { + let f32input = ${castToF32(dataType, components, "x[j + offset]")}; + let f32scale = ${castToF32(dataType, components, "scale[j]")}; + output[j + offset] = ${variables[0].type.value}((f32input ${simplified ? "" : "- mean"}) * inv_std_dev * f32scale + ${bias ? `+ ${castToF32(dataType, components, "bias[j]")}` : ""} + ); + } + + ${hasMeanDataOutput ? "mean_data_output[global_idx] = mean" : ""}; + ${hasInvStdOutput ? "inv_std_output[global_idx] = inv_std_dev" : ""}; + }`; + }; + const outputs = [{ dims: outputShape, dataType: inputs[0].dataType }]; + if (hasMeanDataOutput) { + outputs.push({ dims: meanInvStdDevDim, dataType: 1 /* float */ }); + } + if (hasInvStdOutput) { + outputs.push({ dims: meanInvStdDevDim, dataType: 1 /* float */ }); + } + return { + name: "LayerNormalization", + shaderCache: { hint: `${components};${outputCount};${simplified}`, inputDependencies }, + getRunData: () => ({ outputs, dispatchGroup: { x: Math.ceil( + normCount / 64 + /* workgroup size */ + ) }, programUniforms }), + getShaderSource + }; + }; + layerNorm = (context, attributes) => { + validateInputs16(context.inputs); + context.compute(createLayerNormProgramInfo(context.inputs, attributes, context.outputCount)); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/matmulnbits.ts +var validateInputs17, createMatMulNBitsProgramInfo, matMulNBits, parseMatMulNBitsAttributes; +var init_matmulnbits = __esm({ + "web/lib/wasm/jsep/webgpu/ops/matmulnbits.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_attribute_with_cache_key(); + init_common(); + validateInputs17 = (inputs, attributes) => { + if (inputs.length < 3 || inputs.length > 4) { + throw new Error("MatMulNBits requires 3 or 4 inputs"); + } + const a = inputs[0]; + const aRank = a.dims.length; + if (a.dims[aRank - 1] !== attributes.k) { + throw new Error("The last dim of input shape does not match the k value"); + } + const nBlocksPerCol = Math.floor((attributes.k + attributes.blockSize - 1) / attributes.blockSize); + const blobSize = attributes.blockSize / 8 * attributes.bits; + const b = inputs[1]; + if (!ShapeUtil.areEqual(b.dims, [attributes.n, nBlocksPerCol, blobSize])) { + throw new Error("The second inputs must be 3D tensor with shape N X nBlocksPerCol X blobSize"); + } + const scales = inputs[2]; + const scalesShape = scales.dims; + if (ShapeUtil.size(scalesShape) !== attributes.n * nBlocksPerCol) { + throw new Error("scales input size error."); + } + if (inputs.length === 4) { + const zeroPoints = inputs[3]; + const zeroPointsShape = zeroPoints.dims; + const expectedZeroPointsSize = attributes.bits > 4 ? attributes.n * nBlocksPerCol : attributes.n * Math.floor((nBlocksPerCol + 1) / 2); + if (ShapeUtil.size(zeroPointsShape) !== expectedZeroPointsSize) { + throw new Error("zeroPoints input size error."); + } + } + }; + createMatMulNBitsProgramInfo = (inputs, attributes, maxComputeWorkgroupSizes, maxComputeWorkgroupStorageSize) => { + const inputShape = inputs[0].dims; + const aRank = inputShape.length; + const nBlocksPerCol = Math.floor((attributes.k + attributes.blockSize - 1) / attributes.blockSize); + const dimAOuter = inputShape[aRank - 2]; + const dimInner = attributes.k; + const dimBOuter = attributes.n; + const batchDims = inputShape.slice(0, aRank - 2); + const batchSize = ShapeUtil.size(batchDims); + const blobSize = attributes.blockSize / 8 * attributes.bits; + const blobSizeInWords = blobSize / 4; + const dataType = inputs[0].dataType; + const outputNumber = getMaxComponents(dimAOuter); + const aComponents = getMaxComponents(attributes.k); + const bComponents = getMaxComponents(blobSizeInWords); + const elementSize = getTensorElementSize(dataType); + const workgroupOutputSize = dimAOuter * nBlocksPerCol * elementSize; + const maxNumberOfComponents = Math.floor(maxComputeWorkgroupStorageSize / workgroupOutputSize); + const useBlockwiseMatMulNBits = nBlocksPerCol <= maxComputeWorkgroupSizes[0] && maxNumberOfComponents > 0; + const components = !useBlockwiseMatMulNBits || maxNumberOfComponents >= 4 ? getMaxComponents(dimBOuter) : maxNumberOfComponents >= 2 && getMaxComponents(dimBOuter) >= 2 ? 2 : 1; + const outputShape = batchDims.concat([dimAOuter, dimBOuter]); + const outputSize = ShapeUtil.size(outputShape) / components / outputNumber; + const programUniforms = useBlockwiseMatMulNBits ? [] : [{ type: 12 /* uint32 */, data: outputSize }, { type: 12 /* uint32 */, data: attributes.blockSize }]; + const inputShapeTemp = [batchSize, dimAOuter, dimInner / aComponents]; + const bShape = ShapeUtil.convertShape(inputs[1].dims).slice(); + bShape.splice(-1, 1, blobSizeInWords / bComponents); + programUniforms.push(...createTensorShapeVariables(inputShapeTemp)); + programUniforms.push(...createTensorShapeVariables(bShape)); + programUniforms.push(...createTensorShapeVariables(inputs[2].dims)); + if (inputs.length === 4) { + programUniforms.push(...createTensorShapeVariables(ShapeUtil.convertShape(inputs[3].dims))); + } + const outputShapeTemp = [batchSize, dimAOuter, dimBOuter / components]; + programUniforms.push(...createTensorShapeVariables(outputShapeTemp)); + const getShaderSource = (shaderHelper) => { + const inputRank = inputShapeTemp.length; + const a = inputVariable("a", inputs[0].dataType, inputRank, aComponents); + const b = inputVariable("b", 12 /* uint32 */, bShape.length, bComponents); + const scales = inputVariable("scales", inputs[2].dataType, inputs[2].dims.length); + const inputVariables = [a, b, scales]; + const zeroPoints = inputs.length === 4 ? inputVariable("zero_points", 12 /* uint32 */, inputs[3].dims.length) : void 0; + if (zeroPoints) { + inputVariables.push(zeroPoints); + } + const outputRank = outputShapeTemp.length; + const output = outputVariable("output", inputs[0].dataType, outputRank, components); + const uniforms = [{ name: "output_size", type: "u32" }, { name: "block_size", type: "u32" }]; + const dataType2 = tensorTypeToWsglStorageType(inputs[0].dataType); + const qDqDataType = (() => { + switch (aComponents) { + case 1: + return `array<${dataType2}, 8>`; + case 2: + return `mat4x2<${dataType2}>`; + case 4: + return `mat2x4<${dataType2}>`; + default: + throw new Error(`${aComponents}-component is not supported.`); + } + })(); + const processOneBlock = ` + for (var word: u32 = 0; word < ${blobSizeInWords}; word += ${bComponents}) { + ${b.indicesSet("b_indices", "2", "word")}; + let b_data = ${b.getByIndices("b_indices")}; + for (var i: u32 = 0; i < ${bComponents}; i++) { + let b_value: u32 = ${bComponents === 1 ? "b_data" : "b_data[word + i]"}; + let b_mask: u32 = 0x0F0F0F0Fu; + let b_value_lower: vec4 = unpack4xU8(b_value & b_mask); + let b_value_upper: vec4 = unpack4xU8((b_value >> 4) & b_mask); + let b_quantized_values = ${qDqDataType}(${Array.from({ length: 4 }, (_, i) => `${dataType2}(b_value_lower[${i}]), ${dataType2}(b_value_upper[${i}])`).join(", ")}); + let b_dequantized_values = ${(() => { + if (aComponents === 1) { + return `${qDqDataType}(${Array.from({ length: 8 }, (_, i) => `(b_quantized_values[${i}] - zero_point) * scale`).join(", ")});`; + } else { + return `(b_quantized_values - ${qDqDataType}(${Array(8).fill("zero_point").join(",")})) * scale;`; + } + })()}; + // Number of B elements per 32-bit word is 32/bits = 32/4 = 8 + for (var m: u32 = 0; m < ${useBlockwiseMatMulNBits ? dimAOuter : outputNumber}u; m++) { + ${a.indicesSet("a_indices", inputRank - 2, useBlockwiseMatMulNBits ? "m" : `row * ${outputNumber} + m`)}; + ${a.indicesSet("a_indices", inputRank - 1, "word_offset")}; + var input_offset = ${a.indicesToOffset("a_indices")}; + var a_data: ${qDqDataType}; + for (var j: u32 = 0; j < ${8 / aComponents}; j++) { + a_data[j] = ${a.getByOffset("input_offset")}; + input_offset++; + } + ${useBlockwiseMatMulNBits ? "workgroup_shared[workgroup_shared_offset + m]" : "output_values[m]"}${components > 1 ? "[c]" : ""} += ${Array.from( + { length: 8 / aComponents }, + (_, i) => `${aComponents === 1 ? `a_data[${i}] * b_dequantized_values[${i}]` : `dot(a_data[${i}], b_dequantized_values[${i}])`}` + ).join(" + ")}; + } + word_offset += ${8 / aComponents}; + } + }`; + const updateZeroPointIndex = zeroPoints ? ` + zero_point_offset += 4; + if (zero_point_offset == 32) { + zero_point_offset = 0; + zero_point_index++; + zero_point_word = ${zeroPoints.getByOffset("zero_point_index")}; + }` : ""; + return useBlockwiseMatMulNBits ? ` + var workgroup_shared: array<${output.type.value}, ${dimAOuter * nBlocksPerCol}>; + ${shaderHelper.declareVariables(...inputVariables, output)} + ${shaderHelper.mainStart([ + nBlocksPerCol, + 1, + 1 + ])} + var a_indices: ${a.type.indices}; + var block = local_id.x; + var col = workgroup_id.y; + var batch = workgroup_id.z; + ${a.indicesSet("a_indices", "0", "batch")}; + // Two zero points are packed into one byte when uniforms.bits is 4. + for (var c: u32 = 0; c < ${components}; c++) { + let col_times_components_plus_c = col * ${components} + c; + ${zeroPoints ? ` + var zero_point_bytes_per_col: u32 = (${nBlocksPerCol} + 1) / 2; + var zero_point_byte_count: u32 = col_times_components_plus_c * zero_point_bytes_per_col + (block >> 0x1u); + var zero_point_word_index: u32 = zero_point_byte_count >> 0x2u; + var zero_point_byte_offset: u32 = zero_point_byte_count & 0x3u; + var zero_point_nibble_offset: u32 = block & 0x1u; + var zero_point_bits_offset: u32 = (zero_point_byte_offset << 3) + (zero_point_nibble_offset << 2); + var zero_point_word: u32 = ${zeroPoints.getByOffset("zero_point_word_index")} >> zero_point_bits_offset;` : ""} + var b_indices: ${b.type.indices}; + ${b.indicesSet("b_indices", "0", "col_times_components_plus_c")}; + // The scale and zero points are computed per block. + var scales_index = col_times_components_plus_c * ${nBlocksPerCol} + block; + let scale = ${scales.getByOffset("scales_index")}; + // The default zero point is 8 for unsigned 4-bit quantization. + let zero_point = ${dataType2}(${zeroPoints ? "(zero_point_word) & 0xFu" : 8}); + ${b.indicesSet("b_indices", "1", "block")}; + var word_offset: u32 = block * ${attributes.blockSize / aComponents}; + var workgroup_shared_offset: u32 = block * ${dimAOuter}; + ${processOneBlock} + } + workgroupBarrier(); + if (local_id.x == 0u) { + var output_indices: ${output.type.indices}; + ${output.indicesSet("output_indices", "0", "batch")}; + ${output.indicesSet("output_indices", outputRank - 1, "col")}; + ${output.indicesSet("output_indices", outputRank - 2, "0")}; + var output_offset = ${output.indicesToOffset("output_indices")}; + for (var m: u32 = 0u; m < ${dimAOuter}u; m++) { + var output_value: ${output.type.value} = ${output.type.value}(0); + var workgroup_shared_offset: u32 = m; + for (var b: u32 = 0u; b < ${nBlocksPerCol}u; b++) { + output_value += workgroup_shared[workgroup_shared_offset]; + workgroup_shared_offset += ${dimAOuter}; + } + ${output.setByOffset("output_offset", "output_value")}; + output_offset += ${dimBOuter / components}; + } + } + }` : ` + ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)} + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")} + var output_values: array<${output.type.value}, ${outputNumber}>; + var output_indices = ${output.offsetToIndices("global_idx")}; + var col = ${output.indicesGet("output_indices", outputRank - 1)}; + var row = ${output.indicesGet("output_indices", outputRank - 2)}; + var a_indices: ${a.type.indices} = output_indices; + // Two zero points are packed into one byte because uniforms.bits <= 4. + // zero_point_offset is either 0 or 4. It is bit offset within one byte. + // TODO support zero_point_offset for bits > 4 + ${zeroPoints ? ` + var zero_point_abs_offset = col * ${components} * ((${nBlocksPerCol} + 1) / 2); + var zero_point_index: u32 = zero_point_abs_offset / 4; + var zero_point_word: u32 = ${zeroPoints.getByOffset("zero_point_index")}; + var zero_point_offset: u32 = (zero_point_abs_offset % 4) * 8;` : ""} + var scale_index = col * ${nBlocksPerCol * components}; + var b_indices: ${b.type.indices}; + for (var c: u32 = 0; c < ${components}; c++) { + ${b.indicesSet("b_indices", "0", `col * ${components} + c`)}; + var block_offset: u32 = 0; + for (var block: u32 = 0; block < ${nBlocksPerCol}; block++) { + // The scale and zero points are computed per block. + let scale = ${scales.getByOffset("scale_index")}; + // The default zero point is 8 for unsigned 4-bit quantization. + let zero_point = ${dataType2}(${zeroPoints ? "extractBits(zero_point_word, zero_point_offset, 4)" : 8}); + ${b.indicesSet("b_indices", "1", "block")}; + var word_offset: u32 = block_offset; + ${processOneBlock} + scale_index++; + ${updateZeroPointIndex} + block_offset += uniforms.block_size / ${aComponents}; + } + // Drop the trailing 4 bits if the zero_poit_offset is not a byte boundary to align with the next byte. + ${zeroPoints ? `if (zero_point_offset % 8 > 0) { + ${updateZeroPointIndex} + }` : ""} + } + for (var k: u32 = 0u; k < ${outputNumber}u; k++) { + ${output.indicesSet("output_indices", outputRank - 2, `${outputNumber} * row + k`)}; + ${output.setByIndices("output_indices", "output_values[k]")} + } + }`; + }; + return { + name: useBlockwiseMatMulNBits ? "BlockwiseMatMulNBits" : "MatMulNBits", + shaderCache: { + hint: `${attributes.cacheKey};${dimAOuter};${dataType};${inputs.length}`, + inputDependencies: Array(inputs.length).fill("rank") + }, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType }], + name: useBlockwiseMatMulNBits ? "BlockwiseMatMulNBits" : "MatMulNBits", + dispatchGroup: useBlockwiseMatMulNBits ? { x: 1, y: Math.ceil(dimBOuter / components), z: batchSize } : { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms + }), + getShaderSource + }; + }; + matMulNBits = (context, attributes) => { + validateInputs17(context.inputs, attributes); + const maxComputeWorkgroupSizes = context.getMaxComputeWorkgroupSizes(); + const maxComputeWorkgroupStorageSize = context.getMaxComputeWorkgroupStoragesize(); + context.compute(createMatMulNBitsProgramInfo( + context.inputs, + attributes, + maxComputeWorkgroupSizes, + maxComputeWorkgroupStorageSize + )); + }; + parseMatMulNBitsAttributes = (attributes) => createAttributeWithCacheKey(attributes); + } +}); + +// web/lib/wasm/jsep/webgpu/ops/multihead-attentiion.ts +var getInput, validateInputs18, parseMultiHeadAttentionAttributes, weightTransposeAttribute2, addBiasTranspose, maybeTransposeToBNSHAndAddBias, multiHeadAttention; +var init_multihead_attentiion = __esm({ + "web/lib/wasm/jsep/webgpu/ops/multihead-attentiion.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_attribute_with_cache_key(); + init_types(); + init_attention(); + init_common(); + init_transpose(); + getInput = (inputs, i) => inputs.length > i && inputs[i].dims.length > 0 && ShapeUtil.size(inputs[i].dims) > 0 ? inputs[i] : void 0; + validateInputs18 = (inputs, attributes) => { + const query = inputs[0]; + const key = getInput(inputs, 1); + const value = getInput(inputs, 2); + const bias = getInput(inputs, 3); + const keyPaddingMask = getInput(inputs, 4); + const relativePositionBias = getInput(inputs, 5); + const pastKey = getInput(inputs, 6); + const pastValue = getInput(inputs, 7); + if (query.dims.length !== 3 && query.dims.length !== 5) { + throw new Error("Input query is expected to have 3 or 5 dimensions"); + } + const dmmhaPacking = false; + const batchSize = query.dims[0]; + const sequenceLength = query.dims[1]; + const hiddenSize = query.dims.length === 3 ? dmmhaPacking ? query.dims[2] / 3 : query.dims[2] : attributes.numHeads * query.dims[4]; + let kvSequenceLength = sequenceLength; + let pastSequenceLength = 0; + let maxSequenceLength = 0; + const headSize = Math.floor(hiddenSize / attributes.numHeads); + if (pastKey && pastValue) { + if (pastKey.dims.length !== 4) { + throw new Error('Input "past_key" is expected to have 4 dimensions'); + } + if (pastKey.dims[0] !== batchSize || pastKey.dims[1] !== attributes.numHeads || pastKey.dims[3] !== headSize) { + throw new Error('Input "past_key" shape (batch_size, num_heads, past_sequence_length, head_size)'); + } + if (pastValue.dims[0] !== batchSize || pastValue.dims[1] !== attributes.numHeads || pastValue.dims[3] !== headSize) { + throw new Error('Input "past_value" shape (batch_size, num_heads, past_sequence_length, head_size)'); + } + if (pastKey.dims[2] !== pastValue.dims[2]) { + throw new Error('Input "past_key" and "past_value" shall have same dim 2 (past_sequence_length)'); + } + if (pastValue.dims.length !== 4) { + throw new Error('Input "past_value" is expected to have 4 dimensions'); + } + pastSequenceLength = pastKey.dims[2]; + maxSequenceLength = pastKey.dims[2]; + } else if (pastKey || pastValue) { + throw new Error('Input "past_key" and "past_value" shall be both present or both absent'); + } + let qkvFormat; + if (key) { + if (query.dims.length !== 3) { + throw new Error('Input "query" is expected to have 3 dimensions when key is given'); + } + if (key.dims.length < 3 || key.dims.length > 5) { + throw new Error('Input "key" is expected to have 3, 4, or 5 dimensions'); + } + if (query.dims[0] !== key.dims[0]) { + throw new Error('Input "query" and "key" shall have same dim 0 (batch size)'); + } + if (key.dims.length === 3) { + if (key.dims[2] !== query.dims[2]) { + throw new Error('Input "query" and "key" shall have same dim 2 (hidden_size)'); + } + qkvFormat = 2 /* qkvBSNH */; + kvSequenceLength = key.dims[1]; + } else if (key.dims.length === 5) { + if (key.dims[2] !== attributes.numHeads || key.dims[3] !== 2 || key.dims[4] !== headSize) { + throw new Error('Expect "key" shape (batch_size, kv_sequence_length, num_heads, 2, head_size) for packed kv'); + } + if (value) { + throw new Error('Expect "value" be none when "key" has packed kv format.'); + } + qkvFormat = 5 /* qKvBSNHxBSN2H */; + kvSequenceLength = key.dims[1]; + } else { + if (key.dims[1] !== attributes.numHeads || key.dims[3] !== headSize) { + throw new Error('Expect "key" shape (batch_size, num_heads, kv_sequence_length, head_size) for past_key'); + } + qkvFormat = 0 /* unknown */; + kvSequenceLength = key.dims[2]; + } + } else { + if (query.dims.length !== 3 && query.dims.length !== 5) { + throw new Error('Input "query" is expected to have 3 or 5 dimensions when key is empty'); + } + if (query.dims.length === 5 && (query.dims[2] !== attributes.numHeads || query.dims[3] !== 3)) { + throw new Error('Expect "query" shape (batch_size, kv_sequence_length, num_heads, 3, head_size) for packed kv'); + } + qkvFormat = 3 /* qkvBSN3H */; + } + if (bias) { + if (bias.dims.length !== 1) { + throw new Error('Input "bias" is expected to have 1 dimension'); + } + if (value) { + if (query.dims.length === 5 && query.dims[3] === 2) { + throw new Error("bias is not allowed for packed kv."); + } + } + } + let maskType = 0 /* none */; + if (keyPaddingMask) { + maskType = 8 /* maskUnknown */; + const maskDims = keyPaddingMask.dims; + if (maskDims.length === 1) { + if (maskDims[0] === batchSize) { + maskType = 1 /* mask1dKeySeqLen */; + } else if (maskDims[0] === 3 * batchSize + 2) { + maskType = 3 /* mask1DKeySeqLenStart */; + } + } else if (maskDims.length === 2 && maskDims[0] === batchSize && maskDims[1] === kvSequenceLength) { + maskType = 5 /* mask2dKeyPadding */; + } + if (maskType === 8 /* maskUnknown */) { + throw new Error('Input "key_padding_mask" shape shall be (batch_size) or (batch_size, kv_sequence_length)'); + } + throw new Error("Mask not supported"); + } + let passPastInKv = false; + let vHiddenSize = hiddenSize; + if (value) { + if (value.dims.length !== 3 && value.dims.length !== 4) { + throw new Error('Input "value" is expected to have 3 or 4 dimensions'); + } + if (query.dims[0] !== value.dims[0]) { + throw new Error('Input "query" and "value" shall have same dim 0 (batch_size)'); + } + if (value.dims.length === 3) { + if (kvSequenceLength !== value.dims[1]) { + throw new Error('Input "key" and "value" shall have the same dim 1 (kv_sequence_length)'); + } + vHiddenSize = value.dims[2]; + } else { + if (kvSequenceLength !== value.dims[2]) { + throw new Error('Input "past_key" and "past_value" shall have the same dim 2 (kv_sequence_length)'); + } + vHiddenSize = value.dims[1] * value.dims[3]; + passPastInKv = true; + } + } + const totalSequenceLength = pastSequenceLength + kvSequenceLength; + const broadcastResPosBias = false; + if (keyPaddingMask) { + throw new Error("Key padding mask is not supported"); + } + if (relativePositionBias) { + if (relativePositionBias.dims.length !== 4) { + throw new Error('Input "relative_position_bias" is expected to have 4 dimensions'); + } + if (relativePositionBias.dims[0] !== batchSize && relativePositionBias.dims[0] !== 1 || relativePositionBias.dims[1] !== attributes.numHeads || relativePositionBias.dims[2] !== sequenceLength || relativePositionBias.dims[3] !== totalSequenceLength) { + throw new Error('Input "relative_position_bias" shape (batch_size, 1, sequence_length, kv_sequence_length)'); + } + } + return { + batchSize, + sequenceLength, + pastSequenceLength, + kvSequenceLength, + totalSequenceLength, + maxSequenceLength, + inputHiddenSize: 0, + hiddenSize, + vHiddenSize, + headSize, + vHeadSize: Math.floor(vHiddenSize / attributes.numHeads), + numHeads: attributes.numHeads, + isUnidirectional: false, + pastPresentShareBuffer: false, + maskFilterValue: attributes.maskFilterValue, + maskType, + scale: attributes.scale, + broadcastResPosBias, + passPastInKv, + qkvFormat + }; + }; + parseMultiHeadAttentionAttributes = (attributes) => createAttributeWithCacheKey({ ...attributes }); + weightTransposeAttribute2 = createAttributeWithCacheKey({ perm: [0, 2, 1, 3] }); + addBiasTranspose = (context, qkv, bias, batchSize, sequenceLength, hiddenSize, biasOffset) => { + const outputShape = [batchSize, sequenceLength, hiddenSize]; + const outputSize = ShapeUtil.size(outputShape); + const programUniforms = [ + { type: 12 /* uint32 */, data: outputSize }, + { type: 12 /* uint32 */, data: biasOffset }, + { type: 12 /* uint32 */, data: hiddenSize } + ]; + const getShaderSource = (shaderHelper) => { + const output = outputVariable("qkv_with_bias", qkv.dataType, outputShape); + const qkvInput = inputVariable("qkv", qkv.dataType, outputShape); + const biasInput = inputVariable("bias", bias.dataType, outputShape); + const uniforms = [ + { name: "output_size", type: "u32" }, + { name: "bias_offset", type: "u32" }, + { name: "hidden_size", type: "u32" } + ]; + return ` + ${shaderHelper.registerUniforms(uniforms).declareVariables(qkvInput, biasInput, output)} + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")} + let bias_offset_idx = (global_idx % uniforms.hidden_size) + uniforms.bias_offset; + + qkv_with_bias[global_idx] = qkv[global_idx] + bias[bias_offset_idx]; + }`; + }; + return context.compute( + { + name: "MultiHeadAttentionAddBias", + shaderCache: { inputDependencies: ["type", "type"] }, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: qkv.dataType, gpuDataType: 0 /* default */ }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms + }), + getShaderSource + }, + { inputs: [qkv, bias], outputs: [-1] } + )[0]; + }; + maybeTransposeToBNSHAndAddBias = (context, batchSize, numHeads, sequenceLength, headSize, input, bias, biasOffset) => { + let reshapedInput = input; + if (!bias) { + if (input.dims.length === 3) { + reshapedInput = input.reshape([batchSize, sequenceLength, numHeads, headSize]); + } + return context.compute( + createTransposeProgramInfo(reshapedInput, weightTransposeAttribute2.perm), + { inputs: [reshapedInput], outputs: [-1] } + )[0]; + } else { + if (sequenceLength === 1) { + throw new Error("AddBiasReshape is not implemented. Please export your model with packed QKV or KV"); + } else { + reshapedInput = addBiasTranspose(context, input, bias, batchSize, sequenceLength, numHeads * headSize, biasOffset); + reshapedInput = reshapedInput.reshape([batchSize, sequenceLength, numHeads, headSize]); + return context.compute( + createTransposeProgramInfo(reshapedInput, weightTransposeAttribute2.perm), + { inputs: [reshapedInput], outputs: [-1] } + )[0]; + } + } + }; + multiHeadAttention = (context, attributes) => { + const params = validateInputs18(context.inputs, attributes); + const query = context.inputs[0]; + const key = getInput(context.inputs, 1); + const value = getInput(context.inputs, 2); + const bias = getInput(context.inputs, 3); + const keyPaddingMask = getInput(context.inputs, 4); + const relativePositionBias = getInput(context.inputs, 5); + const pastKey = getInput(context.inputs, 6); + const pastValue = getInput(context.inputs, 7); + if (query.dims.length === 5) { + throw new Error("Packed QKV is not implemented"); + } + if (key?.dims.length === 5) { + throw new Error("Packed KV is not implemented"); + } + const kvBNSH = key && value && key.dims.length === 4 && value.dims.length === 4; + const Q = maybeTransposeToBNSHAndAddBias( + context, + params.batchSize, + params.numHeads, + params.sequenceLength, + params.headSize, + query, + bias, + 0 + ); + if (kvBNSH) { + return applyAttention( + context, + Q, + key, + value, + keyPaddingMask, + void 0, + pastKey, + pastValue, + relativePositionBias, + params, + attributes + ); + } + if (!key || !value) { + throw new Error("key and value must be provided"); + } + const K = maybeTransposeToBNSHAndAddBias( + context, + params.batchSize, + params.numHeads, + params.kvSequenceLength, + params.headSize, + key, + bias, + params.hiddenSize + ); + const V = maybeTransposeToBNSHAndAddBias( + context, + params.batchSize, + params.numHeads, + params.kvSequenceLength, + params.vHeadSize, + value, + bias, + 2 * params.hiddenSize + ); + applyAttention( + context, + Q, + K, + V, + keyPaddingMask, + void 0, + pastKey, + pastValue, + relativePositionBias, + params, + attributes + ); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/pad.ts +var validateInputs19, getPadConstant, getPadReflect, getPadEdge, getPadWrap, getPadSnippet, createPadProgramInfo, createPadAttributesFromInputs, pad; +var init_pad = __esm({ + "web/lib/wasm/jsep/webgpu/ops/pad.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_common(); + validateInputs19 = (inputs) => { + if (!inputs || inputs.length < 1) { + throw new Error("Too few inputs"); + } + if (inputs[0].dataType !== 1 /* float */ && inputs[0].dataType !== 10 /* float16 */) { + throw new Error("Input type must be float or float16."); + } + if (inputs.length >= 2) { + let validPads = inputs[0].dims.length * 2 === inputs[1].dims[0]; + if (inputs.length === 4) { + validPads = inputs[3].dims[0] * 2 === inputs[1].dims[0]; + } + if (!validPads) { + throw new Error("The pads should be a 1D tensor of shape [2 * input_rank] or [2 * num_axes]."); + } + } + }; + getPadConstant = (output, inputRank, padsLength) => { + let block = ""; + for (let i = inputRank - 1; i >= 0; --i) { + block += ` + k = i32(${output.indicesGet("indices", i)}) - ${getElementAt("uniforms.pads", i, padsLength)}; + if (k < 0) { + break; + } + if (k >= i32(${getElementAt("uniforms.x_shape", i, inputRank)})) { + break; + } + offset += k * i32(${getElementAt("uniforms.x_strides", i, inputRank)}); + `; + } + return ` + value = ${output.type.value}(uniforms.constant_value); + for (var i = 0; i < 1; i++) { + var offset = 0; + var k = 0; + ${block} + value = x[offset]; + } + `; + }; + getPadReflect = (output, inputRank, padsLength) => { + let block = ""; + for (let i = inputRank - 1; i >= 0; --i) { + block += ` + k = i32(${output.indicesGet("indices", i)}) - ${getElementAt("uniforms.pads", i, padsLength)}; + if (k < 0) { + k = -k; + } + { + let _2n_1 = 2 * (i32(${getElementAt("uniforms.x_shape", i, inputRank)}) - 1); + k = k % _2n_1; + if(k >= i32(${getElementAt("uniforms.x_shape", i, inputRank)})) { + k = _2n_1 - k; + } + } + offset += k * i32(${getElementAt("uniforms.x_strides", i, inputRank)}); + `; + } + return ` + var offset = 0; + var k = 0; + ${block} + value = x[offset]; + `; + }; + getPadEdge = (output, inputRank, padsLength) => { + let block = ""; + for (let i = inputRank - 1; i >= 0; --i) { + block += ` + k = i32(${output.indicesGet("indices", i)}) - ${getElementAt("uniforms.pads", i, padsLength)}; + if (k < 0) { + k = 0; + } + if (k >= i32(${getElementAt("uniforms.x_shape", i, inputRank)})) { + k = i32(${getElementAt("uniforms.x_shape", i, inputRank)}) - 1; + } + offset += k * i32(${getElementAt("uniforms.x_strides", i, inputRank)}); + `; + } + return ` + var offset = 0; + var k = 0; + ${block} + value = x[offset]; + `; + }; + getPadWrap = (output, inputRank, padsLength) => { + let block = ""; + for (let i = inputRank - 1; i >= 0; --i) { + block += ` + k = i32(${output.indicesGet("indices", i)}) - ${getElementAt("uniforms.pads", i, padsLength)}; + if (k < 0) { + k += i32(${getElementAt("uniforms.x_shape", i, inputRank)}]); + } + if (k >= i32(${getElementAt("uniforms.x_shape", i, inputRank)})) { + k -= i32(${getElementAt("uniforms.x_shape", i, inputRank)}); + } + offset += k * i32(${getElementAt("uniforms.x_strides", i, inputRank)}); + `; + } + return ` + var offset = 0; + var k = 0; + ${block} + value = x[offset]; + `; + }; + getPadSnippet = (output, inputRank, attributes) => { + switch (attributes.mode) { + case 0: + return getPadConstant(output, inputRank, attributes.pads.length); + case 1: + return getPadReflect(output, inputRank, attributes.pads.length); + case 2: + return getPadEdge(output, inputRank, attributes.pads.length); + case 3: + return getPadWrap(output, inputRank, attributes.pads.length); + default: + throw new Error("Invalid mode"); + } + }; + createPadProgramInfo = (inputs, attributes) => { + const outputShape = ShapeUtil.padShape(inputs[0].dims.slice(), attributes.pads); + const inputDims = inputs[0].dims; + const outputSize = ShapeUtil.size(outputShape); + const programUniforms = [{ type: 12 /* uint32 */, data: outputSize }, { type: 6 /* int32 */, data: attributes.pads }]; + if (attributes.mode === 0) { + programUniforms.push({ type: inputs[0].dataType, data: attributes.value }); + } + programUniforms.push(...createTensorShapeVariables(inputs[0].dims, outputShape)); + const inputDependencies = ["rank"]; + const getShaderSource = (shaderHelper) => { + const output = outputVariable("output", inputs[0].dataType, outputShape.length); + const input = inputVariable("x", inputs[0].dataType, inputDims.length); + const dataType = input.type.value; + const padSnippet = getPadSnippet(output, inputDims.length, attributes); + const uniforms = [{ name: "output_size", type: "u32" }, { name: "pads", type: "i32", length: attributes.pads.length }]; + if (attributes.mode === 0) { + uniforms.push({ name: "constant_value", type: dataType }); + } + return ` + ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)} + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")} + + let indices = ${output.offsetToIndices("global_idx")}; + + var value = ${dataType}(0); + ${padSnippet} + output[global_idx] = value; + }`; + }; + return { + name: "Pad", + shaderCache: { hint: `${attributes.mode}`, inputDependencies }, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: inputs[0].dataType }], + dispatchGroup: { x: Math.ceil( + ShapeUtil.size(outputShape) / 64 + /* workgroup size */ + ) }, + programUniforms + }), + getShaderSource + }; + }; + createPadAttributesFromInputs = (inputs, attributes) => { + if (inputs.length > 1) { + const bigInt64Pads = inputs[1].getBigInt64Array(); + const value = inputs.length >= 3 && inputs[2].data ? inputs[2].getFloat32Array()[0] : 0; + const inputRank = inputs[0].dims.length; + const updatePads = new Int32Array(2 * inputRank).fill(0); + if (inputs.length >= 4) { + const axes = inputs[3].getBigInt64Array(); + for (let i = 0; i < axes.length; i++) { + updatePads[Number(axes[i])] = Number(bigInt64Pads[i]); + updatePads[Number(axes[i]) + inputRank] = Number(bigInt64Pads[i + axes.length]); + } + } else { + bigInt64Pads.forEach((v, i) => updatePads[Number(i)] = Number(v)); + } + const pads = []; + updatePads.forEach((v) => pads.push(v)); + return { mode: attributes.mode, value, pads }; + } else { + return attributes; + } + }; + pad = (context, attributes) => { + validateInputs19(context.inputs); + const updatedAttributes = createPadAttributesFromInputs(context.inputs, attributes); + context.compute(createPadProgramInfo(context.inputs, updatedAttributes), { inputs: [0] }); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/pool.ts +var validateInputs20, getAdjustedPoolAttributesAndOutputShape, getUniformAndPadInfo, generatePoolingCode, createShaderKeyFromAttributes, createAveragePoolShaderKeyFromAttributes, createMaxPoolShaderKeyFromAttributes, parsePoolCommonAttributes, createAveragePoolProgramInfo, parseAveragePoolAttributes, averagePool, globalPoolAttributes, parseGlobalAveragePoolAttributes, globalAveragePool, createMaxPoolProgramInfo, maxPool, parseMaxPoolAttributes, parseGlobalMaxPoolAttributes, globalMaxPool; +var init_pool = __esm({ + "web/lib/wasm/jsep/webgpu/ops/pool.ts"() { + "use strict"; + init_esm(); + init_wasm_common(); + init_util(); + init_common(); + validateInputs20 = (inputs) => { + if (env2.webgpu.validateInputContent && (!inputs || inputs.length !== 1)) { + throw new Error("Pool ops requires 1 input."); + } + }; + getAdjustedPoolAttributesAndOutputShape = (input, attributes, isGlobalOperator) => { + const isChannelsLast = attributes.format === "NHWC"; + const inputShapeAsChannelFirst = input.dims.slice(); + if (isChannelsLast) { + inputShapeAsChannelFirst.splice(1, 0, inputShapeAsChannelFirst.pop()); + } + const hasDilations = Object.hasOwnProperty.call(attributes, "dilations"); + const kernelShape = attributes.kernelShape.slice(); + const strides = attributes.strides.slice(); + const dilations = hasDilations ? attributes.dilations.slice() : []; + const pads = attributes.pads.slice(); + PoolConvUtil.adjustPoolAttributes(isGlobalOperator, inputShapeAsChannelFirst, kernelShape, strides, dilations, pads); + const outputShapeAsChannelFirst = PoolConvUtil.computePoolOutputShape( + isGlobalOperator, + inputShapeAsChannelFirst, + strides, + dilations, + kernelShape, + pads, + attributes.autoPad + ); + const newAttributes = Object.assign({}, attributes); + if (hasDilations) { + Object.assign(newAttributes, { kernelShape, strides, pads, dilations, cacheKey: attributes.cacheKey }); + } else { + Object.assign(newAttributes, { kernelShape, strides, pads, cacheKey: attributes.cacheKey }); + } + const outputShapeAsChannelLast = outputShapeAsChannelFirst.slice(); + outputShapeAsChannelLast.push(outputShapeAsChannelLast.splice(1, 1)[0]); + return [newAttributes, isChannelsLast ? outputShapeAsChannelLast : outputShapeAsChannelFirst]; + }; + getUniformAndPadInfo = (outputShape, attributes) => { + const isChannelsLast = attributes.format === "NHWC"; + const outputSize = ShapeUtil.size(outputShape); + const kernelSize = ShapeUtil.size(attributes.kernelShape); + const programUniforms = [{ type: 12 /* uint32 */, data: outputSize }, { type: 12 /* uint32 */, data: kernelSize }]; + const uniforms = [{ name: "outputSize", type: "u32" }, { name: "kernelSize", type: "u32" }]; + if (attributes.kernelShape.length <= 2) { + const kw = attributes.kernelShape[attributes.kernelShape.length - 1]; + const sw = attributes.strides[attributes.strides.length - 1]; + const pwStart = attributes.pads[attributes.pads.length / 2 - 1]; + const pwEnd = attributes.pads[attributes.pads.length - 1]; + const pwStartEndNotZero = !!(pwStart + pwEnd); + programUniforms.push( + { type: 12 /* uint32 */, data: kw }, + { type: 12 /* uint32 */, data: sw }, + { type: 12 /* uint32 */, data: pwStart }, + { type: 12 /* uint32 */, data: pwEnd } + ); + uniforms.push( + { name: "kw", type: "u32" }, + { name: "sw", type: "u32" }, + { name: "pwStart", type: "u32" }, + { name: "pwEnd", type: "u32" } + ); + let phStartEndNotZero = false; + if (attributes.kernelShape.length === 2) { + const kh = attributes.kernelShape[attributes.kernelShape.length - 2]; + const sh = attributes.strides[attributes.strides.length - 2]; + const phStart = attributes.pads[attributes.pads.length / 2 - 2]; + const phEnd = attributes.pads[attributes.pads.length - 2]; + phStartEndNotZero = !!(phStart + phEnd); + programUniforms.push( + { type: 12 /* uint32 */, data: kh }, + { type: 12 /* uint32 */, data: sh }, + { type: 12 /* uint32 */, data: phStart }, + { type: 12 /* uint32 */, data: phEnd } + ); + uniforms.push( + { name: "kh", type: "u32" }, + { name: "sh", type: "u32" }, + { name: "phStart", type: "u32" }, + { name: "phEnd", type: "u32" } + ); + } + return [programUniforms, uniforms, true, pwStartEndNotZero, phStartEndNotZero]; + } else { + if (isChannelsLast) { + throw new Error("Pooling with kernelShape.length > 2 is not supported for NHWC format."); + } + const kernelStrides = ShapeUtil.computeStrides(attributes.kernelShape); + programUniforms.push( + { type: 12 /* uint32 */, data: kernelStrides }, + { type: 12 /* uint32 */, data: attributes.pads }, + { type: 12 /* uint32 */, data: attributes.strides } + ); + uniforms.push( + { name: "kernelStrides", type: "u32", length: kernelStrides.length }, + { name: "pads", type: "u32", length: attributes.pads.length }, + { name: "strides", type: "u32", length: attributes.strides.length } + ); + const hasPads = attributes.pads.reduce((sum, cur) => sum + cur); + return [programUniforms, uniforms, !!hasPads, false, false]; + } + }; + generatePoolingCode = (shaderHelper, x, rank, outputShapeRank, attributes, op1, op2, start, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero) => { + const isChannelsLast = attributes.format === "NHWC"; + const dataType = x.type.value; + const output = outputVariable("output", x.type.tensor, outputShapeRank); + if (attributes.kernelShape.length <= 2) { + let codeW = ""; + let codeH = ""; + let codeHEnd = ""; + const dimIdxW = rank - (isChannelsLast ? 2 : 1); + if (pwStartEndNotZero) { + codeW = ` + for (var i: u32 = 0u; i < uniforms.kw; i++) { + xIndices[${dimIdxW}] = indices[${dimIdxW}] * uniforms.sw - uniforms.pwStart + i; + if (xIndices[${dimIdxW}] < 0 || xIndices[${dimIdxW}] + >= uniforms.x_shape[${dimIdxW}]) { + pad++; + continue; + } + let x_val = x[${x.indicesToOffset("xIndices")}]; + ${op1} + }`; + } else { + codeW = ` + for (var i: u32 = 0u; i < uniforms.kw; i++) { + xIndices[${dimIdxW}] = indices[${dimIdxW}] * uniforms.sw - uniforms.pwStart + i; + let x_val = x[${x.indicesToOffset("xIndices")}]; + ${op1} + }`; + } + if (attributes.kernelShape.length === 2) { + const dimIdxH = rank - (isChannelsLast ? 3 : 2); + if (phStartEndNotZero) { + codeH = ` + for (var j: u32 = 0u; j < uniforms.kh; j++) { + xIndices[${dimIdxH}] = indices[${dimIdxH}] * uniforms.sh - uniforms.phStart + j; + if (xIndices[${dimIdxH}] < 0 || xIndices[${dimIdxH}] >= uniforms.x_shape[${dimIdxH}]) { + pad += i32(uniforms.kw); + continue; + } + `; + } else { + codeH = ` + for (var j: u32 = 0u; j < uniforms.kh; j++) { + xIndices[${dimIdxH}] = indices[${dimIdxH}] * uniforms.sh - uniforms.phStart + j; + `; + } + codeHEnd = ` + } + `; + } + const poolingCode = ` + ${shaderHelper.registerUniforms(uniforms).declareVariables(x, output)} + + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")} + + let indices = ${output.offsetToIndices("global_idx")}; + var xIndices = ${output.offsetToIndices("global_idx")}; + + var value = ${dataType}(${start}); + var pad = 0; + ${codeH} + ${codeW} + ${codeHEnd} + ${op2} + + output[global_idx] = value; + }`; + return poolingCode; + } else { + if (isChannelsLast) { + throw new Error("Pooling with kernelShape.length > 2 is not supported for NHWC format."); + } + const stridesRank = attributes.kernelShape.length; + const padsRank = attributes.pads.length; + let padCode = ""; + if (hasPads) { + padCode = ` + if (xIndices[j] >= uniforms.x_shape[j]) { + pad++; + isPad = true; + break; + } + } + if (!isPad) { + let x_val = x[${x.indicesToOffset("xIndices")}]; + ${op1} + }`; + } else { + padCode = ` + } + let x_val = x[${x.indicesToOffset("xIndices")}]; + ${op1} + `; + } + const poolingCode = ` + ${shaderHelper.registerUniforms(uniforms).declareVariables(x, output)} + + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")} + let indices = ${output.offsetToIndices("global_idx")}; + var xIndices = ${output.offsetToIndices("global_idx")}; + + var offsets: array; + + var value = ${dataType}(${start}); + var pad = 0; + var isPad = false; + + for (var i: u32 = 0u; i < uniforms.kernelSize; i++) { + var offset = i; + for (var j = 0u; j < ${stridesRank - 1}u; j++) { + offsets[j] = offset / ${getElementAt("uniforms.kernelStrides", "j", stridesRank)}; + offset -= offsets[j] * ${getElementAt("uniforms.kernelStrides", "j", stridesRank)}; + } + offsets[${stridesRank - 1}] = offset; + + isPad = false; + for (var j = ${rank - stridesRank}u; j < ${rank}u; j++) { + xIndices[j] = indices[j] * ${getElementAt("uniforms.strides", `j - ${rank - stridesRank}u`, stridesRank)} + + offsets[j - ${rank - stridesRank}u] - ${getElementAt("uniforms.pads", "j - 2u", padsRank)}; + ${padCode} + } + ${op2} + + output[global_idx] = value; + }`; + return poolingCode; + } + }; + createShaderKeyFromAttributes = (attributes) => `${attributes.format};${attributes.ceilMode};${attributes.autoPad};${attributes.kernelShape.length}`; + createAveragePoolShaderKeyFromAttributes = (attributes) => `${createShaderKeyFromAttributes(attributes)};${attributes.countIncludePad}`; + createMaxPoolShaderKeyFromAttributes = (attributes) => `${createShaderKeyFromAttributes(attributes)};${attributes.storageOrder};${attributes.dilations}`; + parsePoolCommonAttributes = (attributes) => ({ + format: attributes.format, + autoPad: ["NOTSET", "VALID", "SAME_UPPER", "SAME_LOWER"][attributes.auto_pad], + ceilMode: attributes.ceil_mode, + kernelShape: attributes.kernel_shape, + strides: attributes.strides, + pads: attributes.pads + }); + createAveragePoolProgramInfo = (name, input, isGlobalOperator, attributes) => { + const [adjustedAttributes, outputShape] = getAdjustedPoolAttributesAndOutputShape(input, attributes, isGlobalOperator); + const x = inputVariable("x", input.dataType, input.dims.length); + const dataType = x.type.value; + const op1 = "value += x_val;"; + let op2 = ""; + if (adjustedAttributes.countIncludePad) { + op2 += `value /= ${dataType}(uniforms.kernelSize);`; + } else { + op2 += `value /= ${dataType}(i32(uniforms.kernelSize) - pad);`; + } + const [programUniforms, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero] = getUniformAndPadInfo(outputShape, adjustedAttributes); + programUniforms.push(...createTensorShapeVariables(input.dims, outputShape)); + const inputDependencies = ["rank"]; + return { + name, + shaderCache: { hint: `${attributes.cacheKey};${hasPads};${pwStartEndNotZero};${phStartEndNotZero}`, inputDependencies }, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: input.dataType }], + dispatchGroup: { x: Math.ceil( + ShapeUtil.size(outputShape) / 64 + /* workgroup size */ + ) }, + programUniforms + }), + getShaderSource: (shaderHelper) => generatePoolingCode( + shaderHelper, + x, + input.dims.length, + outputShape.length, + adjustedAttributes, + op1, + op2, + 0, + uniforms, + hasPads, + pwStartEndNotZero, + phStartEndNotZero + ) + }; + }; + parseAveragePoolAttributes = (attributes) => { + const countIncludePad = attributes.count_include_pad === 0 ? false : true; + const attr = parsePoolCommonAttributes(attributes); + if (attr.ceilMode !== 0) { + throw new Error("using ceil() in shape computation is not yet supported for AveragePool"); + } + const averagePoolAttributes = { countIncludePad, ...attr, cacheKey: "" }; + return { ...averagePoolAttributes, cacheKey: createAveragePoolShaderKeyFromAttributes(averagePoolAttributes) }; + }; + averagePool = (context, attributes) => { + validateInputs20(context.inputs); + context.compute(createAveragePoolProgramInfo("AveragePool", context.inputs[0], false, attributes)); + }; + globalPoolAttributes = { + autoPad: "", + ceilMode: 0, + countIncludePad: false, + kernelShape: [], + strides: [], + pads: [], + storageOrder: 0, + dilations: [] + }; + parseGlobalAveragePoolAttributes = (attributes) => { + const format = attributes.format; + return { format, ...globalPoolAttributes, cacheKey: format }; + }; + globalAveragePool = (context, attributes) => { + validateInputs20(context.inputs); + context.compute(createAveragePoolProgramInfo("GlobalAveragePool", context.inputs[0], true, attributes)); + }; + createMaxPoolProgramInfo = (name, input, isGlobalOperator, attributes) => { + const [adjustedAttributes, outputShape] = getAdjustedPoolAttributesAndOutputShape(input, attributes, isGlobalOperator); + const op1 = ` + value = max(x_val, value); + `; + const op2 = ""; + const x = inputVariable("x", input.dataType, input.dims.length); + const inputDependencies = ["rank"]; + const [programUniforms, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero] = getUniformAndPadInfo(outputShape, adjustedAttributes); + programUniforms.push(...createTensorShapeVariables(input.dims, outputShape)); + return { + name, + shaderCache: { hint: `${attributes.cacheKey};${hasPads};${pwStartEndNotZero};${phStartEndNotZero}`, inputDependencies }, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: input.dataType }], + dispatchGroup: { x: Math.ceil( + ShapeUtil.size(outputShape) / 64 + /* workgroup size */ + ) }, + programUniforms + }), + getShaderSource: (shaderHelper) => generatePoolingCode( + shaderHelper, + x, + input.dims.length, + outputShape.length, + adjustedAttributes, + op1, + op2, + input.dataType === 10 /* float16 */ ? -65504 : -1e5, + uniforms, + hasPads, + pwStartEndNotZero, + phStartEndNotZero + ) + }; + }; + maxPool = (context, attributes) => { + validateInputs20(context.inputs); + context.compute(createMaxPoolProgramInfo("MaxPool", context.inputs[0], false, attributes)); + }; + parseMaxPoolAttributes = (attributes) => { + const storageOrder = attributes.storage_order; + const dilations = attributes.dilations; + const attr = parsePoolCommonAttributes(attributes); + if (storageOrder !== 0) { + throw new Error("column major storage order is not yet supported for MaxPool"); + } + if (attr.ceilMode !== 0) { + throw new Error("using ceil() in shape computation is not yet supported for MaxPool"); + } + const maxPoolAttributes = { storageOrder, dilations, ...attr, cacheKey: "" }; + return { ...maxPoolAttributes, cacheKey: createMaxPoolShaderKeyFromAttributes(maxPoolAttributes) }; + }; + parseGlobalMaxPoolAttributes = (attributes) => { + const format = attributes.format; + return { format, ...globalPoolAttributes, cacheKey: format }; + }; + globalMaxPool = (context, attributes) => { + validateInputs20(context.inputs); + context.compute(createMaxPoolProgramInfo("GlobalMaxPool", context.inputs[0], true, attributes)); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/range.ts +var validateInputsContent, createRangeProgramInfo, range; +var init_range = __esm({ + "web/lib/wasm/jsep/webgpu/ops/range.ts"() { + "use strict"; + init_esm(); + init_wasm_common(); + init_common(); + validateInputsContent = (start, limit, delta) => { + const sameStartLimit = start === limit; + const increasingRangeNegativeStep = start < limit && delta < 0; + const decreasingRangePositiveStep = start > limit && delta > 0; + if (sameStartLimit || increasingRangeNegativeStep || decreasingRangePositiveStep) { + throw new Error("Range these inputs' contents are invalid."); + } + }; + createRangeProgramInfo = (start, limit, delta, dataType) => { + const numElements = Math.abs(Math.ceil((limit - start) / delta)); + const outputShape = [numElements]; + const outputSize = numElements; + const programUniforms = [ + { type: 12 /* uint32 */, data: outputSize }, + { type: dataType, data: start }, + { type: dataType, data: delta }, + ...createTensorShapeVariables(outputShape) + ]; + const getShaderSource = (shaderHelper) => { + const output = outputVariable("output", dataType, outputShape.length); + const wgslType = output.type.value; + const uniforms = [ + { name: "outputSize", type: "u32" }, + { name: "start", type: wgslType }, + { name: "delta", type: wgslType } + ]; + return ` + ${shaderHelper.registerUniforms(uniforms).declareVariables(output)} + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")} + output[global_idx] = uniforms.start + ${wgslType}(global_idx) * uniforms.delta; + }`; + }; + return { + name: "Range", + shaderCache: { hint: `${dataType}` }, + getShaderSource, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms + }) + }; + }; + range = (context) => { + let start = 0; + let limit = 0; + let delta = 0; + if (context.inputs[0].dataType === 6 /* int32 */) { + start = context.inputs[0].getInt32Array()[0]; + limit = context.inputs[1].getInt32Array()[0]; + delta = context.inputs[2].getInt32Array()[0]; + } else if (context.inputs[0].dataType === 1 /* float */) { + start = context.inputs[0].getFloat32Array()[0]; + limit = context.inputs[1].getFloat32Array()[0]; + delta = context.inputs[2].getFloat32Array()[0]; + } + if (env2.webgpu.validateInputContent) { + validateInputsContent(start, limit, delta); + } + context.compute(createRangeProgramInfo(start, limit, delta, context.inputs[0].dataType), { inputs: [] }); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/resize.ts +var validateScales, updateScales, validateInputs21, getOriginalCoordinateFromResizedCoordinate, getNearestPixelFromOriginal, updateRoI, initOutputShape, adjustOutputShape, calculateOriginalIndicesFromOutputIndices, calculateInputIndicesFromOutputIndices, checkInputIndices, setChannelAndBatchIndices, bilinearInterpolation, bicubicInterpolation, trilinearInterpolation, createResizeProgramInfo, getOpsetVersionFromCustomDataBuffer, resize, parseResizeAttributes; +var init_resize = __esm({ + "web/lib/wasm/jsep/webgpu/ops/resize.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_attribute_with_cache_key(); + init_common(); + validateScales = (scales, attributes) => { + scales.every((value) => value > 0 || (() => { + throw new Error("Resize requires scales input values to be positive"); + })); + if (scales.length > 0) { + if (attributes.mode === "linear") { + if (!(scales.length === 2 || scales.length === 3 || scales.length === 4 && scales[0] === 1 && scales[1] === 1 || scales.length === 4 && scales[0] === 1 && scales[3] === 1 || scales.length === 5 && scales[0] === 1 && scales[1] === 1)) { + throw new Error( + `For linear mode, Resize requires scales to be 2D, 3D, 4D with either two outermost or one innermost and + one outermost scale values equal to 1, or 5D with two outermost scale values equal to 1` + ); + } + } else if (attributes.mode === "cubic") { + if (!(scales.length === 2 || scales.length === 4 && scales[0] === 1 && scales[1] === 1 || scales.length === 4 && scales[0] === 1 && scales[3] === 1)) { + throw new Error("Resize requires scales input size to be 2 or 4 for cubic mode"); + } + } + } + }; + updateScales = (scales, axes, rank) => { + axes.every((value) => value >= 0 && value < rank || (() => { + throw new Error("Resize requires axes input values to be positive and less than rank"); + })); + const newScales = new Array(rank).fill(1); + axes.forEach((value, index) => newScales[value] = scales[index]); + return newScales; + }; + validateInputs21 = (inputs, attributes, opsetVersion, scales, sizes, roi) => { + const [roiInputIndex, scalesInputIndex, sizesInputIndex] = opsetVersion > 10 ? [1, 2, 3] : [-1, inputs.length > 1 ? 1 : -1, -1]; + const rank = inputs[0].dims.length; + if (roiInputIndex > 0 && inputs.length > roiInputIndex && inputs[roiInputIndex].dims.length > 0) { + inputs[roiInputIndex].getFloat32Array().forEach((value) => roi.push(value)); + } else if (attributes.coordinateTransformMode === "tf_crop_and_resize") { + throw new Error("Resize requires RoI input to be specified when coordinateTransformMode is tfCropAndResize"); + } + if (scalesInputIndex > 0 && inputs.length > scalesInputIndex && inputs[scalesInputIndex].dims.length > 0) { + inputs[scalesInputIndex].getFloat32Array().forEach((value) => scales.push(value)); + if (scales.length !== 0 && (scales.length !== rank && (opsetVersion >= 18 && scales.length !== attributes.axes.length))) { + throw new Error( + "Resize requires scales input size to be same as input rank or axes size for opset 18 and up" + ); + } + validateScales(scales, attributes); + if (attributes.axes.length > 0) { + updateScales(scales, attributes.axes, rank).forEach((value, index) => scales[index] = value); + } + } + if (sizesInputIndex > 0 && inputs.length > sizesInputIndex) { + inputs[sizesInputIndex].getBigInt64Array().forEach((value) => sizes.push(Number(value))); + if (sizes.length !== rank || opsetVersion >= 18 && sizes.length === attributes.axes.length) { + throw new Error("Resize requires sizes input size to be same as input rank or axes size for opset 18 and up"); + } + } + if (attributes.axes.length > 0) { + if (scales.length !== attributes.axes.length) { + throw new Error('Resize requires "scales" input size to be of axes rank when axes attributes is specified'); + } + if (sizes.length !== attributes.axes.length) { + throw new Error( + 'Resize requires "sizes" input size to be of rank axes rank when axes attributes is specified' + ); + } + } + if (typeof scales !== "undefined" && typeof sizes !== "undefined" && scales.length > 0 && sizes.length > rank) { + throw new Error("Resize requires only of scales or sizes to be specified"); + } + }; + getOriginalCoordinateFromResizedCoordinate = (coordinateTransferMode, dType) => `fn getOriginalCoordinateFromResizedCoordinate(xResized: u32, xScale: f32, lengthResized: u32, + lengthOriginal: u32, roiStart: f32, roiEnd: f32) -> ${dType} { ` + (() => { + switch (coordinateTransferMode) { + case "asymmetric": + return `return ${dType}(xResized) / ${dType}(xScale);`; + case "pytorch_half_pixel": + return `if (lengthResized > 1) { + return (${dType}(xResized) + 0.5) / ${dType}(xScale) - 0.5; + } else { + return 0.0; + }`; + case "tf_half_pixel_for_nn": + return `return (${dType}(xResized) + 0.5) / ${dType}(xScale);`; + case "align_corners": + return `if (lengthResized == 1) { + return 0.0; + } else { + // The whole part and the fractional part are calculated separately due to inaccuracy of floating + // point division. As an example, f32(21) / f32(7) may evaluate to 2.99... instead of 3, causing an + // offset-by-one error later in floor(). + let whole = ${dType}(xResized * (lengthOriginal - 1) / (lengthResized - 1)); + let fract = + ${dType}(xResized * (lengthOriginal - 1) % (lengthResized - 1)) / ${dType}(lengthResized - 1); + return whole + fract; + }`; + case "tf_crop_and_resize": + return `if (lengthResized > 1) { + return ${dType}(roiStart) * ${dType}(lengthOriginal - 1) + + (${dType}(xResized) * ${dType}(roiEnd - roiStart) * ${dType}(lengthOriginal - 1)) / + ${dType}(lengthResized - 1); + } else { + return 0.5 * ${dType}(roiStart + roiEnd) * ${dType}(lengthOriginal - 1); + }`; + case "half_pixel_symmetric": + return `const outputWidth = ${dType}xScale * ${dType}(lengthResized); + const adjustment = ${dType}(lengthResized) / outputWidth; + const center = ${dType}(lengthOriginal) / 2; + const offset = center * (1 - adjustment); + return offset + ((${dType}(xResized) + 0.5) / ${dType}(xScale)) - 0.5;`; + case "half_pixel": + return `return ((${dType}(xResized) + 0.5) / ${dType}(xScale)) - 0.5;`; + default: + throw new Error(`Coordinate transform mode ${coordinateTransferMode} is not supported`); + } + })() + "}"; + getNearestPixelFromOriginal = (nearestMode, opsetVersion, dType) => `fn getNearestPixelFromOriginal(xOriginal: ${dType}, isDownSample: bool) -> ${dType} {` + (() => { + switch (nearestMode) { + case "round_prefer_ceil": + return "if (fract(xOriginal) == 0.5) { return ceil(xOriginal); } else { return round(xOriginal); }"; + case "floor": + return "return floor(xOriginal);"; + case "ceil": + return "return ceil(xOriginal);"; + case "round_prefer_floor": + return "if (fract(xOriginal) == 0.5) { return floor(xOriginal); } else { return round(xOriginal); }"; + case "simple": + default: + if (opsetVersion < 11) { + return "if (isDownSample) { return ceil(xOriginal); } else { return xOriginal; }"; + } + throw new Error(`Nearest mode ${nearestMode} is not supported`); + } + })() + "}"; + updateRoI = (roi, axes, rank) => { + const roiTmp = new Array(rank).fill(0).concat(new Array(rank).fill(1)); + const roiLocal = roi.length === 0 ? roiTmp : roi.slice(); + if (axes.length > 0) { + axes.forEach((v, i) => { + roiTmp[v] = roiLocal[i]; + roiTmp[i + rank] = roiLocal[axes.length + i]; + }); + return roiTmp; + } + return roiLocal; + }; + initOutputShape = (inputShape, scales, sizes, axes) => { + let outputShape = []; + if (sizes.length > 0) { + if (axes.length > 0) { + inputShape.forEach((v) => outputShape.push(v)); + if (Math.max(...axes) > inputShape.length) { + throw new Error("axes is out of bound"); + } + axes.forEach((v, i) => outputShape[v] = sizes[i]); + } else { + sizes.forEach((v) => outputShape.push(v)); + } + } else { + if (scales.length === 0) { + throw new Error("Resize requires either scales or sizes."); + } else { + outputShape = inputShape.map((value, index) => Math.round(value * scales[index])); + } + } + return outputShape; + }; + adjustOutputShape = (inputShape, scales, attributes) => { + const scaleInPolicy = (() => { + switch (attributes.keepAspectRatioPolicy) { + case "not_larger": + return attributes.axes.length > 0 ? Math.min(...attributes.axes.map((i) => scales[i]), Number.MAX_VALUE) : Math.min(...scales, Number.MAX_VALUE); + case "not_smaller": + return attributes.axes.length > 0 ? Math.max(...attributes.axes.map((i) => scales[i]), Number.MIN_VALUE) : Math.max(...scales, Number.MIN_VALUE); + default: + throw new Error(`Keep aspect ratio policy ${attributes.keepAspectRatioPolicy} is not supported`); + } + })(); + scales.fill(1, 0, scales.length); + const adjustedOutputShape = inputShape.slice(); + if (attributes.axes.length > 0) { + attributes.axes.forEach((v) => scales[v] = scaleInPolicy); + attributes.axes.forEach((v) => adjustedOutputShape[v] = Math.round(inputShape[v] * scales[v])); + } else { + scales.fill(scaleInPolicy, 0, scales.length); + adjustedOutputShape.forEach((v, i) => adjustedOutputShape[i] = Math.round(v * scales[i])); + } + return adjustedOutputShape; + }; + calculateOriginalIndicesFromOutputIndices = (output, inputShape, outputShape, scalesLength, roiLength) => ` + fn calculateOriginalIndicesFromOutputIndices(output_indices: ${output.type.indices}) -> array<${output.type.value}, ${outputShape.length}> { + var original_indices: array<${output.type.value}, ${outputShape.length}>; + for (var i:u32 = 0; i < ${outputShape.length}; i++) { + var output_index = ${output.indicesGet("output_indices", "i")}; + var scale = ${getElementAt("uniforms.scales", "i", scalesLength)}; + var roi_low = ${getElementAt("uniforms.roi", "i", roiLength)}; + var roi_hi = ${getElementAt("uniforms.roi", `i + ${inputShape.length}`, roiLength)}; + if (scale == 1.0) { + original_indices[i] = ${output.type.value}(output_index); + } else { + var input_shape_i = ${getElementAt("uniforms.input_shape", "i", inputShape.length)}; + var output_shape_i = ${getElementAt("uniforms.output_shape", "i", outputShape.length)}; + original_indices[i] = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i, + input_shape_i, roi_low, roi_hi); + } + } + return original_indices; + }`; + calculateInputIndicesFromOutputIndices = (input, output, inputShape, outputShape, scalesLength, roiLength, useExtrapolation) => ` + fn calculateInputIndicesFromOutputIndices(output_indices: ${output.type.indices}) -> ${input.type.indices} { + var input_indices: ${input.type.indices}; + for (var i:u32 = 0; i < ${outputShape.length}; i++) { + var output_index = ${output.indicesGet("output_indices", "i")}; + var input_index: u32; + var scale = ${getElementAt("uniforms.scales", "i", scalesLength)}; + if (scale == 1.0) { + input_index = output_index; + } else { + var roi_low = ${getElementAt("uniforms.roi", "i", roiLength)}; + var roi_hi = ${getElementAt("uniforms.roi", `i + ${inputShape.length}`, roiLength)}; + var input_shape_i = ${getElementAt("uniforms.input_shape", "i", inputShape.length)}; + var output_shape_i = ${getElementAt("uniforms.output_shape", "i", outputShape.length)}; + var original_idx = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i, + input_shape_i, roi_low, roi_hi); + if (!${useExtrapolation} || (original_idx >= 0 && original_idx < ${output.type.value}(input_shape_i))) { + if (original_idx < 0) { + input_index = 0; + } else if (original_idx > ${output.type.value}(input_shape_i - 1)) { + input_index = input_shape_i - 1; + } else { + input_index = u32(getNearestPixelFromOriginal(original_idx, scale < 1)); + } + } else { + input_index = u32(original_idx); + } + } + ${input.indicesSet("input_indices", "i", " input_index")} + } + return input_indices; + }`; + checkInputIndices = (input, inputShape) => ` + fn checkInputIndices(input_indices: ${input.type.indices}) -> bool { + for (var i:u32 = 0; i < ${inputShape.length}; i++) { + var input_index = ${input.indicesGet("input_indices", "i")}; + if (input_index < 0 || input_index >= ${getElementAt("uniforms.input_shape", "i", inputShape.length)}) { + return false; + } + } + return true; + }`; + setChannelAndBatchIndices = (input, channelIdx, batchIdx, spacialDims) => input.rank > spacialDims ? ` + ${input.indicesSet("input_indices", channelIdx, "channel")}; + ${input.indicesSet("input_indices", batchIdx, "batch")}; +` : ""; + bilinearInterpolation = (input, output, inputShape, useExtrapolation, extrapolationValue) => { + const isNchw = true; + const [batchIdx, heightIdx, widthIdx, channelIdx] = inputShape.length === 2 ? [-1, 0, 1, -1] : isNchw ? [0, 2, 3, 1] : [0, 1, 2, 3]; + const dType = input.type.value; + return ` + fn getInputValue(batch: u32, channel: u32, row: u32, col: u32) -> ${dType} { + var input_indices: ${input.type.indices}; + ${input.indicesSet("input_indices", heightIdx, `max(0, min(row, ${inputShape[heightIdx]} - 1))`)}; + ${input.indicesSet("input_indices", widthIdx, `max(0, min(col, ${inputShape[widthIdx]} - 1))`)}; + ${setChannelAndBatchIndices(input, channelIdx, batchIdx, 2)} + return ${input.getByIndices("input_indices")}; + } + + fn bilinearInterpolation(output_indices: ${output.type.indices}) -> ${dType} { + var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices); + var row:${dType} = originalIndices[${heightIdx}]; + var col:${dType} = originalIndices[${widthIdx}]; + ${useExtrapolation ? `if (row < 0 || row > (${inputShape[heightIdx]} - 1) || col < 0 || col > (${inputShape[widthIdx]} - 1)) { + return ${extrapolationValue}; + }` : ""}; + row = max(0, min(row, ${inputShape[heightIdx]} - 1)); + col = max(0, min(col, ${inputShape[widthIdx]} - 1)); + var row1: u32 = u32(row); + var col1: u32 = u32(col); + var row2: u32 = u32(row + 1); + var col2: u32 = u32(col + 1); + var channel: u32 = ${inputShape.length > 2 ? `u32(originalIndices[${channelIdx}])` : "0"}; + var batch: u32 = ${inputShape.length > 2 ? `u32(originalIndices[${batchIdx}])` : "0"}; + var x11: ${dType} = getInputValue(batch, channel, row1, col1); + var x12: ${dType} = getInputValue(batch, channel, row1, col2); + var x21: ${dType} = getInputValue(batch, channel, row2, col1); + var x22: ${dType} = getInputValue(batch, channel, row2, col2); + var dx1: ${dType} = abs(row - ${dType}(row1)); + var dx2: ${dType} = abs(${dType}(row2) - row); + var dy1: ${dType} = abs(col - ${dType}(col1)); + var dy2: ${dType} = abs(${dType}(col2) - col); + if (row1 == row2) { + dx1 = 0.5; + dx2 = 0.5; + } + if (col1 == col2) { + dy1 = 0.5; + dy2 = 0.5; + } + return (x11 * dx2 * dy2 + x12 * dx2 * dy1 + x21 * dx1 * dy2 + x22 * dx1 * dy1); + }`; + }; + bicubicInterpolation = (input, output, inputShape, outputShape, scales, roi, cubicCoeffA, useExtrapolation, extrapolationValue, excludeOutside) => { + const is2D = inputShape.length === 2; + const isNchw = true; + const [heightIdx, widthIdx] = is2D ? [0, 1] : isNchw ? [2, 3] : [1, 2]; + const dType = input.type.value; + const createCubicInterpolationFunction = (idx) => { + const direction = idx === heightIdx ? "row" : "col"; + return ` + fn ${direction}CubicInterpolation(input_indices: ${input.type.indices}, output_indices: ${output.type.indices}) -> ${dType} { + var output_index = ${output.indicesGet("output_indices", idx)}; + var originalIdx: ${dType} = getOriginalCoordinateFromResizedCoordinate(output_index, ${scales[idx]}, + ${outputShape[idx]}, ${inputShape[idx]}, ${roi[idx]}, ${roi[idx]} + ${inputShape.length}); + var fractOriginalIdx: ${dType} = originalIdx - floor(originalIdx); + var coefs = getCubicInterpolationCoefs(fractOriginalIdx); + + if (${useExtrapolation} && (originalIdx < 0 || originalIdx > (${inputShape[idx]} - 1))) { + return ${extrapolationValue}; + } + var data: array<${dType}, 4> = array<${dType}, 4>(0.0, 0.0, 0.0, 0.0); + for (var i: i32 = -1; i < 3; i++) { + var ${direction}: ${dType} = originalIdx + ${dType}(i); + if (${direction} < 0 || ${direction} >= ${inputShape[idx]}) { + ${(() => { + if (excludeOutside) { + return `coefs[i + 1] = 0.0; + continue;`; + } else if (useExtrapolation) { + return `return ${extrapolationValue};`; + } else { + return `${direction} = max(0, min(${direction}, ${inputShape[idx]} - 1));`; + } + })()}; + } + var input_indices_copy: ${input.type.indices} = input_indices; + ${input.indicesSet("input_indices_copy", idx, `u32(${direction})`)}; + data[i + 1] = ${idx === heightIdx ? input.getByIndices("input_indices_copy") : "rowCubicInterpolation(input_indices_copy, output_indices)"}; + } + return cubicInterpolation1D(data, coefs); + }`; + }; + return ` + ${createCubicInterpolationFunction(heightIdx)}; + ${createCubicInterpolationFunction(widthIdx)}; + fn getCubicInterpolationCoefs(s: ${dType}) -> array<${dType}, 4> { + var absS = abs(s); + var coeffs: array<${dType}, 4> = array<${dType}, 4>(0.0, 0.0, 0.0, 0.0); + var oneMinusAbsS: ${dType} = 1.0 - absS; + var twoMinusAbsS: ${dType} = 2.0 - absS; + var onePlusAbsS: ${dType} = 1.0 + absS; + coeffs[0] = ((${cubicCoeffA} * onePlusAbsS - 5 * ${cubicCoeffA}) * onePlusAbsS + 8 * ${cubicCoeffA}) * onePlusAbsS - 4 * ${cubicCoeffA}; + coeffs[1] = ((${cubicCoeffA} + 2) * absS - (${cubicCoeffA} + 3)) * absS * absS + 1; + coeffs[2] = ((${cubicCoeffA} + 2) * oneMinusAbsS - (${cubicCoeffA} + 3)) * oneMinusAbsS * oneMinusAbsS + 1; + coeffs[3] = ((${cubicCoeffA} * twoMinusAbsS - 5 * ${cubicCoeffA}) * twoMinusAbsS + 8 * ${cubicCoeffA}) * twoMinusAbsS - 4 * ${cubicCoeffA}; + return coeffs; + } + + fn cubicInterpolation1D(x: array<${dType}, 4>, coefs: array<${dType}, 4>) -> ${dType} { + var coefsSum: ${dType} = coefs[0] + coefs[1] + coefs[2] + coefs[3]; + return (x[0] * coefs[0] + x[1] * coefs[1]+ x[2] * coefs[2]+ x[3] * coefs[3]) / coefsSum; + } + + fn bicubicInterpolation(output_indices: ${output.type.indices}) -> ${dType} { + var input_indices: ${input.type.indices} = output_indices; + return colCubicInterpolation(input_indices, output_indices); + } + `; + }; + trilinearInterpolation = (input, output, inputShape, useExtrapolation, extrapolationValue) => { + const isNchw = true; + const [batchIdx, depthIdx, heightIdx, widthIdx, channelIdx] = inputShape.length === 3 ? [-1, 0, 1, 2, -1] : isNchw ? [0, 2, 3, 4, 1] : [0, 1, 2, 3, 4]; + const dType = input.type.value; + return ` + fn getInputValue(batch: u32, channel: u32, depth:u32, height: u32, width: u32) -> ${dType} { + var input_indices: ${input.type.indices}; + ${input.indicesSet("input_indices", depthIdx, `max(0, min(depth, ${inputShape[depthIdx]} - 1))`)}; + ${input.indicesSet("input_indices", heightIdx, `max(0, min(height, ${inputShape[heightIdx]} - 1))`)}; + ${input.indicesSet("input_indices", widthIdx, `max(0, min(width, ${inputShape[widthIdx]} - 1))`)}; + ${setChannelAndBatchIndices(input, channelIdx, batchIdx, 3)} + return ${input.getByIndices("input_indices")}; + } + + fn trilinearInterpolation(output_indices: ${output.type.indices}) -> ${dType} { + var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices); + var depth:${dType} = originalIndices[${depthIdx}]; + var height:${dType} = originalIndices[${heightIdx}]; + var width:${dType} = originalIndices[${widthIdx}]; + ${useExtrapolation ? `if (depth < 0 || depth > (${inputShape[depthIdx]} - 1) || height < 0 || height > (${inputShape[heightIdx]} - 1) || width < 0 || (width > ${inputShape[widthIdx]} - 1)) { + return ${extrapolationValue}; + }` : ""}; + + depth = max(0, min(depth, ${inputShape[depthIdx]} - 1)); + height = max(0, min(height, ${inputShape[heightIdx]} - 1)); + width = max(0, min(width, ${inputShape[widthIdx]} - 1)); + var depth1: u32 = u32(depth); + var height1: u32 = u32(height); + var width1: u32 = u32(width); + var depth2: u32 = u32(depth + 1); + var height2: u32 = u32(height + 1); + var width2: u32 = u32(width + 1); + var channel: u32 = ${inputShape.length > 3 ? `u32(originalIndices[${channelIdx}])` : "0"}; + var batch: u32 = ${inputShape.length > 3 ? `u32(originalIndices[${batchIdx}])` : "0"}; + + var x111: ${dType} = getInputValue(batch, channel, depth1, height1, width1); + var x112: ${dType} = getInputValue(batch, channel, depth1, height1, width2); + var x121: ${dType} = getInputValue(batch, channel, depth1, height2, width1); + var x122: ${dType} = getInputValue(batch, channel, depth1, height2, width2); + var x211: ${dType} = getInputValue(batch, channel, depth2, height1, width1); + var x212: ${dType} = getInputValue(batch, channel, depth2, height1, width2); + var x221: ${dType} = getInputValue(batch, channel, depth2, height2, width1); + var x222: ${dType} = getInputValue(batch, channel, depth2, height2, width2); + var dx1: ${dType} = abs(depth - ${dType}(depth1)); + var dx2: ${dType} = abs(${dType}(depth2) - depth); + var dy1: ${dType} = abs(height - ${dType}(height1)); + var dy2: ${dType} = abs(${dType}(height2) - height); + var dz1: ${dType} = abs(width - ${dType}(width1)); + var dz2: ${dType} = abs(${dType}(width2) - width); + if (depth1 == depth2) { + dx1 = 0.5; + dx2 = 0.5; + } + if (height1 == height2) { + dy1 = 0.5; + dy2 = 0.5; + } + if (width1 == width2) { + dz1 = 0.5; + dz2 = 0.5; + } + return (x111 * dx2 * dy2 * dz2 + x112 * dx2 * dy2 * dz1 + x121 * dx2 * dy1 *dz2 + x122 * dx2 * dy1 * dz1 + + x211 * dx1 * dy2 * dz2 + x212 * dx1 * dy2 * dz1 + x221 * dx1 * dy1 *dz2 + x222 * dx1 * dy1 * dz1); + }`; + }; + createResizeProgramInfo = (inputTensor, attributes, opsetVersion, scalesInput, sizes, roiInput) => { + const inputShape = inputTensor.dims; + const roi = updateRoI(roiInput, attributes.axes, inputShape.length); + let outputShape = initOutputShape(inputShape, scalesInput, sizes, attributes.axes); + let scales = scalesInput.slice(); + if (scalesInput.length === 0) { + scales = inputShape.map((value, index) => value === 0 ? 1 : outputShape[index] / value); + if (attributes.keepAspectRatioPolicy !== "stretch") { + outputShape = adjustOutputShape(inputShape, scales, attributes); + } + } + const output = outputVariable("output", inputTensor.dataType, outputShape.length); + const input = inputVariable("input", inputTensor.dataType, inputShape.length); + const outputSize = ShapeUtil.size(outputShape); + const noScale = inputShape.length === outputShape.length && inputShape.every((d, i) => d === outputShape[i]); + const useExtrapolation = attributes.coordinateTransformMode === "tf_crop_and_resize"; + const extrapolationValue = attributes.extrapolationValue; + const dataType = input.type.value; + const getShaderSource = (shaderHelper) => ` + ${noScale ? "" : ` + ${getOriginalCoordinateFromResizedCoordinate(attributes.coordinateTransformMode, dataType)}; + ${(() => { + switch (attributes.mode) { + case "nearest": + return ` + ${checkInputIndices(input, inputShape)}; + ${getNearestPixelFromOriginal(attributes.nearestMode, opsetVersion, dataType)}; + ${calculateInputIndicesFromOutputIndices( + input, + output, + inputShape, + outputShape, + scales.length, + roi.length, + useExtrapolation + )}; + `; + case "linear": + return ` + ${calculateOriginalIndicesFromOutputIndices(output, inputShape, outputShape, scales.length, roi.length)}; + ${(() => { + if (inputShape.length === 2 || inputShape.length === 4) { + return `${bilinearInterpolation(input, output, inputShape, useExtrapolation, extrapolationValue)}`; + } else if (inputShape.length === 3 || inputShape.length === 5) { + return `${trilinearInterpolation(input, output, inputShape, useExtrapolation, extrapolationValue)}`; + } else { + throw Error("Linear mode only supports input dims 2, 3, 4 and 5 are supported in linear mode."); + } + })()}; + `; + case "cubic": + return ` + ${(() => { + if (inputShape.length === 2 || inputShape.length === 4) { + return `${bicubicInterpolation( + input, + output, + inputShape, + outputShape, + scales, + roi, + attributes.cubicCoeffA, + useExtrapolation, + attributes.extrapolationValue, + attributes.excludeOutside + )}`; + } else { + throw Error("Cubic mode only supports input dims 2 and 4 are supported in linear mode."); + } + })()}; + `; + default: + throw Error("Invalid resize mode"); + } + })()}; + `} + ${shaderHelper.registerUniform("output_size", "u32").registerUniform("scales", "f32", scales.length).registerUniform("roi", "f32", roi.length).declareVariables(input, output)} + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")} + ${noScale ? "output[global_idx] = input[global_idx];" : ` + let output_indices = ${output.offsetToIndices("global_idx")}; + var input_indices: ${input.type.indices}; + ${(() => { + switch (attributes.mode) { + case "nearest": + return `input_indices = calculateInputIndicesFromOutputIndices(output_indices); + if (checkInputIndices(input_indices)) { + output[global_idx] = ${input.getByIndices("input_indices")}; + } else { + output[global_idx] = ${attributes.extrapolationValue}; + }`; + case "linear": + return `output[global_idx] = ${inputShape.length === 2 || inputShape.length === 4 ? "bilinearInterpolation" : "trilinearInterpolation"}(output_indices);`; + case "cubic": + return "output[global_idx] = bicubicInterpolation(output_indices);"; + default: + throw Error(`Unsupported resize mode: ${attributes.mode}`); + } + })()}; +`} + }`; + return { + name: "Resize", + shaderCache: { + hint: `${attributes.cacheKey}|${opsetVersion}|${scales.length > 0 ? scales : ""}|${sizes.length > 0 ? sizes : ""}|${roi.length > 0 ? roi : ""}|${noScale}|${inputShape}`, + inputDependencies: ["rank"] + }, + getShaderSource, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: inputTensor.dataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms: [ + { type: 12 /* uint32 */, data: outputSize }, + { type: 1 /* float */, data: scales }, + { type: 1 /* float */, data: roi }, + ...createTensorShapeVariables(inputShape, outputShape) + ] + }) + }; + }; + getOpsetVersionFromCustomDataBuffer = (context) => { + const customDataBuffer = context.customDataBuffer; + const customDataBuffer32 = new Uint32Array(customDataBuffer, customDataBuffer.byteOffset, 1); + const opsetVersion = customDataBuffer32[0]; + return opsetVersion; + }; + resize = (context, attributes) => { + const scales = []; + const sizes = []; + const roi = []; + const opsetVersion = getOpsetVersionFromCustomDataBuffer(context); + if (attributes.antialias !== 0) { + throw Error("Only default value (0) for Antialias attribute is supported"); + } + validateInputs21(context.inputs, attributes, opsetVersion, scales, sizes, roi); + context.compute( + createResizeProgramInfo(context.inputs[0], attributes, opsetVersion, scales, sizes, roi), + { inputs: [0] } + ); + }; + parseResizeAttributes = (attributes) => { + const antialias = attributes.antialias; + const axes = attributes.axes; + const coordinateTransformMode = attributes.coordinateTransformMode; + const cubicCoeffA = attributes.cubicCoeffA; + const excludeOutside = attributes.excludeOutside !== 0; + const extrapolationValue = attributes.extrapolationValue; + const keepAspectRatioPolicy = attributes.keepAspectRatioPolicy; + const mode = attributes.mode; + const nearestMode = attributes.nearestMode === "" ? "simple" : attributes.nearestMode; + return createAttributeWithCacheKey({ + antialias, + axes, + coordinateTransformMode, + cubicCoeffA, + excludeOutside, + extrapolationValue, + keepAspectRatioPolicy, + mode, + nearestMode + }); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/rotary-embedding.ts +var validateInputs22, createRotaryEmbeddingProgramInfo, rotaryEmbedding; +var init_rotary_embedding = __esm({ + "web/lib/wasm/jsep/webgpu/ops/rotary-embedding.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_attribute_with_cache_key(); + init_common(); + validateInputs22 = (inputs, attributes) => { + const [input, positionIds, cosCache, sinCache] = inputs; + const { numHeads, rotaryEmbeddingDim } = attributes; + if (input.dims.length !== 3 && input.dims.length !== 4) { + throw new Error(`Input 'x' is expected to have 3 or 4 dimensions, got ${input.dims.length}`); + } + if (!ShapeUtil.areEqual(positionIds.dims, []) && !ShapeUtil.areEqual(positionIds.dims, [1]) && positionIds.dims.length !== 2) { + throw new Error(`Input 'position_ids' is expected to have 0, 1, or 2 dimensions, got ${positionIds.dims.length}`); + } + if (cosCache.dims.length !== 2) { + throw new Error(`Input 'cos_cache' is expected to have 2 dimensions, got ${cosCache.dims.length}`); + } + if (sinCache.dims.length !== 2) { + throw new Error(`Input 'sin_cache' is expected to have 2 dimensions, got ${sinCache.dims.length}`); + } + if (!ShapeUtil.areEqual(cosCache.dims, sinCache.dims)) { + throw new Error("Inputs 'cos_cache' and 'sin_cache' are expected to have the same shape"); + } + if (rotaryEmbeddingDim > 0 && numHeads === 0) { + throw new Error("num_heads must be provided if rotary_embedding_dim is specified"); + } + const batchSize = input.dims[0]; + const sequenceLength = input.dims[input.dims.length - 2]; + const maxSequenceLength = cosCache.dims[0]; + const hiddenSize = ShapeUtil.sizeFromDimension(input.dims, 1) / sequenceLength; + const headSize = rotaryEmbeddingDim === 0 ? cosCache.dims[1] * 2 : hiddenSize / numHeads; + if (rotaryEmbeddingDim > headSize) { + throw new Error("rotary_embedding_dim must be less than or equal to head_size"); + } + if (positionIds.dims.length === 2) { + if (batchSize !== positionIds.dims[0]) { + throw new Error(`Input 'position_ids' dimension 0 should be of size batch_size, got ${positionIds.dims[0]}`); + } + if (sequenceLength !== positionIds.dims[1]) { + throw new Error(`Input 'position_ids' dimension 1 should be of size sequence_length, got ${positionIds.dims[1]}`); + } + } + if (headSize / 2 !== cosCache.dims[1] && rotaryEmbeddingDim / 2 !== cosCache.dims[1]) { + throw new Error(`Input 'cos_cache' dimension 1 should be same as head_size / 2 or rotary_embedding_dim / 2, got ${cosCache.dims[1]}`); + } + if (sequenceLength > maxSequenceLength) { + throw new Error("Updating cos_cache and sin_cache in RotaryEmbedding is not currently supported"); + } + }; + createRotaryEmbeddingProgramInfo = (inputs, attributes) => { + const { interleaved, numHeads, rotaryEmbeddingDim, scale } = attributes; + const batchSize = inputs[0].dims[0]; + const batchStride = ShapeUtil.sizeFromDimension(inputs[0].dims, 1); + const sequenceLength = inputs[0].dims[inputs[0].dims.length - 2]; + const hiddenSize = batchStride / sequenceLength; + const halfRotaryEmbeddingDim = inputs[2].dims[1]; + const headSize = rotaryEmbeddingDim === 0 ? halfRotaryEmbeddingDim * 2 : hiddenSize / numHeads; + const globalShape = new Array(batchSize, sequenceLength, hiddenSize / headSize, headSize - halfRotaryEmbeddingDim); + const globalStrides = ShapeUtil.computeStrides(globalShape); + const programUniforms = [ + { type: 1 /* float */, data: scale }, + { type: 12 /* uint32 */, data: globalShape }, + { type: 12 /* uint32 */, data: globalStrides }, + // strides for addressing the input/output tensor, in permutated order to align with the unfolded global index, + // i.e. BSNH + ...inputs[0].dims.length === 3 ? new Array({ type: 12 /* uint32 */, data: [batchStride, hiddenSize, headSize, 1] }) : [], + ...inputs[0].dims.length === 4 ? new Array( + { type: 12 /* uint32 */, data: [batchStride, headSize, sequenceLength * headSize, 1] } + ) : [], + ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims, inputs[2].dims, inputs[3].dims, inputs[0].dims) + ]; + const getShaderSource = (shaderHelper) => { + const input = inputVariable("input", inputs[0].dataType, inputs[0].dims.length); + const positionIds = inputVariable("position_ids", inputs[1].dataType, inputs[1].dims.length); + const cosCache = inputVariable("cos_cache", inputs[2].dataType, inputs[2].dims.length); + const sinCache = inputVariable("sin_cache", inputs[3].dataType, inputs[3].dims.length); + const output = outputVariable("output", inputs[0].dataType, inputs[0].dims.length); + shaderHelper.registerUniforms([ + { name: "scale", type: "f32" }, + { name: "global_shape", type: "u32", length: globalShape.length }, + { name: "global_strides", type: "u32", length: globalStrides.length }, + { name: "input_output_strides", type: "u32", length: globalStrides.length } + ]); + return ` + ${shaderHelper.declareVariables(input, positionIds, cosCache, sinCache, output)} + + ${shaderHelper.mainStart(WORKGROUP_SIZE)} + let half_rotary_emb_dim = uniforms.${cosCache.name}_shape[1]; + let bsnh = global_idx / uniforms.global_strides % uniforms.global_shape; + let size = uniforms.global_shape[0] * uniforms.global_strides[0]; + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("size")} + + if (bsnh[3] < half_rotary_emb_dim) { + let position_ids_idx = + ${positionIds.broadcastedIndicesToOffset("bsnh.xy", outputVariable("", positionIds.type.tensor, 2))}; + let position_id = + u32(${positionIds.getByOffset("position_ids_idx")}) + select(0, bsnh[1], position_ids_idx == 0); + let i = dot(bsnh, uniforms.input_output_strides) + select(0, bsnh[3], ${interleaved}); + let j = i + select(half_rotary_emb_dim, 1, ${interleaved}); + let re = ${input.getByOffset("i")} * ${cosCache.get("position_id", "bsnh[3]")} - + ${input.getByOffset("j")} * ${sinCache.get("position_id", "bsnh[3]")}; + ${output.setByOffset("i", "re")} + let im = ${input.getByOffset("i")} * ${sinCache.get("position_id", "bsnh[3]")} + + ${input.getByOffset("j")} * ${cosCache.get("position_id", "bsnh[3]")}; + ${output.setByOffset("j", "im")} + } else { + let k = dot(bsnh, uniforms.input_output_strides) + half_rotary_emb_dim; + ${output.setByOffset("k", input.getByOffset("k"))} + } + }`; + }; + return { + name: "RotaryEmbedding", + shaderCache: { + hint: createAttributeWithCacheKey({ + interleaved + }).cacheKey, + inputDependencies: ["rank", "rank", "rank", "rank"] + }, + getShaderSource, + getRunData: () => ({ + outputs: [{ dims: inputs[0].dims, dataType: inputs[0].dataType }], + dispatchGroup: { x: Math.ceil(ShapeUtil.size(globalShape) / WORKGROUP_SIZE) }, + programUniforms + }) + }; + }; + rotaryEmbedding = (context, attributes) => { + validateInputs22(context.inputs, attributes); + context.compute(createRotaryEmbeddingProgramInfo(context.inputs, attributes)); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/skip-layer-norm.ts +var validateInputs23, createSkipLayerNormProgramInfo, skipLayerNorm; +var init_skip_layer_norm = __esm({ + "web/lib/wasm/jsep/webgpu/ops/skip-layer-norm.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_common(); + validateInputs23 = (inputs) => { + if (!inputs || inputs.length < 3) { + throw new Error("layerNorm requires at least 3 inputs."); + } + const input = inputs[0]; + const skip = inputs[1]; + const gamma = inputs[2]; + if (input.dataType !== skip.dataType || input.dataType !== gamma.dataType) { + throw new Error("All inputs must have the same data type"); + } + if (input.dims.length !== 3 && input.dims.length !== 2) { + throw new Error("Input must be 2D or 3D"); + } + if (skip.dims.length !== 3 && skip.dims.length !== 2) { + throw new Error("Skip must be 2D or 3D"); + } + const hiddenSize = input.dims[input.dims.length - 1]; + const sequenceLength = input.dims[input.dims.length - 2]; + if (skip.dims[skip.dims.length - 1] !== hiddenSize) { + throw new Error("Skip must have the same hidden size as input"); + } + if (skip.dims[skip.dims.length - 2] !== sequenceLength) { + throw new Error("Skip must have the same sequence length as input"); + } + if (gamma.dims.length !== 1) { + throw new Error("Gamma must be 1D"); + } + if (gamma.dims[gamma.dims.length - 1] !== hiddenSize) { + throw new Error("Gamma must have the same hidden size as input"); + } + if (inputs.length > 3) { + const beta = inputs[3]; + if (beta.dims.length !== 1) { + throw new Error("Beta must be 1D"); + } + if (beta.dims[beta.dims.length - 1] !== hiddenSize) { + throw new Error("Beta must have the same hidden size as input"); + } + } + if (inputs.length > 4) { + const bias = inputs[4]; + if (bias.dims.length !== 1) { + throw new Error("Bias must be 1D"); + } + if (bias.dims[bias.dims.length - 1] !== hiddenSize) { + throw new Error("Bias must have the same hidden size as input"); + } + } + }; + createSkipLayerNormProgramInfo = (inputs, attributes, outputCount, isTraining) => { + const simplified = attributes.simplified; + const inputShape = inputs[0].dims; + const inputSize = ShapeUtil.size(inputShape); + const outputShape = inputShape; + const outputSize = inputSize; + const hiddenSize = inputShape.slice(-1)[0]; + const meanInvStdDevDim = isTraining ? inputShape.slice(0, -1).concat(1) : []; + const hasBetaInput = !simplified && inputs.length > 3; + const hasBiasInput = inputs.length > 4; + const hasMeanOutput = isTraining && outputCount > 1; + const hasInvStdDevOutput = isTraining && outputCount > 2; + const hasInputSkipBiasSumOutput = outputCount > 3; + const components = getMaxComponents(hiddenSize); + const programUniforms = [ + { type: 12 /* uint32 */, data: outputSize }, + { type: 12 /* uint32 */, data: components }, + { type: 12 /* uint32 */, data: hiddenSize }, + { type: 1 /* float */, data: attributes.epsilon } + ]; + const getShaderSource = (shaderHelper) => { + const uniformsArray = [ + { name: "output_size", type: "u32" }, + { name: "components", type: "u32" }, + { name: "hidden_size", type: "u32" }, + { name: "epsilon", type: "f32" } + ]; + const variables = [ + inputVariable("x", inputs[0].dataType, inputs[0].dims, components), + inputVariable("skip", inputs[1].dataType, inputs[1].dims, components), + inputVariable("gamma", inputs[2].dataType, inputs[2].dims, components) + ]; + if (hasBetaInput) { + variables.push(inputVariable("beta", inputs[3].dataType, inputs[3].dims, components)); + } + if (hasBiasInput) { + variables.push(inputVariable("bias", inputs[4].dataType, inputs[4].dims, components)); + } + variables.push(outputVariable("output", inputs[0].dataType, outputShape, components)); + if (hasMeanOutput) { + variables.push(outputVariable("mean_output", 1 /* float */, meanInvStdDevDim)); + } + if (hasInvStdDevOutput) { + variables.push(outputVariable("inv_std_output", 1 /* float */, meanInvStdDevDim)); + } + if (hasInputSkipBiasSumOutput) { + variables.push(outputVariable("input_skip_bias_sum", inputs[0].dataType, outputShape, components)); + } + const dataType = tensorTypeToWsglStorageType(inputs[0].dataType); + return ` + + ${shaderHelper.registerUniforms(uniformsArray).declareVariables(...variables)} + + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size / uniforms.hidden_size")} + let hidden_size_vectorized: u32 = uniforms.hidden_size / uniforms.components; + let offset = global_idx * hidden_size_vectorized; + var sum = ${fillVector("f32", components)}; + var squareSum = ${fillVector("f32", components)}; + for (var i: u32 = 0; i < hidden_size_vectorized; i++) { + let skip_value = skip[offset + i]; + let bias_value = ${hasBiasInput ? "bias[i]" : dataType + "(0.0)"}; + let input_value = x[offset + i]; + let value = input_value + skip_value + bias_value; + ${hasInputSkipBiasSumOutput ? "input_skip_bias_sum[offset + i] = value;" : ""} + output[offset + i] = value; + let f32_value = ${castToF32(dataType, components, "value")}; + sum += f32_value; + squareSum += f32_value * f32_value; + } + let mean = ${sumVector("sum", components)} / f32(uniforms.hidden_size); + let inv_std_dev = inverseSqrt(${sumVector("squareSum", components)} / f32(uniforms.hidden_size) ${simplified ? "" : "- mean * mean"} + uniforms.epsilon); + ${hasMeanOutput ? "mean_output[global_idx] = mean;" : ""} + ${hasInvStdDevOutput ? "inv_std_output[global_idx] = inv_std_dev;" : ""} + for (var i: u32 = 0; i < hidden_size_vectorized; i++) { + output[offset + i] = (output[offset + i] ${simplified ? "" : `- ${dataType}(mean)`}) * ${dataType}(inv_std_dev) * gamma[i] ${hasBetaInput ? "+ beta[i]" : ""}; + } + }`; + }; + const outputs = [{ dims: outputShape, dataType: inputs[0].dataType }]; + if (outputCount > 1) { + outputs.push({ dims: meanInvStdDevDim, dataType: 1 /* float */ }); + } + if (outputCount > 2) { + outputs.push({ dims: meanInvStdDevDim, dataType: 1 /* float */ }); + } + if (outputCount > 3) { + outputs.push({ dims: inputShape, dataType: inputs[0].dataType }); + } + return { + name: "SkipLayerNormalization", + shaderCache: { + hint: `${components};${hasMeanOutput};${hasInvStdDevOutput};${hasInputSkipBiasSumOutput}`, + inputDependencies: inputs.map((_input, _index) => "type") + }, + getShaderSource, + getRunData: () => ({ outputs, dispatchGroup: { x: Math.ceil(outputSize / hiddenSize / 64) }, programUniforms }) + }; + }; + skipLayerNorm = (context, attributes) => { + const isTraining = false; + validateInputs23(context.inputs); + const outputs = [0]; + if (context.outputCount > 1) { + outputs.push(isTraining ? 1 : -3); + } + if (context.outputCount > 2) { + outputs.push(isTraining ? 2 : -3); + } + if (context.outputCount > 3) { + outputs.push(3); + } + context.compute( + createSkipLayerNormProgramInfo(context.inputs, attributes, context.outputCount, isTraining), + { outputs } + ); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/slice.ts +var validateInputs24, readInput, createSliceAttributesFromInputs, fixStartEndValues, calculateInputIndicesImpl, createSliceProgramInfo, slice, parseSliceAttributes; +var init_slice = __esm({ + "web/lib/wasm/jsep/webgpu/ops/slice.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_attribute_with_cache_key(); + init_common(); + validateInputs24 = (inputs, attributes) => { + if (!inputs || inputs.length < 1) { + throw new Error("too few inputs"); + } + if (attributes.axes.length !== 0) { + if (attributes.axes.length !== attributes.starts.length || attributes.axes.length !== attributes.ends.length) { + throw new Error("axes, starts and ends must have the same length"); + } + } else if (attributes.starts.length !== attributes.ends.length) { + throw new Error("starts and ends must have the same length"); + } + inputs.slice(1).forEach((_, idx) => { + if (inputs[idx + 1].dataType !== 6 /* int32 */ && inputs[idx + 1].dataType !== 7 /* int64 */) { + throw new Error(`Input ${idx} must be an array of int32 or int64`); + } + }); + }; + readInput = (inputs, idx) => { + const input = []; + if (inputs.length > idx) { + if (inputs[idx].dataType === 7 /* int64 */) { + inputs[idx].getBigInt64Array().forEach((v) => input.push(Number(v))); + } else if (inputs[idx].dataType === 6 /* int32 */) { + inputs[idx].getInt32Array().forEach((v) => input.push(Number(v))); + } else { + throw new Error(`Input ${idx} must be an array of int32 or int64`); + } + } + return input; + }; + createSliceAttributesFromInputs = (inputs, attributes) => { + if (inputs.length > 1) { + const starts = readInput(inputs, 1); + const ends = readInput(inputs, 2); + let axes = readInput(inputs, 3); + if (axes.length === 0) { + axes = [...Array(inputs[0].dims.length).keys()]; + } + return createAttributeWithCacheKey({ starts, ends, axes }); + } else { + return attributes; + } + }; + fixStartEndValues = (value, index, inputShape, axes, steps) => { + let newValue = value; + if (value < 0) { + newValue += inputShape[axes[index]]; + } + if (steps[index] < 0) { + return Math.max(0, Math.min(newValue, inputShape[axes[index]] - 1)); + } else { + return Math.max(0, Math.min(newValue, inputShape[axes[index]])); + } + }; + calculateInputIndicesImpl = (input, output, inputShape) => `fn calculateInputIndices(output_indices: ${output.type.indices}) -> ${input.type.indices} { + var input_indices: ${input.type.indices}; + var carry = 0u; + for (var i = ${inputShape.length}; i >= 0; i--) { + let input_shape_i = ${getElementAt("uniforms.input_shape", "i", inputShape.length)}; + let steps_i = ${getElementAt("uniforms.steps", "i", inputShape.length)}; + let signs_i = ${getElementAt("uniforms.signs", "i", inputShape.length)}; + let starts_i = ${getElementAt("uniforms.starts", "i", inputShape.length)}; + var output_index = ${output.indicesGet("output_indices", "i")}; + var input_index = output_index * steps_i + starts_i + carry; + carry = input_index / input_shape_i; + input_index = input_index % input_shape_i; + if (signs_i < 0) { + input_index = input_shape_i - input_index - 1u + starts_i; + } + ${input.indicesSet("input_indices", "i", "input_index")}; + } + return input_indices; + }`; + createSliceProgramInfo = (inputs, attributes) => { + const inputShape = inputs[0].dims; + const inputSize = ShapeUtil.size(inputShape); + const axes = attributes.axes.length > 0 ? ShapeUtil.normalizeAxes(attributes.axes, inputShape.length) : [...Array(inputShape.length).keys()]; + let steps = readInput(inputs, 4); + steps.forEach((step) => step !== 0 || (() => { + throw new Error("step cannot be 0"); + })); + if (steps.length === 0) { + steps = Array(axes.length).fill(1); + } + const starts = attributes.starts.map((start, i) => fixStartEndValues(start, i, inputShape, axes, steps)); + const ends = attributes.ends.map((end, i) => fixStartEndValues(end, i, inputShape, axes, steps)); + if (axes.length !== starts.length || axes.length !== ends.length) { + throw new Error("start, ends and axes should have the same number of elements"); + } + if (axes.length !== inputShape.length) { + for (let i = 0; i < inputShape.length; ++i) { + if (!axes.includes(i)) { + starts.splice(i, 0, 0); + ends.splice(i, 0, inputShape[i]); + steps.splice(i, 0, 1); + } + } + } + const signs = steps.map((step) => Math.sign(step)); + steps.forEach((step, i, array) => { + if (step < 0) { + const numSteps = (ends[i] - starts[i]) / step; + const newEnd = starts[i]; + const newStart = newEnd + numSteps * steps[i]; + starts[i] = newStart; + ends[i] = newEnd; + array[i] = -step; + } + }); + const outputShape = inputShape.slice(0); + axes.forEach((axis, _) => { + outputShape[axis] = Math.ceil((ends[axis] - starts[axis]) / steps[axis]); + }); + const outputTensorInfo = { dims: outputShape, dataType: inputs[0].dataType }; + const output = outputVariable("output", inputs[0].dataType, outputShape.length); + const input = inputVariable("input", inputs[0].dataType, inputs[0].dims.length); + const outputSize = ShapeUtil.size(outputShape); + const uniforms = [ + { name: "outputSize", type: "u32" }, + { name: "starts", type: "u32", length: starts.length }, + { name: "signs", type: "i32", length: signs.length }, + { name: "steps", type: "u32", length: steps.length } + ]; + const programUniforms = [ + { type: 12 /* uint32 */, data: outputSize }, + { type: 12 /* uint32 */, data: starts }, + { type: 6 /* int32 */, data: signs }, + { type: 12 /* uint32 */, data: steps }, + ...createTensorShapeVariables(inputs[0].dims, outputShape) + ]; + const getShaderSource = (shaderHelper) => ` + ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)} + ${calculateInputIndicesImpl(input, output, inputShape)} + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")} + let output_indices = ${output.offsetToIndices("global_idx")}; + let input_indices = calculateInputIndices(output_indices); + ${output.setByOffset("global_idx", input.getByIndices("input_indices"))} + }`; + return { + name: "Slice", + shaderCache: { hint: `${signs.length}_${starts.length}_${steps.length}`, inputDependencies: ["rank"] }, + getShaderSource, + getRunData: () => ({ + outputs: [outputTensorInfo], + dispatchGroup: { x: Math.ceil( + inputSize / 64 + /* workgroup size */ + ) }, + programUniforms + }) + }; + }; + slice = (context, attributes) => { + validateInputs24(context.inputs, attributes); + const updatedAttributes = createSliceAttributesFromInputs(context.inputs, attributes); + context.compute(createSliceProgramInfo(context.inputs, updatedAttributes), { inputs: [0] }); + }; + parseSliceAttributes = (attributes) => { + const starts = attributes.starts; + const ends = attributes.ends; + const axes = attributes.axes; + return createAttributeWithCacheKey({ starts, ends, axes }); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/softmax.ts +var validateInputs25, createSoftmaxProgramInfo, softmax, parseSoftmaxAttributes; +var init_softmax = __esm({ + "web/lib/wasm/jsep/webgpu/ops/softmax.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_attribute_with_cache_key(); + init_common(); + validateInputs25 = (inputs) => { + if (!inputs || inputs.length !== 1) { + throw new Error("Softmax op requires 1 input."); + } + }; + createSoftmaxProgramInfo = (input, attributes) => { + const shape = input.dims; + const outputSize = ShapeUtil.size(shape); + const WG = 64; + let axis = attributes.axis; + if (axis < 0) { + axis = shape.length + axis; + } + if (axis < shape.length - 1) { + throw new Error("softmax only supports last axis for now."); + } + const cols = shape[axis]; + const rows = outputSize / cols; + const components = getMaxComponents(cols); + const packedCols = cols / components; + const maxVector = (name, components2) => { + if (components2 === 4) { + return `max(max(${name}.x, ${name}.y), max(${name}.z, ${name}.w))`; + } else if (components2 === 2) { + return `max(${name}.x, ${name}.y)`; + } else if (components2 === 3) { + return `max(max(${name}.x, ${name}.y), ${name}.z)`; + } + return name; + }; + const x = inputVariable("x", input.dataType, input.dims, components); + const output = outputVariable("result", input.dataType, input.dims, components); + const valueType = x.type.value; + const threadMaxDecl = tensorTypeToWsglStorageType(input.dataType) === "f32" ? `var threadMax = ${valueType}(-3.402823e+38f);` : `var threadMax = ${valueType}(-65504.0h);`; + const getShaderSource = (shaderHelper) => ` + var rowMaxShared : ${valueType}; + var rowSumShared : ${valueType}; + var threadShared : array<${valueType}, ${WG}>; + + fn getValue(row: i32, col: i32, row_stride: i32) -> ${valueType} { + let index = row * row_stride + col; + return x[index]; + } + + fn setValue(row: i32, col: i32, row_stride: i32, value: ${valueType}) { + let index = row * row_stride + col; + result[index] = value; + } + ${shaderHelper.registerUniform("packedCols", "i32").declareVariables(x, output)} + ${shaderHelper.mainStart()} + let gindex = i32(global_idx); + let lindex = i32(local_idx); + const wg = ${WG}; + let row = gindex / wg; + let cols = uniforms.packedCols; + let row_stride : i32 = uniforms.packedCols; + + // find the rows max + ${threadMaxDecl} + for (var col = lindex; col < cols; col += wg) { + let value = getValue(row, col, row_stride); + threadMax = max(threadMax, value); + } + if (lindex < cols) { + threadShared[lindex] = threadMax; + } + workgroupBarrier(); + + var reduceSize = min(cols, wg); + for (var currSize = reduceSize >> 1; currSize > 0; currSize = reduceSize >> 1) { + reduceSize = currSize + (reduceSize & 1); + if (lindex < currSize) { + threadShared[lindex] = max(threadShared[lindex], threadShared[lindex + reduceSize]); + } + workgroupBarrier(); + } + if (lindex == 0) { + rowMaxShared = ${valueType}(${maxVector("threadShared[0]", components)}); + } + workgroupBarrier(); + + // find the rows sum + var threadSum = ${valueType}(0.0); + for (var col = lindex; col < cols; col += wg) { + let subExp = exp(getValue(row, col, row_stride) - rowMaxShared); + threadSum += subExp; + } + threadShared[lindex] = threadSum; + workgroupBarrier(); + + for (var currSize = wg >> 1; currSize > 0; currSize = currSize >> 1) { + if (lindex < currSize) { + threadShared[lindex] = threadShared[lindex] + threadShared[lindex + currSize]; + } + workgroupBarrier(); + } + if (lindex == 0) { + rowSumShared = ${valueType}(${sumVector("threadShared[0]", components)}); + } + workgroupBarrier(); + + // calculate final value for each element in the row + for (var col = lindex; col < cols; col += wg) { + let value = exp(getValue(row, col, row_stride) - rowMaxShared) / rowSumShared; + setValue(row, col, row_stride, value); + } + }`; + return { + name: "Softmax", + shaderCache: { hint: `${components}`, inputDependencies: ["type"] }, + getRunData: () => ({ + outputs: [{ dims: shape, dataType: input.dataType }], + dispatchGroup: { x: rows }, + programUniforms: [{ type: 6 /* int32 */, data: packedCols }] + }), + getShaderSource + }; + }; + softmax = (context, attributes) => { + validateInputs25(context.inputs); + context.compute(createSoftmaxProgramInfo(context.inputs[0], attributes)); + }; + parseSoftmaxAttributes = (attributes) => createAttributeWithCacheKey({ axis: attributes.axis }); + } +}); + +// web/lib/wasm/jsep/webgpu/ops/split.ts +var validateInputs26, createSplitAttributesFromInputs, calculateOutputIndexImpl, writeBufferDataImpl, createSplitProgramInfo, split, parseSplitAttributes; +var init_split = __esm({ + "web/lib/wasm/jsep/webgpu/ops/split.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_attribute_with_cache_key(); + init_common(); + validateInputs26 = (inputs) => { + if (!inputs || inputs.length < 1) { + throw new Error("too few inputs"); + } + }; + createSplitAttributesFromInputs = (inputs, attributes) => { + const splitSizes = []; + let numOutputs = attributes.numOutputs; + if (inputs[1].dims[0] > 0) { + inputs[1].getBigInt64Array().forEach((v) => splitSizes.push(Number(v))); + numOutputs = splitSizes.length; + } + return createAttributeWithCacheKey({ numOutputs, axis: attributes.axis, splitSizes }); + }; + calculateOutputIndexImpl = (numberOfTensors) => ` +fn calculateOutputIndex(index: u32) -> u32 { + for (var i: u32 = 0u; i < ${numberOfTensors}u; i += 1u ) { + if (index < ${getElementAt("uniforms.size_in_split_axis", "i", numberOfTensors)}) { + return i; + } + } + return ${numberOfTensors}u; +}`; + writeBufferDataImpl = (outputs) => { + const numberOfTensors = outputs.length; + const codeLines = []; + for (let i = 0; i < numberOfTensors; ++i) { + const returnSnippet = outputs[i].setByIndices("indices", "input[global_idx]"); + if (numberOfTensors === 1) { + codeLines.push(returnSnippet); + } else if (i === 0) { + codeLines.push(`if (output_number == ${i}u) { ${returnSnippet} }`); + } else if (i === numberOfTensors - 1) { + codeLines.push(`else { ${returnSnippet} }`); + } else { + codeLines.push(`else if (output_number == ${i}) { ${returnSnippet} }`); + } + } + return ` + fn writeBufferData(output_number: u32, indices: ${outputs[0].type.indices}, global_idx: u32) { + ${codeLines.join("\n")} + }`; + }; + createSplitProgramInfo = (inputs, attributes) => { + const inputShape = inputs[0].dims; + const inputSize = ShapeUtil.size(inputShape); + const dataType = inputs[0].dataType; + const axis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length); + const outputs = new Array(attributes.numOutputs); + const input = inputVariable("input", dataType, inputShape.length); + const sizeInSplitAxis = new Array(attributes.numOutputs); + const outputsTensorInfo = []; + const outputShapes = []; + let previousSum = 0; + const programUniforms = [{ type: 12 /* uint32 */, data: inputSize }]; + for (let i = 0; i < attributes.numOutputs; i++) { + previousSum += attributes.splitSizes[i]; + sizeInSplitAxis[i] = previousSum; + const outputShape = inputShape.slice(); + outputShape[attributes.axis] = attributes.splitSizes[i]; + outputShapes.push(outputShape); + outputs[i] = outputVariable(`output${i}`, dataType, outputShape.length); + outputsTensorInfo.push({ dims: outputShapes[i], dataType: inputs[0].dataType }); + } + programUniforms.push( + { type: 12 /* uint32 */, data: sizeInSplitAxis }, + ...createTensorShapeVariables(inputShape, ...outputShapes) + ); + const getShaderSource = (shaderHelper) => ` + ${shaderHelper.registerUniform("input_size", "u32").registerUniform("size_in_split_axis", "u32", sizeInSplitAxis.length).declareVariables(input, ...outputs)} + ${calculateOutputIndexImpl(sizeInSplitAxis.length)} + ${writeBufferDataImpl(outputs)} + + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.input_size")} + + var indices = ${input.offsetToIndices("global_idx")}; + var index = ${input.indicesGet("indices", axis)}; + let output_number = calculateOutputIndex(index); + if (output_number != 0) { + index -= ${getElementAt("uniforms.size_in_split_axis", "output_number - 1u", sizeInSplitAxis.length)}; + ${input.indicesSet("indices", axis, "index")}; + } + writeBufferData(output_number, indices, global_idx); + }`; + return { + name: "Split", + shaderCache: { hint: attributes.cacheKey, inputDependencies: ["rank"] }, + getShaderSource, + getRunData: () => ({ + outputs: outputsTensorInfo, + dispatchGroup: { x: Math.ceil( + inputSize / 64 + /* workgroup size */ + ) }, + programUniforms + }) + }; + }; + split = (context, attributes) => { + validateInputs26(context.inputs); + const updatedAttributes = context.inputs.length === 1 ? attributes : createSplitAttributesFromInputs(context.inputs, attributes); + context.compute(createSplitProgramInfo(context.inputs, updatedAttributes), { inputs: [0] }); + }; + parseSplitAttributes = (attributes) => { + const axis = attributes.axis; + const splitSizes = attributes.splitSizes; + const numOutputs = attributes.numOutputs < 0 ? splitSizes.length : attributes.numOutputs; + if (numOutputs !== splitSizes.length) { + throw new Error("numOutputs and splitSizes lengh must be equal"); + } + return createAttributeWithCacheKey({ axis, numOutputs, splitSizes }); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/tile.ts +var getRepeats, validateInputs27, getOutputShape2, createTileProgramInfo, tile; +var init_tile = __esm({ + "web/lib/wasm/jsep/webgpu/ops/tile.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_common(); + getRepeats = (repeatsTensorView) => Array.from(repeatsTensorView.getBigInt64Array(), Number); + validateInputs27 = (inputs) => { + if (!inputs || inputs.length !== 2) { + throw new Error("Tile requires 2 inputs."); + } + if (inputs[0].dataType !== 1 /* float */ && inputs[0].dataType !== 6 /* int32 */ && inputs[0].dataType !== 12 /* uint32 */) { + throw new Error("Tile only support float, int32, and uint32 data types"); + } + if (inputs[1].dataType !== 7 /* int64 */) { + throw new Error("Tile `repeats` input should be of int64 data type"); + } + if (inputs[1].dims.length !== 1) { + throw new Error("Tile `repeats` input should be 1-D"); + } + const repeats = getRepeats(inputs[1]); + if (repeats.length !== inputs[0].dims.length) { + throw new Error("Tile `repeats` input should have same number of elements as rank of input data tensor"); + } + }; + getOutputShape2 = (inputShape, repeats) => { + const outputShape = []; + for (let i = 0; i < inputShape.length; ++i) { + outputShape.push(inputShape[i] * repeats[i]); + } + return outputShape; + }; + createTileProgramInfo = (inputs) => { + const inputShape = inputs[0].dims; + const repeats = getRepeats(inputs[1]); + const outputShape = getOutputShape2(inputShape, repeats); + const outputSize = ShapeUtil.size(outputShape); + const dataType = inputs[0].dataType; + const input = inputVariable("input", dataType, inputShape.length); + const output = outputVariable("output", dataType, outputShape.length); + const getShaderSource = (shaderHelper) => ` + const inputShape = ${input.indices(...inputShape)}; + ${shaderHelper.registerUniform("output_size", "u32").declareVariables(input, output)} + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")} + let output_indices = ${output.offsetToIndices("global_idx")}; + var input_indices: ${input.type.indices}; + for (var i = 0; i < ${inputShape.length}; i++) { + let input_dim_i = ${input.indicesGet("uniforms.input_shape", "i")}; + let input_dim_value = ${output.indicesGet("output_indices", "i")} % input_dim_i; + + ${input.indicesSet("input_indices", "i", "input_dim_value")} + } + ${output.setByOffset("global_idx", input.getByIndices("input_indices"))} + }`; + return { + name: "Tile", + shaderCache: { hint: `${repeats}`, inputDependencies: ["rank"] }, + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: inputs[0].dataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 + /* workgroup size */ + ) }, + programUniforms: [{ type: 12 /* uint32 */, data: outputSize }, ...createTensorShapeVariables(inputs[0].dims, outputShape)] + }), + getShaderSource + }; + }; + tile = (context) => { + validateInputs27(context.inputs); + context.compute(createTileProgramInfo(context.inputs), { inputs: [0] }); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/ops/where.ts +var createWhereOpProgramShader, createWhereOpProgramInfo, where; +var init_where = __esm({ + "web/lib/wasm/jsep/webgpu/ops/where.ts"() { + "use strict"; + init_wasm_common(); + init_util(); + init_common(); + createWhereOpProgramShader = (shaderHelper, inputs, dimsOutput, isBroadcast, typeOutput) => { + const output = outputVariable("output_data", typeOutput, dimsOutput.length, 4); + const a = inputVariable("a_data", inputs[1].dataType, inputs[1].dims.length, 4); + const b = inputVariable("b_data", inputs[2].dataType, inputs[2].dims.length, 4); + const c = inputVariable("c_data", inputs[0].dataType, inputs[0].dims.length, 4); + let assignment; + const expression = (a2, b2, c2) => `select(${b2}, ${a2}, ${c2})`; + if (!isBroadcast) { + assignment = output.setByOffset( + "global_idx", + expression(a.getByOffset("global_idx"), b.getByOffset("global_idx"), c.getByOffset("global_idx")) + ); + } else { + const singleAssignment = (resStr, x, typeCast = "") => { + const expressionA = `a_data[index_a${x}][component_a${x}]`; + const expressionB = `b_data[index_b${x}][component_b${x}]`; + const expressionC = `bool(c_data[index_c${x}] & (0xffu << (component_c${x} * 8)))`; + return ` + let output_indices${x} = ${output.offsetToIndices(`global_idx * 4u + ${x}u`)}; + let offset_a${x} = ${a.broadcastedIndicesToOffset(`output_indices${x}`, output)}; + let offset_b${x} = ${b.broadcastedIndicesToOffset(`output_indices${x}`, output)}; + let offset_c${x} = ${c.broadcastedIndicesToOffset(`output_indices${x}`, output)}; + let index_a${x} = offset_a${x} / 4u; + let index_b${x} = offset_b${x} / 4u; + let index_c${x} = offset_c${x} / 4u; + let component_a${x} = offset_a${x} % 4u; + let component_b${x} = offset_b${x} % 4u; + let component_c${x} = offset_c${x} % 4u; + ${resStr}[${x}] = ${typeCast}(${expression(expressionA, expressionB, expressionC)}); + `; + }; + if (typeOutput === 9 /* bool */) { + assignment = ` + var data = vec4(0); + ${singleAssignment("data", 0, "u32")} + ${singleAssignment("data", 1, "u32")} + ${singleAssignment("data", 2, "u32")} + ${singleAssignment("data", 3, "u32")} + output_data[global_idx] = dot(vec4(0x1, 0x100, 0x10000, 0x1000000), vec4(data));`; + } else { + assignment = ` + ${singleAssignment("output_data[global_idx]", 0)} + ${singleAssignment("output_data[global_idx]", 1)} + ${singleAssignment("output_data[global_idx]", 2)} + ${singleAssignment("output_data[global_idx]", 3)} + `; + } + } + return ` + ${shaderHelper.registerUniform("vec_size", "u32").declareVariables(c, a, b, output)} + ${shaderHelper.mainStart()} + ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.vec_size")} + ${assignment} + }`; + }; + createWhereOpProgramInfo = (inputs) => { + const dimsA = inputs[1].dims; + const dimsB = inputs[2].dims; + const dimsC = inputs[0].dims; + const outputDataType = inputs[1].dataType; + const isBroadcast = !(ShapeUtil.areEqual(dimsA, dimsB) && ShapeUtil.areEqual(dimsB, dimsC)); + let outputShape = dimsA; + let outputSize = ShapeUtil.size(dimsA); + if (isBroadcast) { + const calculatedShape = BroadcastUtil.calcShape(BroadcastUtil.calcShape(dimsA, dimsB, false), dimsC, false); + if (!calculatedShape) { + throw new Error("Can't perform where op on the given tensors"); + } + outputShape = calculatedShape; + outputSize = ShapeUtil.size(outputShape); + } + const vecSize = Math.ceil(outputSize / 4); + return { + name: "Where", + shaderCache: { inputDependencies: ["rank", "rank", "rank"] }, + getShaderSource: (shaderHelper) => createWhereOpProgramShader(shaderHelper, inputs, outputShape, isBroadcast, outputDataType), + getRunData: () => ({ + outputs: [{ dims: outputShape, dataType: outputDataType }], + dispatchGroup: { x: Math.ceil( + outputSize / 64 / 4 + /* vec size */ + ) }, + programUniforms: [{ type: 12 /* uint32 */, data: vecSize }, ...createTensorShapeVariables(dimsC, dimsA, dimsB, outputShape)] + }) + }; + }; + where = (context) => { + context.compute(createWhereOpProgramInfo(context.inputs)); + }; + } +}); + +// web/lib/wasm/jsep/webgpu/op-resolve-rules.ts +var WEBGPU_OP_RESOLVE_RULES; +var init_op_resolve_rules = __esm({ + "web/lib/wasm/jsep/webgpu/op-resolve-rules.ts"() { + "use strict"; + init_argminmax(); + init_attention(); + init_batch_norm(); + init_bias_add(); + init_bias_split_gelu(); + init_binary_op(); + init_concat(); + init_conv(); + init_conv_transpose(); + init_cumsum(); + init_depth_to_space(); + init_einsum(); + init_expand(); + init_fast_gelu(); + init_gather(); + init_gather_elements(); + init_gemm(); + init_instance_norm(); + init_layer_norm(); + init_matmul(); + init_matmulnbits(); + init_multihead_attentiion(); + init_pad(); + init_pool(); + init_range(); + init_reduce(); + init_resize(); + init_rotary_embedding(); + init_skip_layer_norm(); + init_slice(); + init_softmax(); + init_split(); + init_tile(); + init_transpose(); + init_unary_op(); + init_where(); + WEBGPU_OP_RESOLVE_RULES = /* @__PURE__ */ new Map([ + ["Abs", [abs]], + ["Acos", [acos]], + ["Acosh", [acosh]], + ["Add", [add]], + ["ArgMax", [argMax, parseArgMinMaxAttributes]], + ["ArgMin", [argMin, parseArgMinMaxAttributes]], + ["Asin", [asin]], + ["Asinh", [asinh]], + ["Atan", [atan]], + ["Atanh", [atanh]], + ["Attention", [attention]], + // TODO: support new attributes for AveragePool-10 + ["AveragePool", [averagePool, parseAveragePoolAttributes]], + ["BatchNormalization", [batchNorm]], + ["BiasAdd", [biasAdd]], + ["BiasSplitGelu", [biasSplitGelu]], + ["Cast", [cast, parseCastAttributes]], + ["Ceil", [ceil]], + ["Clip", [clip]], + ["Concat", [concat, parseConcatAttributes]], + ["Conv", [conv, parseConvAttributes]], + ["ConvTranspose", [convTranspose, parseConvTransposeAttributes]], + ["Cos", [cos]], + ["Cosh", [cosh]], + ["CumSum", [cumsum, parseCumSumAttributes]], + ["DepthToSpace", [depthToSpace, parseDepthToSpaceAttributes]], + ["Div", [div]], + ["Einsum", [einsum, parseEinsumAttributes]], + ["Elu", [elu, parseAlphaAttributes]], + ["Equal", [equal]], + ["Erf", [erf]], + ["Exp", [exp]], + ["Expand", [expand]], + ["FastGelu", [fastGelu2]], + ["Floor", [floor]], + ["FusedConv", [conv, parseConvAttributes]], + ["Gather", [gather, parseGatherAttributes]], + ["GatherElements", [gatherElements, parseGatherElementsAttributes]], + ["Gelu", [gelu]], + ["Gemm", [gemm, parseGemmAttributes]], + ["GlobalAveragePool", [globalAveragePool, parseGlobalAveragePoolAttributes]], + ["GlobalMaxPool", [globalMaxPool, parseGlobalMaxPoolAttributes]], + ["Greater", [greater]], + ["GreaterOrEqual", [greaterOrEqual]], + ["HardSigmoid", [hardSigmoid, parseHardSigmoidAttributes]], + ["InstanceNormalization", [instanceNorm]], + ["LayerNormalization", [layerNorm]], + ["LeakyRelu", [leakyRelu, parseAlphaAttributes]], + ["Less", [less]], + ["LessOrEqual", [lessOrEqual]], + ["Log", [log]], + ["MatMul", [matMul]], + ["MatMulNBits", [matMulNBits, parseMatMulNBitsAttributes]], + // TODO: support new attributes for MaxPool-8 and MaxPool-10 + ["MaxPool", [maxPool, parseMaxPoolAttributes]], + ["Mul", [mul]], + ["MultiHeadAttention", [multiHeadAttention, parseMultiHeadAttentionAttributes]], + ["Neg", [neg]], + ["Not", [not]], + ["Pad", [pad]], + ["Pow", [pow]], + ["Range", [range]], + ["Reciprocal", [reciprocal]], + ["ReduceMin", [reduceMin]], + ["ReduceMean", [reduceMean]], + ["ReduceMax", [reduceMax]], + ["ReduceSum", [reduceSum]], + ["ReduceProd", [reduceProd]], + ["ReduceL1", [reduceL1]], + ["ReduceL2", [reduceL2]], + ["ReduceLogSum", [reduceLogSum]], + ["ReduceLogSumExp", [reduceLogSumExp]], + ["ReduceSumSquare", [reduceSumSquare]], + ["Relu", [relu]], + ["Resize", [resize, parseResizeAttributes]], + ["RotaryEmbedding", [rotaryEmbedding]], + ["Sigmoid", [sigmoid]], + ["Sin", [sin]], + ["Sinh", [sinh]], + ["Slice", [slice, parseSliceAttributes]], + ["SkipLayerNormalization", [skipLayerNorm]], + ["Split", [split, parseSplitAttributes]], + ["Sqrt", [sqrt]], + ["Softmax", [softmax, parseSoftmaxAttributes]], + ["Sub", [sub]], + ["Tan", [tan]], + ["Tanh", [tanh]], + ["ThresholdedRelu", [thresholdedRelu, parseAlphaAttributes]], + ["Tile", [tile]], + ["Transpose", [transpose, parseTransposeAttributes]], + ["Where", [where]] + ]); + } +}); + +// web/lib/wasm/jsep/webgpu/program-manager.ts +var ProgramManager; +var init_program_manager = __esm({ + "web/lib/wasm/jsep/webgpu/program-manager.ts"() { + "use strict"; + init_esm(); + init_log(); + init_common(); + ProgramManager = class { + constructor(backend) { + this.backend = backend; + this.repo = /* @__PURE__ */ new Map(); + this.attributesBound = false; + } + getArtifact(key) { + return this.repo.get(key); + } + setArtifact(key, artifact) { + this.repo.set(key, artifact); + } + run(buildArtifact, inputs, outputs, dispatchGroup, uniformBufferBinding) { + TRACE_FUNC_BEGIN(buildArtifact.programInfo.name); + const device = this.backend.device; + const computePassEncoder = this.backend.getComputePassEncoder(); + this.backend.writeTimestamp(this.backend.pendingDispatchNumber * 2); + const entries = []; + for (const input of inputs) { + entries.push({ binding: entries.length, resource: { buffer: input.buffer } }); + } + for (const output of outputs) { + entries.push({ binding: entries.length, resource: { buffer: output.buffer } }); + } + if (uniformBufferBinding) { + entries.push({ binding: entries.length, resource: uniformBufferBinding }); + } + const bindGroup = device.createBindGroup( + { layout: buildArtifact.computePipeline.getBindGroupLayout(0), entries, label: buildArtifact.programInfo.name } + ); + if (this.backend.sessionStatus === "capturing") { + const commandInfo = { + kernelId: this.backend.currentKernelId, + computePipeline: buildArtifact.computePipeline, + bindGroup, + dispatchGroup + }; + const sessionCommandList = this.backend.capturedCommandList.get(this.backend.currentSessionId); + sessionCommandList.push(commandInfo); + } + computePassEncoder.setPipeline(buildArtifact.computePipeline); + computePassEncoder.setBindGroup(0, bindGroup); + computePassEncoder.dispatchWorkgroups(...dispatchGroup); + this.backend.writeTimestamp(this.backend.pendingDispatchNumber * 2 + 1); + this.backend.pendingDispatchNumber++; + if (this.backend.pendingDispatchNumber >= this.backend.maxDispatchNumber || this.backend.queryType === "at-passes") { + this.backend.endComputePass(); + } + if (this.backend.pendingDispatchNumber >= this.backend.maxDispatchNumber) { + this.backend.flush(); + } + TRACE_FUNC_END(buildArtifact.programInfo.name); + } + dispose() { + } + build(programInfo, normalizedDispatchGroupSize) { + TRACE_FUNC_BEGIN(programInfo.name); + const device = this.backend.device; + const extensions = []; + if (device.features.has("shader-f16")) { + extensions.push("enable f16;"); + } + const shaderHelper = createShaderHelper(normalizedDispatchGroupSize, this.backend.device.limits); + const userCode = programInfo.getShaderSource(shaderHelper); + const code = `${extensions.join("\n")} +${shaderHelper.additionalImplementations} +${userCode}`; + const shaderModule = device.createShaderModule({ code, label: programInfo.name }); + LOG_DEBUG("verbose", () => `[WebGPU] ${programInfo.name} shader code: ${code}`); + const computePipeline = device.createComputePipeline( + { compute: { module: shaderModule, entryPoint: "main" }, layout: "auto", label: programInfo.name } + ); + TRACE_FUNC_END(programInfo.name); + return { programInfo, computePipeline, uniformVariablesInfo: shaderHelper.variablesInfo }; + } + normalizeDispatchGroupSize(dispatchGroup) { + const x = typeof dispatchGroup === "number" ? dispatchGroup : dispatchGroup.x; + const y = typeof dispatchGroup === "number" ? 1 : dispatchGroup.y || 1; + const z = typeof dispatchGroup === "number" ? 1 : dispatchGroup.z || 1; + const limitPerDimension = this.backend.device.limits.maxComputeWorkgroupsPerDimension; + if (x <= limitPerDimension && y <= limitPerDimension && z <= limitPerDimension) { + return [x, y, z]; + } + const size = x * y * z; + let dispatchAverage = Math.ceil(Math.sqrt(size)); + if (dispatchAverage > limitPerDimension) { + dispatchAverage = Math.ceil(Math.cbrt(size)); + if (dispatchAverage > limitPerDimension) { + throw new Error("Total dispatch size exceeds WebGPU maximum."); + } + return [dispatchAverage, dispatchAverage, dispatchAverage]; + } else { + return [dispatchAverage, dispatchAverage, 1]; + } + } + }; + } +}); + +// web/lib/wasm/jsep/backend-webgpu.ts +var getProgramInputTensorInfoDependencyKey, getProgramInfoUniqueKey, AdapterInfoImpl, WebGpuBackend; +var init_backend_webgpu = __esm({ + "web/lib/wasm/jsep/backend-webgpu.ts"() { + "use strict"; + init_esm(); + init_wasm_common(); + init_log(); + init_tensor_view(); + init_gpu_data_manager(); + init_op_resolve_rules(); + init_program_manager(); + getProgramInputTensorInfoDependencyKey = (inputTensors, inputDependencies) => { + if (inputDependencies.length !== inputTensors.length) { + throw new Error(`inputDependencies length ${inputDependencies.length} is not equal to inputTensors length ${inputTensors.length}.`); + } + const inputInfos = []; + for (let i = 0; i < inputTensors.length; ++i) { + const type = inputTensors[i].dataType; + switch (inputDependencies[i]) { + case "none": { + inputInfos.push(""); + break; + } + case "type": { + inputInfos.push(`${type}`); + break; + } + case "rank": { + const rank = inputTensors[i].dims.length; + inputInfos.push(`${type};${rank}`); + break; + } + case "dims": { + const dims = inputTensors[i].dims.join(","); + inputInfos.push(`${type};${dims}`); + break; + } + default: + throw new Error(`unsupported input dependency: ${inputDependencies[i]}`); + } + } + return inputInfos.join("|"); + }; + getProgramInfoUniqueKey = (programInfo, inputTensors, is1DimensionDispatch) => { + let key = programInfo.name; + if (programInfo.shaderCache?.hint) { + key += "[" + programInfo.shaderCache.hint + "]"; + } + key += ":" + is1DimensionDispatch + `:${getProgramInputTensorInfoDependencyKey( + inputTensors, + programInfo.shaderCache?.inputDependencies ?? new Array(inputTensors.length).fill("dims") + )}`; + return key; + }; + AdapterInfoImpl = class { + constructor(adapterInfo) { + if (adapterInfo) { + this.architecture = adapterInfo.architecture; + this.vendor = adapterInfo.vendor; + } + } + isArchitecture(architecture) { + return this.architecture === architecture; + } + isVendor(vendor) { + return this.vendor === vendor; + } + }; + WebGpuBackend = class { + constructor() { + /** + * representing the session ID of which is currently being run. + * `null` means no session is being run. + * only valid when session.run is executed. + */ + this.currentSessionId = null; + /** + * representing the kernel ID of which is currently being computed (CPU code perspective). + * `null` means no kernel is being computed. + * only one kernel can be computed at a moment. + */ + this.currentKernelId = null; + this.commandEncoder = null; + this.computePassEncoder = null; + this.maxDispatchNumber = 16; + this.pendingDispatchNumber = 0; + // info of kernels pending submission for a single batch + this.pendingKernels = []; + // queryReadBuffer -> pendingKernels mapping for all the batches + this.pendingQueries = /* @__PURE__ */ new Map(); + this.sessionStatus = "default"; + /** + * a SessionID -> CommandInfo[] mapping. It's used to record all GPU commands for corresponding session. + */ + this.capturedCommandList = /* @__PURE__ */ new Map(); + /** + * a SessionID -> PendingKernelInfo[] mapping for profiling. + */ + this.capturedPendingKernels = /* @__PURE__ */ new Map(); + /** + * a SessionID -> a Map of (InputOutputIndex -> [ID, GPUBuffer]) mapping. + */ + this.sessionExternalDataMapping = /* @__PURE__ */ new Map(); + } + /** + * get the custom data of the current kernel + */ + get currentKernelCustomData() { + if (this.currentKernelId === null) { + throw new Error("currentKernelCustomData(): currentKernelId is null. (should not happen)"); + } + let data = this.kernelCustomData.get(this.currentKernelId); + if (!data) { + data = {}; + this.kernelCustomData.set(this.currentKernelId, data); + } + return data; + } + async initialize(env3, adapter) { + this.env = env3; + const requiredFeatures = []; + const deviceDescriptor = { + requiredLimits: { + maxComputeWorkgroupStorageSize: adapter.limits.maxComputeWorkgroupStorageSize, + maxComputeWorkgroupsPerDimension: adapter.limits.maxComputeWorkgroupsPerDimension, + maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize, + maxBufferSize: adapter.limits.maxBufferSize, + maxComputeInvocationsPerWorkgroup: adapter.limits.maxComputeInvocationsPerWorkgroup, + maxComputeWorkgroupSizeX: adapter.limits.maxComputeWorkgroupSizeX, + maxComputeWorkgroupSizeY: adapter.limits.maxComputeWorkgroupSizeY, + maxComputeWorkgroupSizeZ: adapter.limits.maxComputeWorkgroupSizeZ + }, + requiredFeatures + }; + if (adapter.features.has("chromium-experimental-timestamp-query-inside-passes")) { + requiredFeatures.push("chromium-experimental-timestamp-query-inside-passes"); + } else if (adapter.features.has("timestamp-query")) { + requiredFeatures.push("timestamp-query"); + } + if (adapter.features.has("shader-f16")) { + requiredFeatures.push("shader-f16"); + } + this.device = await adapter.requestDevice(deviceDescriptor); + this.adapterInfo = new AdapterInfoImpl(await adapter.requestAdapterInfo()); + this.gpuDataManager = createGpuDataManager(this); + this.programManager = new ProgramManager(this); + this.kernels = /* @__PURE__ */ new Map(); + this.kernelPersistentData = /* @__PURE__ */ new Map(); + this.kernelCustomData = /* @__PURE__ */ new Map(); + configureLogger(env3.logLevel, !!env3.debug); + this.device.onuncapturederror = (ev) => { + if (ev.error instanceof GPUValidationError) { + console.error(`An uncaught WebGPU validation error was raised: ${ev.error.message}`); + } + }; + Object.defineProperty( + this.env.webgpu, + "device", + { value: this.device, writable: false, enumerable: true, configurable: false } + ); + Object.defineProperty( + this.env.webgpu, + "adapter", + { value: adapter, writable: false, enumerable: true, configurable: false } + ); + this.setQueryType(); + } + dispose() { + if (typeof this.querySet !== "undefined") { + this.querySet.destroy(); + } + this.gpuDataManager.dispose(); + } + getCommandEncoder() { + if (!this.commandEncoder) { + this.commandEncoder = this.device.createCommandEncoder(); + } + return this.commandEncoder; + } + getComputePassEncoder() { + if (!this.computePassEncoder) { + const commandEncoder = this.getCommandEncoder(); + const computePassDescriptor = {}; + if (this.queryType === "at-passes") { + computePassDescriptor.timestampWrites = { + querySet: this.querySet, + beginningOfPassWriteIndex: this.pendingDispatchNumber * 2, + endOfPassWriteIndex: this.pendingDispatchNumber * 2 + 1 + }; + } + this.computePassEncoder = commandEncoder.beginComputePass(computePassDescriptor); + } + return this.computePassEncoder; + } + endComputePass() { + if (this.computePassEncoder) { + this.computePassEncoder.end(); + this.computePassEncoder = null; + } + } + flush() { + if (!this.commandEncoder) { + return; + } + TRACE_FUNC_BEGIN(); + this.endComputePass(); + let queryReadBuffer; + if (this.queryType !== "none") { + this.commandEncoder.resolveQuerySet( + this.querySet, + 0, + this.pendingDispatchNumber * 2, + this.queryResolveBuffer, + 0 + ); + queryReadBuffer = this.device.createBuffer( + // eslint-disable-next-line no-bitwise + { size: this.pendingDispatchNumber * 2 * 8, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST } + ); + this.pendingQueries.set(queryReadBuffer, this.pendingKernels); + this.pendingKernels = []; + this.commandEncoder.copyBufferToBuffer( + this.queryResolveBuffer, + 0, + queryReadBuffer, + 0, + this.pendingDispatchNumber * 2 * 8 + ); + } + this.device.queue.submit([this.commandEncoder.finish()]); + this.gpuDataManager.refreshPendingBuffers(); + this.commandEncoder = null; + this.pendingDispatchNumber = 0; + if (this.queryType !== "none") { + void queryReadBuffer.mapAsync(GPUMapMode.READ).then(() => { + const mappedData = new BigUint64Array(queryReadBuffer.getMappedRange()); + const pendingKernels = this.pendingQueries.get(queryReadBuffer); + for (let i = 0; i < mappedData.length / 2; i++) { + const pendingKernelInfo = pendingKernels[i]; + const kernelId = pendingKernelInfo.kernelId; + const kernelInfo = this.kernels.get(kernelId); + const kernelType = kernelInfo.kernelType; + const kernelName = kernelInfo.kernelName; + const programName = pendingKernelInfo.programName; + const inputTensorViews = pendingKernelInfo.inputTensorViews; + const outputTensorViews = pendingKernelInfo.outputTensorViews; + const startTimeU64 = mappedData[i * 2]; + const endTimeU64 = mappedData[i * 2 + 1]; + if (typeof this.queryTimeBase === "undefined") { + this.queryTimeBase = startTimeU64; + } + const startTime = Number(startTimeU64 - this.queryTimeBase); + const endTime = Number(endTimeU64 - this.queryTimeBase); + if (!Number.isSafeInteger(startTime) || !Number.isSafeInteger(endTime)) { + throw new RangeError("incorrect timestamp range"); + } + if (this.env.webgpu.profiling?.ondata) { + this.env.webgpu.profiling.ondata({ + version: 1, + inputsMetadata: inputTensorViews.map( + (value) => ({ dims: value.dims, dataType: tensorDataTypeEnumToString(value.dataType) }) + ), + outputsMetadata: outputTensorViews.map( + (value) => ({ dims: value.dims, dataType: tensorDataTypeEnumToString(value.dataType) }) + ), + kernelId, + kernelType, + kernelName, + programName, + startTime, + endTime + }); + } else { + let inputShapes = ""; + inputTensorViews.forEach((value, i2) => { + inputShapes += `input[${i2}]: [${value.dims}] | ${tensorDataTypeEnumToString(value.dataType)}, `; + }); + let outputShapes = ""; + outputTensorViews.forEach((value, i2) => { + outputShapes += `output[${i2}]: [${value.dims}] | ${tensorDataTypeEnumToString(value.dataType)}, `; + }); + console.log(`[profiling] kernel "${kernelId}|${kernelType}|${kernelName}|${programName}" ${inputShapes}${outputShapes}execution time: ${endTime - startTime} ns`); + } + TRACE("GPU", `${programName}::${startTimeU64}::${endTimeU64}`); + } + queryReadBuffer.unmap(); + this.pendingQueries.delete(queryReadBuffer); + }); + } + TRACE_FUNC_END(); + } + /** + * run a WebGPU program. + * @param program a ProgramInfo instance + * @param inputTensorViews a TensorView array. each element represents a value already exists in GPU. + * @param outputIndices an indices array. each element can be either -1 (temporary data), -2 (persistent data) or an + * index to the kernel's output. + * @param createKernelOutput a callback function that create a value to kernel's output with the given index + * @param createIntermediateOutput a callback function that create a value as a intermediate value, either temporary + * or persistent (owned by the current kernel) + * @returns a TensorView array representing the result. + */ + run(program, inputTensorViews, outputIndices, createKernelOutput, createIntermediateOutput, outputCount) { + TRACE_FUNC_BEGIN(program.name); + const inputDatas = []; + for (let i = 0; i < inputTensorViews.length; ++i) { + const data = inputTensorViews[i].data; + if (data === 0) { + continue; + } + const gpuData = this.gpuDataManager.get(data); + if (!gpuData) { + throw new Error(`no GPU data for input: ${data}`); + } + inputDatas.push(gpuData); + } + const { outputs, dispatchGroup, programUniforms } = program.getRunData(inputTensorViews); + const validatedOutputIndices = outputIndices.length === 0 ? outputs.map((_, i) => i) : outputIndices; + if (validatedOutputIndices.length !== outputs.length) { + throw new Error(`Output size ${validatedOutputIndices.length} must be equal to ${outputs.length}.`); + } + const outputTensorViews = []; + const outputDatas = []; + for (let i = 0; i < outputs.length; ++i) { + if (!Number.isInteger(validatedOutputIndices[i]) || validatedOutputIndices[i] < -3 || validatedOutputIndices[i] >= outputCount) { + throw new Error(`Invalid output index: ${validatedOutputIndices[i]}`); + } + if (validatedOutputIndices[i] === -3) { + continue; + } + const isTemporary = validatedOutputIndices[i] === -1; + const isPersistent = validatedOutputIndices[i] === -2; + const tensorView = isTemporary || isPersistent ? createIntermediateOutput(outputs[i].dataType, outputs[i].dims) : createKernelOutput(validatedOutputIndices[i], outputs[i].dataType, outputs[i].dims); + outputTensorViews.push(tensorView); + if (tensorView.data === 0) { + continue; + } + const gpuData = this.gpuDataManager.get(tensorView.data); + if (!gpuData) { + throw new Error(`no GPU data for output: ${tensorView.data}`); + } + if (isTemporary) { + this.temporaryData.push(gpuData); + } + if (isPersistent) { + let persistentData = this.kernelPersistentData.get(this.currentKernelId); + if (!persistentData) { + persistentData = []; + this.kernelPersistentData.set(this.currentKernelId, persistentData); + } + persistentData.push(gpuData); + } + outputDatas.push(gpuData); + } + if (inputDatas.length !== inputTensorViews.length || outputDatas.length !== outputTensorViews.length) { + if (outputDatas.length === 0) { + TRACE_FUNC_END(program.name); + return outputTensorViews; + } + throw new Error( + `Program ${program.name} has zero-sized tensor(s) in inputs or outputs. This is not supported now.` + ); + } + let uniformBufferBinding; + if (programUniforms) { + let currentOffset = 0; + const offsets = []; + programUniforms.forEach((v) => { + const data = typeof v.data === "number" ? [v.data] : v.data; + if (data.length === 0) { + return; + } + const sizeOfElement = v.type === 10 /* float16 */ ? 2 : 4; + let sizeOfVecOrMat; + let baseAlignment; + if (v.type === 10 /* float16 */) { + baseAlignment = data.length > 4 ? 16 : data.length > 2 ? 8 : data.length * sizeOfElement; + sizeOfVecOrMat = data.length > 4 ? 16 : sizeOfElement * data.length; + } else { + baseAlignment = data.length <= 2 ? data.length * sizeOfElement : 16; + sizeOfVecOrMat = 16; + } + currentOffset = Math.ceil(currentOffset / baseAlignment) * baseAlignment; + offsets.push(currentOffset); + const elementPerVecOrMat = v.type === 10 /* float16 */ ? 8 : 4; + currentOffset += data.length > 4 ? Math.ceil(data.length / elementPerVecOrMat) * sizeOfVecOrMat : data.length * sizeOfElement; + }); + const maxAlignmentOfField = 16; + currentOffset = Math.ceil(currentOffset / maxAlignmentOfField) * maxAlignmentOfField; + const arrayBuffer = new ArrayBuffer(currentOffset); + programUniforms.forEach((v, i) => { + const offset = offsets[i]; + const data = typeof v.data === "number" ? [v.data] : v.data; + if (v.type === 6 /* int32 */) { + new Int32Array(arrayBuffer, offset, data.length).set(data); + } else if (v.type === 12 /* uint32 */) { + new Uint32Array(arrayBuffer, offset, data.length).set(data); + } else if (v.type === 10 /* float16 */) { + new Uint16Array(arrayBuffer, offset, data.length).set(data); + } else if (v.type === 1 /* float */) { + new Float32Array(arrayBuffer, offset, data.length).set(data); + } else { + throw new Error(`Unsupported uniform type: ${tensorDataTypeEnumToString(v.type)}`); + } + }); + const uniformBufferData = ( + // eslint-disable-next-line no-bitwise + this.gpuDataManager.create(currentOffset, GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM) + ); + this.device.queue.writeBuffer(uniformBufferData.buffer, 0, arrayBuffer, 0, currentOffset); + this.gpuDataManager.release(uniformBufferData.id); + uniformBufferBinding = { offset: 0, size: currentOffset, buffer: uniformBufferData.buffer }; + } + const normalizedDispatchGroup = this.programManager.normalizeDispatchGroupSize(dispatchGroup); + const is1DimensionDispatch = normalizedDispatchGroup[1] === 1 && normalizedDispatchGroup[2] === 1; + const key = getProgramInfoUniqueKey(program, inputTensorViews, is1DimensionDispatch); + let artifact = this.programManager.getArtifact(key); + if (!artifact) { + artifact = this.programManager.build(program, normalizedDispatchGroup); + this.programManager.setArtifact(key, artifact); + LOG_DEBUG("info", () => `[artifact] key: ${key}, programName: ${program.name}`); + } + if (programUniforms && artifact.uniformVariablesInfo) { + if (programUniforms.length !== artifact.uniformVariablesInfo.length) { + throw new Error(`Uniform variables count mismatch: expect ${artifact.uniformVariablesInfo.length}, got ${programUniforms.length} in program "${artifact.programInfo.name}".`); + } + for (let i = 0; i < programUniforms.length; i++) { + const uniform = programUniforms[i]; + const actualType = uniform.type; + const actualLength = typeof uniform.data === "number" ? 1 : uniform.data.length; + const [type, length] = artifact.uniformVariablesInfo[i]; + if (actualType !== type || actualLength !== length) { + throw new Error(`Uniform variable ${i} mismatch: expect type ${type} with size ${length}, got type ${actualType} with size ${actualLength} in program "${artifact.programInfo.name}".`); + } + } + } + LOG_DEBUG( + "info", + () => `[ProgramManager] run "${program.name}" (key=${key}) with ${normalizedDispatchGroup[0]}x${normalizedDispatchGroup[1]}x${normalizedDispatchGroup[2]}` + ); + if (this.queryType !== "none" || this.sessionStatus === "capturing") { + const pendingKernelInfo = { + kernelId: this.currentKernelId, + programName: artifact.programInfo.name, + inputTensorViews, + outputTensorViews + }; + this.pendingKernels.push(pendingKernelInfo); + if (this.sessionStatus === "capturing") { + const sessionPendingKernels = this.capturedPendingKernels.get(this.currentSessionId); + sessionPendingKernels.push(pendingKernelInfo); + } + } + this.programManager.run(artifact, inputDatas, outputDatas, normalizedDispatchGroup, uniformBufferBinding); + TRACE_FUNC_END(program.name); + return outputTensorViews; + } + upload(gpuDataId, data) { + this.gpuDataManager.upload(gpuDataId, data); + } + memcpy(src, dst) { + this.gpuDataManager.memcpy(src, dst); + } + async download(gpuDataId, getTargetBuffer) { + await this.gpuDataManager.download(gpuDataId, getTargetBuffer); + } + alloc(size) { + return this.gpuDataManager.create(size).id; + } + free(ptr) { + return this.gpuDataManager.release(ptr); + } + createKernel(kernelType, kernelId, attribute, kernelName) { + const op = WEBGPU_OP_RESOLVE_RULES.get(kernelType); + if (!op) { + throw new Error(`kernel not implemented: ${kernelType}`); + } + const kernelInfo = { + kernelType, + kernelName, + kernelEntry: op[0], + attributes: [op[1], attribute] + }; + this.kernels.set(kernelId, kernelInfo); + } + releaseKernel(kernelId) { + const persistentData = this.kernelPersistentData.get(kernelId); + if (persistentData) { + for (const data of persistentData) { + this.gpuDataManager.release(data.id); + } + this.kernelPersistentData.delete(kernelId); + } + this.kernelCustomData.delete(kernelId); + this.kernels.delete(kernelId); + } + computeKernel(kernelId, context, errors) { + const kernel = this.kernels.get(kernelId); + if (!kernel) { + throw new Error(`kernel not created: ${kernelId}`); + } + const kernelType = kernel.kernelType; + const kernelName = kernel.kernelName; + const kernelEntry = kernel.kernelEntry; + const attributes = kernel.attributes; + if (this.currentKernelId !== null) { + throw new Error(`kernel "[${kernelType}] ${kernelName}" is not allowed to be called recursively`); + } + this.currentKernelId = kernelId; + if (attributes[0]) { + attributes[1] = attributes[0](attributes[1]); + attributes[0] = void 0; + } + LOG_DEBUG("info", () => `[WebGPU] Start to run kernel "[${kernelType}] ${kernelName}"...`); + const useErrorScope = this.env.debug; + this.temporaryData = []; + try { + if (useErrorScope) { + this.device.pushErrorScope("validation"); + } + kernelEntry(context, attributes[1]); + return 0; + } catch (e) { + errors.push(Promise.resolve(`[WebGPU] Kernel "[${kernelType}] ${kernelName}" failed. ${e}`)); + return 1; + } finally { + if (useErrorScope) { + errors.push(this.device.popErrorScope().then( + (err) => err ? `GPU validation error for kernel "[${kernelType}] ${kernelName}": ${err.message}` : null + )); + } + for (const data of this.temporaryData) { + this.gpuDataManager.release(data.id); + } + this.temporaryData = []; + this.currentKernelId = null; + } + } + // #region external buffer + registerBuffer(sessionId, index, buffer, size) { + let sessionInputOutputMapping = this.sessionExternalDataMapping.get(sessionId); + if (!sessionInputOutputMapping) { + sessionInputOutputMapping = /* @__PURE__ */ new Map(); + this.sessionExternalDataMapping.set(sessionId, sessionInputOutputMapping); + } + const previousBuffer = sessionInputOutputMapping.get(index); + const id = this.gpuDataManager.registerExternalBuffer(buffer, size, previousBuffer?.[1]); + sessionInputOutputMapping.set(index, [id, buffer]); + return id; + } + unregisterBuffers(sessionId) { + const sessionInputOutputMapping = this.sessionExternalDataMapping.get(sessionId); + if (sessionInputOutputMapping) { + sessionInputOutputMapping.forEach((bufferInfo) => this.gpuDataManager.unregisterExternalBuffer(bufferInfo[1])); + this.sessionExternalDataMapping.delete(sessionId); + } + } + getBuffer(gpuDataId) { + const gpuData = this.gpuDataManager.get(gpuDataId); + if (!gpuData) { + throw new Error(`no GPU data for buffer: ${gpuDataId}`); + } + return gpuData.buffer; + } + createDownloader(gpuBuffer, size, type) { + return async () => { + const data = await downloadGpuData(this, gpuBuffer, size); + return createView(data.buffer, type); + }; + } + // #endregion + writeTimestamp(index) { + if (this.queryType !== "inside-passes") { + return; + } + this.computePassEncoder.writeTimestamp(this.querySet, index); + } + setQueryType() { + this.queryType = "none"; + if (this.env.webgpu.profiling?.mode === "default" || (typeof this.env.trace === "undefined" ? this.env.wasm.trace : this.env.trace)) { + if (this.device.features.has("chromium-experimental-timestamp-query-inside-passes")) { + this.queryType = "inside-passes"; + } else if (this.device.features.has("timestamp-query")) { + this.queryType = "at-passes"; + } + if (this.queryType !== "none" && typeof this.querySet === "undefined") { + this.querySet = this.device.createQuerySet({ + type: "timestamp", + count: this.maxDispatchNumber * 2 + }); + this.queryResolveBuffer = this.device.createBuffer( + // eslint-disable-next-line no-bitwise + { size: this.maxDispatchNumber * 2 * 8, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE } + ); + } + } + } + captureBegin() { + LOG_DEBUG("info", "captureBegin"); + if (!this.capturedCommandList.get(this.currentSessionId)) { + this.capturedCommandList.set(this.currentSessionId, []); + } + if (!this.capturedPendingKernels.get(this.currentSessionId)) { + this.capturedPendingKernels.set(this.currentSessionId, []); + } + this.flush(); + this.sessionStatus = "capturing"; + } + captureEnd() { + LOG_DEBUG("info", "captureEnd"); + this.flush(); + this.sessionStatus = "default"; + } + replay() { + LOG_DEBUG("info", "replay"); + this.sessionStatus = "replaying"; + const sessionCommandList = this.capturedCommandList.get(this.currentSessionId); + const sessionPendingKernels = this.capturedPendingKernels.get(this.currentSessionId); + const length = sessionCommandList.length; + this.pendingKernels = []; + for (let i = 0; i < length; i++) { + const computePassEncoder = this.getComputePassEncoder(); + const command = sessionCommandList[i]; + this.writeTimestamp(this.pendingDispatchNumber * 2); + computePassEncoder.setPipeline(command.computePipeline); + computePassEncoder.setBindGroup(0, command.bindGroup); + computePassEncoder.dispatchWorkgroups(...command.dispatchGroup); + this.writeTimestamp(this.pendingDispatchNumber * 2 + 1); + this.pendingDispatchNumber++; + if (this.queryType !== "none") { + this.pendingKernels.push(sessionPendingKernels[i]); + } + if (this.pendingDispatchNumber >= this.maxDispatchNumber || this.queryType === "at-passes") { + this.endComputePass(); + } + if (this.pendingDispatchNumber >= this.maxDispatchNumber) { + this.flush(); + } + } + this.flush(); + this.sessionStatus = "default"; + } + onReleaseSession(sessionId) { + this.unregisterBuffers(sessionId); + if (this.capturedCommandList.has(sessionId)) { + this.capturedCommandList.delete(sessionId); + } + if (this.capturedPendingKernels.has(sessionId)) { + this.capturedPendingKernels.delete(sessionId); + } + this.gpuDataManager.onReleaseSession(sessionId); + } + onRunStart(sessionId) { + this.currentSessionId = sessionId; + this.setQueryType(); + } + }; + } +}); + +// web/lib/wasm/jsep/init.ts +var init_exports = {}; +__export(init_exports, { + init: () => init +}); +var TensorViewImpl, ComputeContextImpl, init; +var init_init = __esm({ + "web/lib/wasm/jsep/init.ts"() { + "use strict"; + init_wasm_common(); + init_backend_webgpu(); + init_log(); + init_util(); + TensorViewImpl = class _TensorViewImpl { + constructor(module, dataType, data, dims) { + this.module = module; + this.dataType = dataType; + this.data = data; + this.dims = dims; + } + getFloat32Array() { + if (this.dataType !== 1 /* float */) { + throw new Error("Invalid data type"); + } + const elementCount = ShapeUtil.size(this.dims); + return elementCount === 0 ? new Float32Array() : new Float32Array(this.module.HEAP8.buffer, this.data, elementCount); + } + getBigInt64Array() { + if (this.dataType !== 7 /* int64 */) { + throw new Error("Invalid data type"); + } + const elementCount = ShapeUtil.size(this.dims); + return elementCount === 0 ? new BigInt64Array() : new BigInt64Array(this.module.HEAP8.buffer, this.data, elementCount); + } + getInt32Array() { + if (this.dataType !== 6 /* int32 */) { + throw new Error("Invalid data type"); + } + const elementCount = ShapeUtil.size(this.dims); + return elementCount === 0 ? new Int32Array() : new Int32Array(this.module.HEAP8.buffer, this.data, elementCount); + } + reshape(newDims) { + if (ShapeUtil.size(newDims) !== ShapeUtil.size(this.dims)) { + throw new Error("Invalid new shape"); + } + return new _TensorViewImpl(this.module, this.dataType, this.data, newDims); + } + }; + ComputeContextImpl = class { + constructor(module, backend, contextDataOffset) { + this.module = module; + this.backend = backend; + this.customDataOffset = 0; + this.customDataSize = 0; + this.adapterInfo = backend.adapterInfo; + const heapU32 = module.HEAPU32; + let dataIndex = contextDataOffset >>> 2; + this.opKernelContext = heapU32[dataIndex++]; + const inputCount = heapU32[dataIndex++]; + this.outputCount = heapU32[dataIndex++]; + this.customDataOffset = heapU32[dataIndex++]; + this.customDataSize = heapU32[dataIndex++]; + const inputs = []; + for (let i = 0; i < inputCount; i++) { + const dataType = heapU32[dataIndex++]; + const data = heapU32[dataIndex++]; + const dim = heapU32[dataIndex++]; + const dims = []; + for (let d = 0; d < dim; d++) { + dims.push(heapU32[dataIndex++]); + } + inputs.push(new TensorViewImpl(module, dataType, data, dims)); + } + this.inputs = inputs; + } + get kernelCustomData() { + return this.backend.currentKernelCustomData; + } + get customDataBuffer() { + return this.module.HEAPU8.subarray(this.customDataOffset, this.customDataOffset + this.customDataSize); + } + getMaxComputeWorkgroupSizes() { + return [ + this.backend.device.limits.maxComputeWorkgroupSizeX, + this.backend.device.limits.maxComputeWorkgroupSizeY, + this.backend.device.limits.maxComputeWorkgroupSizeZ + ]; + } + getMaxComputeWorkgroupStoragesize() { + return this.backend.device.limits.maxComputeWorkgroupStorageSize; + } + compute(program, inputsOutputsMapping) { + const mappedInputs = inputsOutputsMapping?.inputs?.map((i) => typeof i === "number" ? this.inputs[i] : i) ?? this.inputs; + const outputIndices = inputsOutputsMapping?.outputs ?? []; + const createKernelOutput = (index, dataType, dims) => new TensorViewImpl(this.module, dataType, this.output(index, dims), dims); + const createTemporaryOutput = (dataType, dims) => { + const elementSize = getTensorElementSize(dataType); + if (!elementSize) { + throw new Error(`Unsupported data type: ${dataType}`); + } + const bufferSize = elementSize * ShapeUtil.size(dims); + const gpuDataId = bufferSize > 0 ? this.backend.gpuDataManager.create(bufferSize).id : 0; + return new TensorViewImpl(this.module, dataType, gpuDataId, dims); + }; + return this.backend.run( + program, + mappedInputs, + outputIndices, + createKernelOutput, + createTemporaryOutput, + this.outputCount + ); + } + output(index, dims) { + const stack = this.module.stackSave(); + try { + const data = this.module.stackAlloc( + (1 + dims.length) * 4 + /* sizeof(size_t) */ + ); + let offset = data >> 2; + this.module.HEAPU32[offset++] = dims.length; + for (let i = 0; i < dims.length; i++) { + this.module.HEAPU32[offset++] = dims[i]; + } + return this.module._JsepOutput(this.opKernelContext, index, data); + } catch (e) { + throw new Error( + `Failed to generate kernel's output[${index}] with dims [${dims}]. If you are running with pre-allocated output, please make sure the output type/dims are correct. Error: ${e}` + ); + } finally { + this.module.stackRestore(stack); + } + } + }; + init = async (name, module, env3, gpuAdapter) => { + const jsepInit = module.jsepInit; + if (!jsepInit) { + throw new Error("Failed to initialize JSEP. The WebAssembly module is not built with JSEP support."); + } + if (name === "webgpu") { + const backend = new WebGpuBackend(); + await backend.initialize(env3, gpuAdapter); + jsepInit("webgpu", [ + // backend + backend, + // jsepAlloc() + (size) => backend.alloc(size), + // jsepFree() + (ptr) => backend.free(ptr), + // jsepCopy(src, dst, size, isSourceGpu) + (src, dst, size, isSourceGpu = false) => { + if (isSourceGpu) { + LOG_DEBUG("verbose", () => `[WebGPU] jsepCopyGpuToGpu: src=${src}, dst=${dst}, size=${size}`); + backend.memcpy(src, dst); + } else { + LOG_DEBUG("verbose", () => `[WebGPU] jsepCopyCpuToGpu: dataOffset=${src}, gpuDataId=${dst}, size=${size}`); + const data = module.HEAPU8.subarray(src >>> 0, (src >>> 0) + size); + backend.upload(dst, data); + } + }, + // jsepCopyAsync(src, dst, size) + async (gpuDataId, dataOffset, size) => { + LOG_DEBUG( + "verbose", + () => `[WebGPU] jsepCopyGpuToCpu: gpuDataId=${gpuDataId}, dataOffset=${dataOffset}, size=${size}` + ); + await backend.download( + gpuDataId, + () => module.HEAPU8.subarray(dataOffset >>> 0, (dataOffset >>> 0) + size) + ); + }, + // jsepCreateKernel + (kernelType, kernelId, attribute) => backend.createKernel( + kernelType, + kernelId, + attribute, + module.UTF8ToString(module._JsepGetNodeName(kernelId)) + ), + // jsepReleaseKernel + (kernel) => backend.releaseKernel(kernel), + // jsepRun + (kernel, contextDataOffset, sessionHandle, errors) => { + LOG_DEBUG( + "verbose", + () => `[WebGPU] jsepRun: sessionHandle=${sessionHandle}, kernel=${kernel}, contextDataOffset=${contextDataOffset}` + ); + const context = new ComputeContextImpl(module, backend, contextDataOffset); + return backend.computeKernel(kernel, context, errors); + }, + // jsepCaptureBegin + () => backend.captureBegin(), + // jsepCaptureEnd + () => backend.captureEnd(), + // jsepReplay + () => backend.replay() + ]); + } else { + jsepInit("webnn"); + } + }; + } +}); + +// web/lib/wasm/wasm-core-impl.ts +var initOrt, initRuntime, initEp, activeSessions, getSessionInputOutputCount, copyFromExternalBuffer, createSession, releaseSession, prepareInputOutputTensor, run, endProfiling, extractTransferableBuffers; +var init_wasm_core_impl = __esm({ + "web/lib/wasm/wasm-core-impl.ts"() { + "use strict"; + init_run_options(); + init_session_options(); + init_wasm_common(); + init_wasm_factory(); + init_wasm_utils(); + init_wasm_utils_load_file(); + initOrt = (numThreads, loggingLevel) => { + const errorCode = getInstance()._OrtInit(numThreads, loggingLevel); + if (errorCode !== 0) { + checkLastError("Can't initialize onnxruntime."); + } + }; + initRuntime = async (env3) => { + initOrt(env3.wasm.numThreads, logLevelStringToEnum(env3.logLevel)); + }; + initEp = async (env3, epName) => { + if (true) { + const initJsep = (init_init(), __toCommonJS(init_exports)).init; + if (epName === "webgpu") { + if (typeof navigator === "undefined" || !navigator.gpu) { + throw new Error("WebGPU is not supported in current environment"); + } + let adapter = env3.webgpu.adapter; + if (!adapter) { + const powerPreference = env3.webgpu.powerPreference; + if (powerPreference !== void 0 && powerPreference !== "low-power" && powerPreference !== "high-performance") { + throw new Error(`Invalid powerPreference setting: "${powerPreference}"`); + } + const forceFallbackAdapter = env3.webgpu.forceFallbackAdapter; + if (forceFallbackAdapter !== void 0 && typeof forceFallbackAdapter !== "boolean") { + throw new Error(`Invalid forceFallbackAdapter setting: "${forceFallbackAdapter}"`); + } + adapter = await navigator.gpu.requestAdapter({ powerPreference, forceFallbackAdapter }); + if (!adapter) { + throw new Error( + 'Failed to get GPU adapter. You may need to enable flag "--enable-unsafe-webgpu" if you are using Chrome.' + ); + } + } else { + if (typeof adapter.limits !== "object" || typeof adapter.features !== "object" || typeof adapter.requestDevice !== "function") { + throw new Error("Invalid GPU adapter set in `env.webgpu.adapter`. It must be a GPUAdapter object."); + } + } + if (!env3.wasm.simd) { + throw new Error( + "Not supported for WebGPU=ON and SIMD=OFF. Please set `env.wasm.simd` to true when using `webgpu` EP" + ); + } + await initJsep("webgpu", getInstance(), env3, adapter); + } + if (epName === "webnn") { + if (typeof navigator === "undefined" || !navigator.ml) { + throw new Error("WebNN is not supported in current environment"); + } + await initJsep("webnn", getInstance(), env3); + } + } + }; + activeSessions = /* @__PURE__ */ new Map(); + getSessionInputOutputCount = (sessionHandle) => { + const wasm2 = getInstance(); + const stack = wasm2.stackSave(); + try { + const dataOffset = wasm2.stackAlloc(8); + const errorCode = wasm2._OrtGetInputOutputCount(sessionHandle, dataOffset, dataOffset + 4); + if (errorCode !== 0) { + checkLastError("Can't get session input/output count."); + } + return [wasm2.HEAP32[dataOffset / 4], wasm2.HEAP32[dataOffset / 4 + 1]]; + } finally { + wasm2.stackRestore(stack); + } + }; + copyFromExternalBuffer = (model) => { + const wasm2 = getInstance(); + const modelDataOffset = wasm2._malloc(model.byteLength); + if (modelDataOffset === 0) { + throw new Error(`Can't create a session. failed to allocate a buffer of size ${model.byteLength}.`); + } + wasm2.HEAPU8.set(model, modelDataOffset); + return [modelDataOffset, model.byteLength]; + }; + createSession = async (modelData, options) => { + let modelDataOffset, modelDataLength; + const wasm2 = getInstance(); + if (Array.isArray(modelData)) { + [modelDataOffset, modelDataLength] = modelData; + } else if (modelData.buffer === wasm2.HEAPU8.buffer) { + [modelDataOffset, modelDataLength] = [modelData.byteOffset, modelData.byteLength]; + } else { + [modelDataOffset, modelDataLength] = copyFromExternalBuffer(modelData); + } + let sessionHandle = 0; + let sessionOptionsHandle = 0; + let ioBindingHandle = 0; + let allocs = []; + const inputNamesUTF8Encoded = []; + const outputNamesUTF8Encoded = []; + try { + [sessionOptionsHandle, allocs] = setSessionOptions(options); + if (options?.externalData && wasm2.mountExternalData) { + const loadingPromises = []; + for (const file of options.externalData) { + const path = typeof file === "string" ? file : file.path; + loadingPromises.push(loadFile(typeof file === "string" ? file : file.data).then((data) => { + wasm2.mountExternalData(path, data); + })); + } + await Promise.all(loadingPromises); + } + sessionHandle = await wasm2._OrtCreateSession(modelDataOffset, modelDataLength, sessionOptionsHandle); + if (sessionHandle === 0) { + checkLastError("Can't create a session."); + } + const [inputCount, outputCount] = getSessionInputOutputCount(sessionHandle); + const enableGraphCapture = !!options?.enableGraphCapture; + const inputNames = []; + const outputNames = []; + const outputPreferredLocations = []; + for (let i = 0; i < inputCount; i++) { + const name = wasm2._OrtGetInputName(sessionHandle, i); + if (name === 0) { + checkLastError("Can't get an input name."); + } + inputNamesUTF8Encoded.push(name); + inputNames.push(wasm2.UTF8ToString(name)); + } + for (let i = 0; i < outputCount; i++) { + const name = wasm2._OrtGetOutputName(sessionHandle, i); + if (name === 0) { + checkLastError("Can't get an output name."); + } + outputNamesUTF8Encoded.push(name); + const nameString = wasm2.UTF8ToString(name); + outputNames.push(nameString); + if (true) { + if (enableGraphCapture && options?.preferredOutputLocation === void 0) { + outputPreferredLocations.push("gpu-buffer"); + continue; + } + const location = typeof options?.preferredOutputLocation === "string" ? options.preferredOutputLocation : options?.preferredOutputLocation?.[nameString] ?? "cpu"; + if (location !== "cpu" && location !== "cpu-pinned" && location !== "gpu-buffer") { + throw new Error(`Not supported preferred output location: ${location}.`); + } + if (enableGraphCapture && location !== "gpu-buffer") { + throw new Error(`Not supported preferred output location: ${location}. Only 'gpu-buffer' location is supported when enableGraphCapture is true.`); + } + outputPreferredLocations.push(location); + } + } + let bindingState = null; + if (outputPreferredLocations.some((l) => l === "gpu-buffer")) { + ioBindingHandle = wasm2._OrtCreateBinding(sessionHandle); + if (ioBindingHandle === 0) { + checkLastError("Can't create IO binding."); + } + bindingState = { + handle: ioBindingHandle, + outputPreferredLocations, + outputPreferredLocationsEncoded: outputPreferredLocations.map((l) => dataLocationStringToEnum(l)) + }; + } + activeSessions.set( + sessionHandle, + [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, bindingState, enableGraphCapture, false] + ); + return [sessionHandle, inputNames, outputNames]; + } catch (e) { + inputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf)); + outputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf)); + if (ioBindingHandle !== 0) { + wasm2._OrtReleaseBinding(ioBindingHandle); + } + if (sessionHandle !== 0) { + wasm2._OrtReleaseSession(sessionHandle); + } + throw e; + } finally { + wasm2._free(modelDataOffset); + if (sessionOptionsHandle !== 0) { + wasm2._OrtReleaseSessionOptions(sessionOptionsHandle); + } + allocs.forEach((alloc) => wasm2._free(alloc)); + wasm2.unmountExternalData?.(); + } + }; + releaseSession = (sessionId) => { + const wasm2 = getInstance(); + const session = activeSessions.get(sessionId); + if (!session) { + throw new Error(`cannot release session. invalid session id: ${sessionId}`); + } + const [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture] = session; + if (ioBindingState) { + if (enableGraphCapture) { + wasm2._OrtClearBoundOutputs(ioBindingState.handle); + } + wasm2._OrtReleaseBinding(ioBindingState.handle); + } + wasm2.jsepOnReleaseSession?.(sessionId); + inputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf)); + outputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf)); + wasm2._OrtReleaseSession(sessionHandle); + activeSessions.delete(sessionId); + }; + prepareInputOutputTensor = (tensor, tensorHandles, allocs, sessionId, index, enableGraphCapture = false) => { + if (!tensor) { + tensorHandles.push(0); + return; + } + const wasm2 = getInstance(); + const dataType = tensor[0]; + const dims = tensor[1]; + const location = tensor[3]; + let rawData; + let dataByteLength; + if (dataType === "string" && location === "gpu-buffer") { + throw new Error("String tensor is not supported on GPU."); + } + if (enableGraphCapture && location !== "gpu-buffer") { + throw new Error( + `External buffer must be provided for input/output index ${index} when enableGraphCapture is true.` + ); + } + if (location === "gpu-buffer") { + const gpuBuffer = tensor[2].gpuBuffer; + const elementSizeInBytes = getTensorElementSize(tensorDataTypeStringToEnum(dataType)); + dataByteLength = dims.reduce((a, b) => a * b, 1) * elementSizeInBytes; + const registerBuffer = wasm2.jsepRegisterBuffer; + if (!registerBuffer) { + throw new Error('Tensor location "gpu-buffer" is not supported without using WebGPU.'); + } + rawData = registerBuffer(sessionId, index, gpuBuffer, dataByteLength); + } else { + const data = tensor[2]; + if (Array.isArray(data)) { + dataByteLength = 4 * data.length; + rawData = wasm2._malloc(dataByteLength); + allocs.push(rawData); + let dataIndex = rawData / 4; + for (let i = 0; i < data.length; i++) { + if (typeof data[i] !== "string") { + throw new TypeError(`tensor data at index ${i} is not a string`); + } + wasm2.HEAPU32[dataIndex++] = allocWasmString(data[i], allocs); + } + } else { + dataByteLength = data.byteLength; + rawData = wasm2._malloc(dataByteLength); + allocs.push(rawData); + wasm2.HEAPU8.set(new Uint8Array(data.buffer, data.byteOffset, dataByteLength), rawData); + } + } + const stack = wasm2.stackSave(); + const dimsOffset = wasm2.stackAlloc(4 * dims.length); + try { + let dimIndex = dimsOffset / 4; + dims.forEach((d) => wasm2.HEAP32[dimIndex++] = d); + const tensor2 = wasm2._OrtCreateTensor( + tensorDataTypeStringToEnum(dataType), + rawData, + dataByteLength, + dimsOffset, + dims.length, + dataLocationStringToEnum(location) + ); + if (tensor2 === 0) { + checkLastError(`Can't create tensor for input/output. session=${sessionId}, index=${index}.`); + } + tensorHandles.push(tensor2); + } finally { + wasm2.stackRestore(stack); + } + }; + run = async (sessionId, inputIndices, inputTensors, outputIndices, outputTensors, options) => { + const wasm2 = getInstance(); + const session = activeSessions.get(sessionId); + if (!session) { + throw new Error(`cannot run inference. invalid session id: ${sessionId}`); + } + const sessionHandle = session[0]; + const inputNamesUTF8Encoded = session[1]; + const outputNamesUTF8Encoded = session[2]; + const ioBindingState = session[3]; + const enableGraphCapture = session[4]; + const inputOutputBound = session[5]; + const inputCount = inputIndices.length; + const outputCount = outputIndices.length; + let runOptionsHandle = 0; + let runOptionsAllocs = []; + const inputTensorHandles = []; + const outputTensorHandles = []; + const inputOutputAllocs = []; + const beforeRunStack = wasm2.stackSave(); + const inputValuesOffset = wasm2.stackAlloc(inputCount * 4); + const inputNamesOffset = wasm2.stackAlloc(inputCount * 4); + const outputValuesOffset = wasm2.stackAlloc(outputCount * 4); + const outputNamesOffset = wasm2.stackAlloc(outputCount * 4); + try { + [runOptionsHandle, runOptionsAllocs] = setRunOptions(options); + for (let i = 0; i < inputCount; i++) { + prepareInputOutputTensor( + inputTensors[i], + inputTensorHandles, + inputOutputAllocs, + sessionId, + inputIndices[i], + enableGraphCapture + ); + } + for (let i = 0; i < outputCount; i++) { + prepareInputOutputTensor( + outputTensors[i], + outputTensorHandles, + inputOutputAllocs, + sessionId, + inputCount + outputIndices[i], + enableGraphCapture + ); + } + let inputValuesIndex = inputValuesOffset / 4; + let inputNamesIndex = inputNamesOffset / 4; + let outputValuesIndex = outputValuesOffset / 4; + let outputNamesIndex = outputNamesOffset / 4; + for (let i = 0; i < inputCount; i++) { + wasm2.HEAPU32[inputValuesIndex++] = inputTensorHandles[i]; + wasm2.HEAPU32[inputNamesIndex++] = inputNamesUTF8Encoded[inputIndices[i]]; + } + for (let i = 0; i < outputCount; i++) { + wasm2.HEAPU32[outputValuesIndex++] = outputTensorHandles[i]; + wasm2.HEAPU32[outputNamesIndex++] = outputNamesUTF8Encoded[outputIndices[i]]; + } + if (ioBindingState && !inputOutputBound) { + const { handle, outputPreferredLocations, outputPreferredLocationsEncoded } = ioBindingState; + if (inputNamesUTF8Encoded.length !== inputCount) { + throw new Error(`input count from feeds (${inputCount}) is expected to be always equal to model's input count (${inputNamesUTF8Encoded.length}).`); + } + for (let i = 0; i < inputCount; i++) { + const index = inputIndices[i]; + const errorCode2 = await wasm2._OrtBindInput(handle, inputNamesUTF8Encoded[index], inputTensorHandles[i]); + if (errorCode2 !== 0) { + checkLastError(`Can't bind input[${i}] for session=${sessionId}.`); + } + } + for (let i = 0; i < outputCount; i++) { + const index = outputIndices[i]; + const location = outputTensors[i]?.[3]; + if (location) { + const errorCode2 = wasm2._OrtBindOutput(handle, outputNamesUTF8Encoded[index], outputTensorHandles[i], 0); + if (errorCode2 !== 0) { + checkLastError(`Can't bind pre-allocated output[${i}] for session=${sessionId}.`); + } + } else { + const errorCode2 = wasm2._OrtBindOutput(handle, outputNamesUTF8Encoded[index], 0, outputPreferredLocationsEncoded[index]); + if (errorCode2 !== 0) { + checkLastError(`Can't bind output[${i}] to ${outputPreferredLocations[i]} for session=${sessionId}.`); + } + } + } + activeSessions.set( + sessionId, + [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture, true] + ); + } + wasm2.jsepOnRunStart?.(sessionHandle); + let errorCode; + if (ioBindingState) { + errorCode = await wasm2._OrtRunWithBinding( + sessionHandle, + ioBindingState.handle, + outputCount, + outputValuesOffset, + runOptionsHandle + ); + } else { + errorCode = await wasm2._OrtRun( + sessionHandle, + inputNamesOffset, + inputValuesOffset, + inputCount, + outputNamesOffset, + outputCount, + outputValuesOffset, + runOptionsHandle + ); + } + if (errorCode !== 0) { + checkLastError("failed to call OrtRun()."); + } + const output = []; + for (let i = 0; i < outputCount; i++) { + const tensor = wasm2.HEAPU32[outputValuesOffset / 4 + i]; + if (tensor === outputTensorHandles[i]) { + output.push(outputTensors[i]); + continue; + } + const beforeGetTensorDataStack = wasm2.stackSave(); + const tensorDataOffset = wasm2.stackAlloc(4 * 4); + let keepOutputTensor = false; + let type, dataOffset = 0; + try { + const errorCode2 = wasm2._OrtGetTensorData( + tensor, + tensorDataOffset, + tensorDataOffset + 4, + tensorDataOffset + 8, + tensorDataOffset + 12 + ); + if (errorCode2 !== 0) { + checkLastError(`Can't access output tensor data on index ${i}.`); + } + let tensorDataIndex = tensorDataOffset / 4; + const dataType = wasm2.HEAPU32[tensorDataIndex++]; + dataOffset = wasm2.HEAPU32[tensorDataIndex++]; + const dimsOffset = wasm2.HEAPU32[tensorDataIndex++]; + const dimsLength = wasm2.HEAPU32[tensorDataIndex++]; + const dims = []; + for (let i2 = 0; i2 < dimsLength; i2++) { + dims.push(wasm2.HEAPU32[dimsOffset / 4 + i2]); + } + wasm2._OrtFree(dimsOffset); + const size = dims.reduce((a, b) => a * b, 1); + type = tensorDataTypeEnumToString(dataType); + const preferredLocation = ioBindingState?.outputPreferredLocations[outputIndices[i]]; + if (type === "string") { + if (preferredLocation === "gpu-buffer") { + throw new Error("String tensor is not supported on GPU."); + } + const stringData = []; + let dataIndex = dataOffset / 4; + for (let i2 = 0; i2 < size; i2++) { + const offset = wasm2.HEAPU32[dataIndex++]; + const maxBytesToRead = i2 === size - 1 ? void 0 : wasm2.HEAPU32[dataIndex] - offset; + stringData.push(wasm2.UTF8ToString(offset, maxBytesToRead)); + } + output.push([type, dims, stringData, "cpu"]); + } else { + if (preferredLocation === "gpu-buffer" && size > 0) { + const getBuffer = wasm2.jsepGetBuffer; + if (!getBuffer) { + throw new Error('preferredLocation "gpu-buffer" is not supported without using WebGPU.'); + } + const gpuBuffer = getBuffer(dataOffset); + const elementSize = getTensorElementSize(dataType); + if (elementSize === void 0 || !isGpuBufferSupportedType(type)) { + throw new Error(`Unsupported data type: ${type}`); + } + keepOutputTensor = true; + output.push([ + type, + dims, + { + gpuBuffer, + download: wasm2.jsepCreateDownloader(gpuBuffer, size * elementSize, type), + dispose: () => { + wasm2._OrtReleaseTensor(tensor); + } + }, + "gpu-buffer" + ]); + } else { + const typedArrayConstructor = tensorTypeToTypedArrayConstructor(type); + const data = new typedArrayConstructor(size); + new Uint8Array(data.buffer, data.byteOffset, data.byteLength).set(wasm2.HEAPU8.subarray(dataOffset, dataOffset + data.byteLength)); + output.push([type, dims, data, "cpu"]); + } + } + } finally { + wasm2.stackRestore(beforeGetTensorDataStack); + if (type === "string" && dataOffset) { + wasm2._free(dataOffset); + } + if (!keepOutputTensor) { + wasm2._OrtReleaseTensor(tensor); + } + } + } + if (ioBindingState && !enableGraphCapture) { + wasm2._OrtClearBoundOutputs(ioBindingState.handle); + activeSessions.set( + sessionId, + [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture, false] + ); + } + return output; + } finally { + wasm2.stackRestore(beforeRunStack); + inputTensorHandles.forEach((v) => wasm2._OrtReleaseTensor(v)); + outputTensorHandles.forEach((v) => wasm2._OrtReleaseTensor(v)); + inputOutputAllocs.forEach((p) => wasm2._free(p)); + if (runOptionsHandle !== 0) { + wasm2._OrtReleaseRunOptions(runOptionsHandle); + } + runOptionsAllocs.forEach((p) => wasm2._free(p)); + } + }; + endProfiling = (sessionId) => { + const wasm2 = getInstance(); + const session = activeSessions.get(sessionId); + if (!session) { + throw new Error("invalid session id"); + } + const sessionHandle = session[0]; + const profileFileName = wasm2._OrtEndProfiling(sessionHandle); + if (profileFileName === 0) { + checkLastError("Can't get an profile file name."); + } + wasm2._OrtFree(profileFileName); + }; + extractTransferableBuffers = (tensors) => { + const buffers = []; + for (const tensor of tensors) { + const data = tensor[2]; + if (!Array.isArray(data) && "buffer" in data) { + buffers.push(data.buffer); + } + } + return buffers; + }; + } +}); + +// proxy-worker:./proxy-worker/main +var require_main = __commonJS({ + "proxy-worker:./proxy-worker/main"(exports, module) { + module.exports = '/*!\n * ONNX Runtime Web v1.18.0\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License.\n */\n"use strict";\n(() => {\n var __defProp = Object.defineProperty;\n var __getOwnPropDesc = Object.getOwnPropertyDescriptor;\n var __getOwnPropNames = Object.getOwnPropertyNames;\n var __hasOwnProp = Object.prototype.hasOwnProperty;\n var __esm = (fn, res) => function __init() {\n return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;\n };\n var __commonJS = (cb, mod) => function __require() {\n return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n };\n var __export = (target, all) => {\n for (var name in all)\n __defProp(target, name, { get: all[name], enumerable: true });\n };\n var __copyProps = (to, from, except, desc) => {\n if (from && typeof from === "object" || typeof from === "function") {\n for (let key of __getOwnPropNames(from))\n if (!__hasOwnProp.call(to, key) && key !== except)\n __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n }\n return to;\n };\n var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);\n\n // nodejs-ignore:fs\n var fs_exports = {};\n __export(fs_exports, {\n createReadStream: () => createReadStream,\n readFile: () => readFile,\n readFileSync: () => readFileSync\n });\n var readFile, readFileSync, createReadStream;\n var init_fs = __esm({\n "nodejs-ignore:fs"() {\n readFile = void 0;\n readFileSync = void 0;\n createReadStream = void 0;\n }\n });\n\n // nodejs-ignore:path\n var path_exports = {};\n __export(path_exports, {\n join: () => join2\n });\n var join2;\n var init_path = __esm({\n "nodejs-ignore:path"() {\n join2 = void 0;\n }\n });\n\n // web/lib/wasm/binding/ort-wasm-simd.jsep.js\n var require_ort_wasm_simd_jsep = __commonJS({\n "web/lib/wasm/binding/ort-wasm-simd.jsep.js"(exports, module) {\n "use strict";\n var ortWasm = (() => {\n var _scriptDir = typeof document != "undefined" ? document.currentScript?.src : void 0;\n if (typeof __filename != "undefined")\n _scriptDir ||= __filename;\n return function(moduleArg = {}) {\n var g = moduleArg, aa, ba, readyPromise = new Promise((a, b) => {\n aa = a;\n ba = b;\n });\n "use strict";\n g.mountExternalData = (a, b) => {\n (g.Ph || (g.Ph = /* @__PURE__ */ new Map())).set(a, b);\n };\n g.unmountExternalData = () => {\n delete g.Ph;\n };\n let da = () => {\n const a = (c, d, e) => (...f) => {\n const h = t, k = d?.();\n f = c(...f);\n const l = d?.();\n k !== l && (c = l, e(k), d = e = null);\n return t != h ? ca() : f;\n }, b = (c) => async (...d) => {\n try {\n if (g.Oh)\n throw Error("Session already started");\n const e = g.Oh = { gi: d[0], errors: [] }, f = await c(...d);\n if (g.Oh !== e)\n throw Error("Session mismatch");\n g.Uh?.flush();\n const h = e.errors;\n if (0 < h.length) {\n let k = await Promise.all(h);\n k = k.filter((l) => l);\n if (0 < k.length)\n throw Error(k.join("\\n"));\n }\n return f;\n } finally {\n g.Oh = null;\n }\n };\n g._OrtCreateSession = a(\n g._OrtCreateSession,\n () => g._OrtCreateSession,\n (c) => g._OrtCreateSession = c\n );\n g._OrtRun = b(a(g._OrtRun, () => g._OrtRun, (c) => g._OrtRun = c));\n g._OrtRunWithBinding = b(a(g._OrtRunWithBinding, () => g._OrtRunWithBinding, (c) => g._OrtRunWithBinding = c));\n g._OrtBindInput = a(g._OrtBindInput, () => g._OrtBindInput, (c) => g._OrtBindInput = c);\n da = void 0;\n };\n g.jsepInit = (a, b) => {\n da?.();\n if ("webgpu" === a) {\n [g.Uh, g.Zh, g.ci, g.Vh, g.bi, g.je, g.di, g.fi, g.$h, g.ai, g.ei] = b;\n const c = g.Uh;\n g.jsepRegisterBuffer = (d, e, f, h) => c.registerBuffer(d, e, f, h);\n g.jsepGetBuffer = (d) => c.getBuffer(d);\n g.jsepCreateDownloader = (d, e, f) => c.createDownloader(d, e, f);\n g.jsepOnReleaseSession = (d) => {\n c.onReleaseSession(d);\n };\n g.jsepOnRunStart = (d) => c.onRunStart(d);\n }\n };\n var ea = Object.assign({}, g), fa = "./this.program", ha = (a, b) => {\n throw b;\n }, ia = "object" == typeof window, ja = "function" == typeof importScripts, ka = "object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node, v = "", la, ma, na;\n if (ka) {\n var fs = (init_fs(), __toCommonJS(fs_exports)), oa = (init_path(), __toCommonJS(path_exports));\n v = ja ? oa.dirname(v) + "/" : __dirname + "/";\n la = (a, b) => {\n a = pa(a) ? new URL(a) : oa.normalize(a);\n return fs.readFileSync(a, b ? void 0 : "utf8");\n };\n na = (a) => {\n a = la(a, true);\n a.buffer || (a = new Uint8Array(a));\n return a;\n };\n ma = (a, b, c, d = true) => {\n a = pa(a) ? new URL(a) : oa.normalize(a);\n fs.readFile(a, d ? void 0 : "utf8", (e, f) => {\n e ? c(e) : b(d ? f.buffer : f);\n });\n };\n !g.thisProgram && 1 < process.argv.length && (fa = process.argv[1].replace(/\\\\/g, "/"));\n process.argv.slice(2);\n ha = (a, b) => {\n process.exitCode = a;\n throw b;\n };\n } else if (ia || ja)\n ja ? v = self.location.href : "undefined" != typeof document && document.currentScript && (v = document.currentScript.src), _scriptDir && (v = _scriptDir), v.startsWith("blob:") ? v = "" : v = v.substr(0, v.replace(/[?#].*/, "").lastIndexOf("/") + 1), la = (a) => {\n var b = new XMLHttpRequest();\n b.open("GET", a, false);\n b.send(null);\n return b.responseText;\n }, ja && (na = (a) => {\n var b = new XMLHttpRequest();\n b.open("GET", a, false);\n b.responseType = "arraybuffer";\n b.send(null);\n return new Uint8Array(b.response);\n }), ma = (a, b, c) => {\n var d = new XMLHttpRequest();\n d.open("GET", a, true);\n d.responseType = "arraybuffer";\n d.onload = () => {\n 200 == d.status || 0 == d.status && d.response ? b(d.response) : c();\n };\n d.onerror = c;\n d.send(null);\n };\n var qa = console.log.bind(console), w = console.error.bind(console);\n Object.assign(g, ea);\n ea = null;\n var ra, x = false, sa, z, E, ta, ua, G, I, va, wa, xa, ya;\n function za() {\n var a = ra.buffer;\n g.HEAP8 = z = new Int8Array(a);\n g.HEAP16 = ta = new Int16Array(a);\n g.HEAPU8 = E = new Uint8Array(a);\n g.HEAPU16 = ua = new Uint16Array(a);\n g.HEAP32 = G = new Int32Array(a);\n g.HEAPU32 = I = new Uint32Array(a);\n g.HEAPF32 = va = new Float32Array(a);\n g.HEAPF64 = ya = new Float64Array(a);\n g.HEAP64 = wa = new BigInt64Array(a);\n g.HEAPU64 = xa = new BigUint64Array(a);\n }\n var Aa = [], Ba = [], Ca = [], Da = 0, Ea = null, Fa = null;\n function Ga(a) {\n a = "Aborted(" + a + ")";\n w(a);\n x = true;\n sa = 1;\n a = new WebAssembly.RuntimeError(a + ". Build with -sASSERTIONS for more info.");\n ba(a);\n throw a;\n }\n var Ha = (a) => a.startsWith("data:application/octet-stream;base64,"), pa = (a) => a.startsWith("file://"), Ia;\n Ia = "ort-wasm-simd.wasm";\n if (!Ha(Ia)) {\n var Ja = Ia;\n Ia = g.locateFile ? g.locateFile(Ja, v) : v + Ja;\n }\n function Ka(a) {\n if (na)\n return na(a);\n throw "both async and sync fetching of the wasm failed";\n }\n function La(a) {\n if (ia || ja) {\n if ("function" == typeof fetch && !pa(a))\n return fetch(a, { credentials: "same-origin" }).then((b) => {\n if (!b.ok)\n throw `failed to load wasm binary file at \'${a}\'`;\n return b.arrayBuffer();\n }).catch(() => Ka(a));\n if (ma)\n return new Promise((b, c) => {\n ma(a, (d) => b(new Uint8Array(d)), c);\n });\n }\n return Promise.resolve().then(() => Ka(a));\n }\n function Ma(a, b, c) {\n return La(a).then((d) => WebAssembly.instantiate(d, b)).then(c, (d) => {\n w(`failed to asynchronously prepare wasm: ${d}`);\n Ga(d);\n });\n }\n function Na(a, b) {\n var c = Ia;\n return "function" != typeof WebAssembly.instantiateStreaming || Ha(c) || pa(c) || ka || "function" != typeof fetch ? Ma(c, a, b) : fetch(c, { credentials: "same-origin" }).then((d) => WebAssembly.instantiateStreaming(d, a).then(b, function(e) {\n w(`wasm streaming compile failed: ${e}`);\n w("falling back to ArrayBuffer instantiation");\n return Ma(c, a, b);\n }));\n }\n var Oa = {\n 1261504: (a, b, c, d) => {\n if ("undefined" == typeof g || !g.Ph)\n return 1;\n a = J(a >>> 0);\n a.startsWith("./") && (a = a.substring(2));\n a = g.Ph.get(a);\n if (!a)\n return 2;\n b >>>= 0;\n c >>>= 0;\n if (b + c > a.byteLength)\n return 3;\n try {\n return E.set(a.subarray(b, b + c), d >>> 0 >>> 0), 0;\n } catch {\n return 4;\n }\n },\n 1262005: (a, b, c) => {\n c = J(c);\n const d = new Uint8Array(b);\n d.set(E.subarray(a >>> 0, a + b >>> 0));\n "object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node ? (init_fs(), __toCommonJS(fs_exports)).writeFileSync(c, d) : (a = new File([d], c, { type: "application/octet-stream" }), a = URL.createObjectURL(a), window.open(a, "_blank"));\n },\n 1262513: () => {\n g.$h();\n },\n 1262544: () => {\n g.ai();\n },\n 1262573: () => {\n g.ei();\n },\n 1262598: (a) => g.Zh(a),\n 1262631: (a) => g.ci(a),\n 1262663: (a, b, c) => {\n g.Vh(a, b, c, true);\n },\n 1262702: (a, b, c) => {\n g.Vh(a, b, c);\n },\n 1262735: (a) => {\n g.je("Abs", a, void 0);\n },\n 1262786: (a) => {\n g.je("Neg", a, void 0);\n },\n 1262837: (a) => {\n g.je("Floor", a, void 0);\n },\n 1262890: (a) => {\n g.je("Ceil", a, void 0);\n },\n 1262942: (a) => {\n g.je("Reciprocal", a, void 0);\n },\n 1263e3: (a) => {\n g.je("Sqrt", a, void 0);\n },\n 1263052: (a) => {\n g.je("Exp", a, void 0);\n },\n 1263103: (a) => {\n g.je("Erf", a, void 0);\n },\n 1263154: (a) => {\n g.je("Sigmoid", a, void 0);\n },\n 1263209: (a, b, c) => {\n g.je("HardSigmoid", a, { alpha: b, beta: c });\n },\n 1263288: (a) => {\n g.je("Log", a, void 0);\n },\n 1263339: (a) => {\n g.je("Sin", a, void 0);\n },\n 1263390: (a) => {\n g.je("Cos", a, void 0);\n },\n 1263441: (a) => {\n g.je("Tan", a, void 0);\n },\n 1263492: (a) => {\n g.je("Asin", a, void 0);\n },\n 1263544: (a) => {\n g.je("Acos", a, void 0);\n },\n 1263596: (a) => {\n g.je("Atan", a, void 0);\n },\n 1263648: (a) => {\n g.je("Sinh", a, void 0);\n },\n 1263700: (a) => {\n g.je("Cosh", a, void 0);\n },\n 1263752: (a) => {\n g.je("Asinh", a, void 0);\n },\n 1263805: (a) => {\n g.je("Acosh", a, void 0);\n },\n 1263858: (a) => {\n g.je("Atanh", a, void 0);\n },\n 1263911: (a) => {\n g.je("Tanh", a, void 0);\n },\n 1263963: (a) => {\n g.je("Not", a, void 0);\n },\n 1264014: (a, b, c) => {\n g.je("Clip", a, { min: b, max: c });\n },\n 1264083: (a) => {\n g.je("Clip", a, void 0);\n },\n 1264135: (a, b) => {\n g.je("Elu", a, { alpha: b });\n },\n 1264193: (a) => {\n g.je("Relu", a, void 0);\n },\n 1264245: (a, b) => {\n g.je("LeakyRelu", a, { alpha: b });\n },\n 1264309: (a, b) => {\n g.je("ThresholdedRelu", a, { alpha: b });\n },\n 1264379: (a, b) => {\n g.je("Cast", a, { to: b });\n },\n 1264437: (a) => {\n g.je("Add", a, void 0);\n },\n 1264488: (a) => {\n g.je("Sub", a, void 0);\n },\n 1264539: (a) => {\n g.je("Mul", a, void 0);\n },\n 1264590: (a) => {\n g.je("Div", a, void 0);\n },\n 1264641: (a) => {\n g.je("Pow", a, void 0);\n },\n 1264692: (a) => {\n g.je("Equal", a, void 0);\n },\n 1264745: (a) => {\n g.je("Greater", a, void 0);\n },\n 1264800: (a) => {\n g.je("GreaterOrEqual", a, void 0);\n },\n 1264862: (a) => {\n g.je("Less", a, void 0);\n },\n 1264914: (a) => {\n g.je("LessOrEqual", a, void 0);\n },\n 1264973: (a, b, c, d, e) => {\n g.je("ReduceMean", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n },\n 1265132: (a, b, c, d, e) => {\n g.je("ReduceMax", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n },\n 1265290: (a, b, c, d, e) => {\n g.je("ReduceMin", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n },\n 1265448: (a, b, c, d, e) => {\n g.je("ReduceProd", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n },\n 1265607: (a, b, c, d, e) => {\n g.je("ReduceSum", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n },\n 1265765: (a, b, c, d, e) => {\n g.je("ReduceL1", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n },\n 1265922: (a, b, c, d, e) => {\n g.je("ReduceL2", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n },\n 1266079: (a, b, c, d, e) => {\n g.je("ReduceLogSum", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n },\n 1266240: (a, b, c, d, e) => {\n g.je("ReduceSumSquare", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n },\n 1266404: (a, b, c, d, e) => {\n g.je("ReduceLogSumExp", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n },\n 1266568: (a) => {\n g.je("Where", a, void 0);\n },\n 1266621: (a, b, c) => {\n g.je("Transpose", a, { perm: b ? Array.from(G.subarray(b >>> 0, c >>> 0)) : [] });\n },\n 1266729: (a, b, c, d) => {\n g.je("DepthToSpace", a, { blocksize: b, mode: J(c), format: d ? "NHWC" : "NCHW" });\n },\n 1266862: (a, b, c, d) => {\n g.je("DepthToSpace", a, { blocksize: b, mode: J(c), format: d ? "NHWC" : "NCHW" });\n },\n 1266995: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => {\n g.je("ConvTranspose", a, { format: l ? "NHWC" : "NCHW", autoPad: b, dilations: [c], group: d, kernelShape: [e], pads: [f, h], strides: [k], wIsConst: () => !!z[m >>> 0], outputPadding: n ? Array.from(G.subarray(n >>> 0, q >>> 0)) : [], outputShape: r ? Array.from(G.subarray(r >>> 0, p >>> 0)) : [], activation: J(u) });\n },\n 1267396: (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => {\n g.je("ConvTranspose", a, { format: k ? "NHWC" : "NCHW", autoPad: b, dilations: Array.from(G.subarray(c >>> 0, (c >>> 0) + 2 >>> 0)), group: d, kernelShape: Array.from(G.subarray(e >>> 0, (e >>> 0) + 2 >>> 0)), pads: Array.from(G.subarray(f >>> 0, (f >>> 0) + 4 >>> 0)), strides: Array.from(G.subarray(h >>> 0, (h >>> 0) + 2 >>> 0)), wIsConst: () => !!z[l >>> 0], outputPadding: m ? Array.from(G.subarray(m >>> 0, n >>> 0)) : [], outputShape: q ? Array.from(G.subarray(q >>> 0, r >>> 0)) : [], activation: J(p) });\n },\n 1267961: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => {\n g.je("ConvTranspose", a, { format: l ? "NHWC" : "NCHW", autoPad: b, dilations: [c], group: d, kernelShape: [e], pads: [f, h], strides: [k], wIsConst: () => !!z[m >>> 0], outputPadding: n ? Array.from(G.subarray(n >>> 0, q >>> 0)) : [], outputShape: r ? Array.from(G.subarray(r >>> 0, p >>> 0)) : [], activation: J(u) });\n },\n 1268362: (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => {\n g.je("ConvTranspose", a, {\n format: k ? "NHWC" : "NCHW",\n autoPad: b,\n dilations: Array.from(G.subarray(c >>> 0, (c >>> 0) + 2 >>> 0)),\n group: d,\n kernelShape: Array.from(G.subarray(e >>> 0, (e >>> 0) + 2 >>> 0)),\n pads: Array.from(G.subarray(f >>> 0, (f >>> 0) + 4 >>> 0)),\n strides: Array.from(G.subarray(h >>> 0, (h >>> 0) + 2 >>> 0)),\n wIsConst: () => !!z[l >>> 0],\n outputPadding: m ? Array.from(G.subarray(m >>> 0, n >>> 0)) : [],\n outputShape: q ? Array.from(G.subarray(q >>> 0, r >>> 0)) : [],\n activation: J(p)\n });\n },\n 1268927: (a, b) => {\n g.je("GlobalAveragePool", a, { format: b ? "NHWC" : "NCHW" });\n },\n 1269018: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => {\n g.je("AveragePool", a, {\n format: y ? "NHWC" : "NCHW",\n auto_pad: b,\n ceil_mode: c,\n count_include_pad: d,\n storage_order: e,\n dilations: [f, h],\n kernel_shape: [k, l],\n pads: [m, n, q, r],\n strides: [p, u]\n });\n },\n 1269302: (a, b) => {\n g.je("GlobalAveragePool", a, { format: b ? "NHWC" : "NCHW" });\n },\n 1269393: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => {\n g.je("AveragePool", a, { format: y ? "NHWC" : "NCHW", auto_pad: b, ceil_mode: c, count_include_pad: d, storage_order: e, dilations: [f, h], kernel_shape: [k, l], pads: [m, n, q, r], strides: [p, u] });\n },\n 1269677: (a, b) => {\n g.je("GlobalMaxPool", a, { format: b ? "NHWC" : "NCHW" });\n },\n 1269764: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => {\n g.je("MaxPool", a, { format: y ? "NHWC" : "NCHW", auto_pad: b, ceil_mode: c, count_include_pad: d, storage_order: e, dilations: [f, h], kernel_shape: [k, l], pads: [m, n, q, r], strides: [p, u] });\n },\n 1270044: (a, b) => {\n g.je("GlobalMaxPool", a, { format: b ? "NHWC" : "NCHW" });\n },\n 1270131: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => {\n g.je("MaxPool", a, { format: y ? "NHWC" : "NCHW", auto_pad: b, ceil_mode: c, count_include_pad: d, storage_order: e, dilations: [f, h], kernel_shape: [k, l], pads: [m, n, q, r], strides: [p, u] });\n },\n 1270411: (a, b, c, d, e) => {\n g.je("Gemm", a, { alpha: b, beta: c, transA: d, transB: e });\n },\n 1270515: (a) => {\n g.je("MatMul", a, void 0);\n },\n 1270569: (a, b, c, d) => {\n g.je("ArgMax", a, { keepDims: !!b, selectLastIndex: !!c, axis: d });\n },\n 1270677: (a, b, c, d) => {\n g.je("ArgMin", a, { keepDims: !!b, selectLastIndex: !!c, axis: d });\n },\n 1270785: (a, b) => {\n g.je("Softmax", a, { axis: b });\n },\n 1270848: (a, b) => {\n g.je("Concat", a, { axis: b });\n },\n 1270908: (a, b, c, d, e) => {\n g.je("Split", a, { axis: b, numOutputs: c, splitSizes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n },\n 1271048: (a) => {\n g.je("Expand", a, void 0);\n },\n 1271102: (a, b) => {\n g.je("Gather", a, { axis: Number(b) });\n },\n 1271173: (a, b) => {\n g.je(\n "GatherElements",\n a,\n { axis: Number(b) }\n );\n },\n 1271252: (a, b, c, d, e, f, h, k, l, m, n) => {\n g.je("Resize", a, { antialias: b, axes: c ? Array.from(G.subarray(c >>> 0, d >>> 0)) : [], coordinateTransformMode: J(e), cubicCoeffA: f, excludeOutside: h, extrapolationValue: k, keepAspectRatioPolicy: J(l), mode: J(m), nearestMode: J(n) });\n },\n 1271598: (a, b, c, d, e, f, h) => {\n g.je("Slice", a, { starts: b ? Array.from(G.subarray(b >>> 0, c >>> 0)) : [], ends: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [], axes: f ? Array.from(G.subarray(f >>> 0, h >>> 0)) : [] });\n },\n 1271814: (a) => {\n g.je("Tile", a, void 0);\n },\n 1271866: (a, b, c, d) => {\n g.je("LayerNormalization", a, { axis: b, epsilon: c, simplified: !!d });\n },\n 1271977: (a, b, c) => {\n g.je("InstanceNormalization", a, { epsilon: b, format: c ? "NHWC" : "NCHW" });\n },\n 1272091: (a, b, c) => {\n g.je("InstanceNormalization", a, { epsilon: b, format: c ? "NHWC" : "NCHW" });\n },\n 1272205: (a) => {\n g.je("Range", a, void 0);\n },\n 1272258: (a, b) => {\n g.je("Einsum", a, { equation: J(b) });\n },\n 1272339: (a, b, c, d, e) => {\n g.je("Pad", a, { mode: b, value: c, pads: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n },\n 1272466: (a, b, c, d, e, f) => {\n g.je("BatchNormalization", a, {\n epsilon: b,\n momentum: c,\n spatial: !!e,\n trainingMode: !!d,\n format: f ? "NHWC" : "NCHW"\n });\n },\n 1272635: (a, b, c, d, e, f) => {\n g.je("BatchNormalization", a, { epsilon: b, momentum: c, spatial: !!e, trainingMode: !!d, format: f ? "NHWC" : "NCHW" });\n },\n 1272804: (a, b, c) => {\n g.je("CumSum", a, { exclusive: Number(b), reverse: Number(c) });\n },\n 1272901: (a, b, c, d, e, f, h, k, l) => {\n g.je("Attention", a, { numHeads: b, isUnidirectional: c, maskFilterValue: d, scale: e, doRotary: f, qkvHiddenSizes: h ? Array.from(G.subarray(Number(k) >>> 0, Number(k) + h >>> 0)) : [], pastPresentShareBuffer: !!l });\n },\n 1273173: (a) => {\n g.je(\n "BiasAdd",\n a,\n void 0\n );\n },\n 1273228: (a) => {\n g.je("BiasSplitGelu", a, void 0);\n },\n 1273289: (a) => {\n g.je("FastGelu", a, void 0);\n },\n 1273345: (a, b, c, d, e, f, h, k, l, m, n, q, r) => {\n g.je("Conv", a, { format: l ? "NHWC" : "NCHW", auto_pad: b, dilations: [c], group: d, kernel_shape: [e], pads: f ? Array.from(G.subarray(f >>> 0, h >>> 0)) : [], strides: [k], w_is_const: () => !!z[m >>> 0], activation: J(n), activation_params: q ? Array.from(va.subarray(q >>> 0, r >>> 0)) : [] });\n },\n 1273715: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => {\n g.je("Conv", a, { format: q ? "NHWC" : "NCHW", auto_pad: b, dilations: [c, d], group: e, kernel_shape: [\n f,\n h\n ], pads: k ? Array.from(G.subarray(k >>> 0, l >>> 0)) : [], strides: [m, n], w_is_const: () => !!z[r >>> 0], activation: J(p), activation_params: u ? Array.from(va.subarray(u >>> 0, y >>> 0)) : [] });\n },\n 1274106: (a) => {\n g.je("Gelu", a, void 0);\n },\n 1274158: (a, b, c, d, e, f) => {\n g.je("MatMulNBits", a, { k: b, n: c, accuracyLevel: d, bits: e, blockSize: f });\n },\n 1274285: (a, b, c, d, e, f) => {\n g.je("MultiHeadAttention", a, { numHeads: b, isUnidirectional: c, maskFilterValue: d, scale: e, doRotary: f });\n },\n 1274444: (a, b, c, d, e) => {\n g.je("RotaryEmbedding", a, {\n interleaved: !!b,\n numHeads: c,\n rotaryEmbeddingDim: d,\n scale: e\n });\n },\n 1274583: (a, b, c) => {\n g.je("SkipLayerNormalization", a, { epsilon: b, simplified: !!c });\n },\n 1274685: (a, b, c) => {\n g.je("SkipLayerNormalization", a, { epsilon: b, simplified: !!c });\n },\n 1274787: (a, b, c, d) => {\n g.je("LayerNormalization", a, { axis: b, epsilon: c, simplified: !!d });\n },\n 1274898: (a) => {\n g.di(a);\n },\n 1274932: (a, b) => g.fi(a, b, g.Oh.gi, g.Oh.errors)\n };\n function Pa(a) {\n this.name = "ExitStatus";\n this.message = `Program terminated with exit(${a})`;\n this.status = a;\n }\n var Qa = [], Ra = 0, L = 0;\n class Sa {\n constructor(a) {\n this.Nh = a;\n this.Ih = a - 24;\n }\n }\n var Za = (a) => {\n var b = L;\n if (!b)\n return Ta(0), 0;\n var c = new Sa(b);\n I[c.Ih + 16 >>> 2 >>> 0] = b;\n var d = I[c.Ih + 4 >>> 2 >>> 0];\n if (!d)\n return Ta(0), b;\n for (var e in a) {\n var f = a[e];\n if (0 === f || f === d)\n break;\n if (Ua(f, d, c.Ih + 16))\n return Ta(f), b;\n }\n Ta(d);\n return b;\n }, $a = "undefined" != typeof TextDecoder ? new TextDecoder("utf8") : void 0, ab = (a, b, c) => {\n b >>>= 0;\n var d = b + c;\n for (c = b; a[c] && !(c >= d); )\n ++c;\n if (16 < c - b && a.buffer && $a)\n return $a.decode(a.subarray(b, c));\n for (d = ""; b < c; ) {\n var e = a[b++];\n if (e & 128) {\n var f = a[b++] & 63;\n if (192 == (e & 224))\n d += String.fromCharCode((e & 31) << 6 | f);\n else {\n var h = a[b++] & 63;\n e = 224 == (e & 240) ? (e & 15) << 12 | f << 6 | h : (e & 7) << 18 | f << 12 | h << 6 | a[b++] & 63;\n 65536 > e ? d += String.fromCharCode(e) : (e -= 65536, d += String.fromCharCode(55296 | e >> 10, 56320 | e & 1023));\n }\n } else\n d += String.fromCharCode(e);\n }\n return d;\n }, J = (a, b) => (a >>>= 0) ? ab(E, a, b) : "", bb = (a) => {\n for (var b = 0, c = 0; c < a.length; ++c) {\n var d = a.charCodeAt(c);\n 127 >= d ? b++ : 2047 >= d ? b += 2 : 55296 <= d && 57343 >= d ? (b += 4, ++c) : b += 3;\n }\n return b;\n }, M = (a, b, c, d) => {\n c >>>= 0;\n if (!(0 < d))\n return 0;\n var e = c;\n d = c + d - 1;\n for (var f = 0; f < a.length; ++f) {\n var h = a.charCodeAt(f);\n if (55296 <= h && 57343 >= h) {\n var k = a.charCodeAt(++f);\n h = 65536 + ((h & 1023) << 10) | k & 1023;\n }\n if (127 >= h) {\n if (c >= d)\n break;\n b[c++ >>> 0] = h;\n } else {\n if (2047 >= h) {\n if (c + 1 >= d)\n break;\n b[c++ >>> 0] = 192 | h >> 6;\n } else {\n if (65535 >= h) {\n if (c + 2 >= d)\n break;\n b[c++ >>> 0] = 224 | h >> 12;\n } else {\n if (c + 3 >= d)\n break;\n b[c++ >>> 0] = 240 | h >> 18;\n b[c++ >>> 0] = 128 | h >> 12 & 63;\n }\n b[c++ >>> 0] = 128 | h >> 6 & 63;\n }\n b[c++ >>> 0] = 128 | h & 63;\n }\n }\n b[c >>> 0] = 0;\n return c - e;\n }, cb, N = (a) => {\n for (var b = ""; E[a >>> 0]; )\n b += cb[E[a++ >>> 0]];\n return b;\n }, db = {}, eb = {}, fb = {}, O;\n function gb(a, b, c = {}) {\n var d = b.name;\n if (!a)\n throw new O(`type "${d}" must have a positive integer typeid pointer`);\n if (eb.hasOwnProperty(a)) {\n if (c.Xh)\n return;\n throw new O(`Cannot register type \'${d}\' twice`);\n }\n eb[a] = b;\n delete fb[a];\n db.hasOwnProperty(a) && (b = db[a], delete db[a], b.forEach((e) => e()));\n }\n function P(a, b, c = {}) {\n if (!("argPackAdvance" in b))\n throw new TypeError("registerType registeredInstance requires argPackAdvance");\n return gb(a, b, c);\n }\n var hb = (a, b, c) => {\n switch (b) {\n case 1:\n return c ? (d) => z[d >>> 0] : (d) => E[d >>> 0];\n case 2:\n return c ? (d) => ta[d >>> 1 >>> 0] : (d) => ua[d >>> 1 >>> 0];\n case 4:\n return c ? (d) => G[d >>> 2 >>> 0] : (d) => I[d >>> 2 >>> 0];\n case 8:\n return c ? (d) => wa[d >>> 3] : (d) => xa[d >>> 3];\n default:\n throw new TypeError(`invalid integer width (${b}): ${a}`);\n }\n }, ib = [], Q = [];\n function jb(a) {\n a >>>= 0;\n 9 < a && 0 === --Q[a + 1] && (Q[a] = void 0, ib.push(a));\n }\n var R = (a) => {\n if (!a)\n throw new O("Cannot use deleted val. handle = " + a);\n return Q[a];\n }, S = (a) => {\n switch (a) {\n case void 0:\n return 2;\n case null:\n return 4;\n case true:\n return 6;\n case false:\n return 8;\n default:\n const b = ib.pop() || Q.length;\n Q[b] = a;\n Q[b + 1] = 1;\n return b;\n }\n };\n function kb(a) {\n return this.fromWireType(I[a >>> 2 >>> 0]);\n }\n var lb = { name: "emscripten::val", fromWireType: (a) => {\n var b = R(a);\n jb(a);\n return b;\n }, toWireType: (a, b) => S(b), argPackAdvance: 8, readValueFromPointer: kb, Mh: null }, mb = (a, b) => {\n switch (b) {\n case 4:\n return function(c) {\n return this.fromWireType(va[c >>> 2 >>> 0]);\n };\n case 8:\n return function(c) {\n return this.fromWireType(ya[c >>> 3 >>> 0]);\n };\n default:\n throw new TypeError(`invalid float width (${b}): ${a}`);\n }\n }, nb = "undefined" != typeof TextDecoder ? new TextDecoder("utf-16le") : void 0, ob = (a, b) => {\n var c = a >> 1;\n for (var d = c + b / 2; !(c >= d) && ua[c >>> 0]; )\n ++c;\n c <<= 1;\n if (32 < c - a && nb)\n return nb.decode(E.subarray(a >>> 0, c >>> 0));\n c = "";\n for (d = 0; !(d >= b / 2); ++d) {\n var e = ta[a + 2 * d >>> 1 >>> 0];\n if (0 == e)\n break;\n c += String.fromCharCode(e);\n }\n return c;\n }, pb = (a, b, c) => {\n c ??= 2147483647;\n if (2 > c)\n return 0;\n c -= 2;\n var d = b;\n c = c < 2 * a.length ? c / 2 : a.length;\n for (var e = 0; e < c; ++e)\n ta[b >>> 1 >>> 0] = a.charCodeAt(e), b += 2;\n ta[b >>> 1 >>> 0] = 0;\n return b - d;\n }, qb = (a) => 2 * a.length, rb = (a, b) => {\n for (var c = 0, d = ""; !(c >= b / 4); ) {\n var e = G[a + 4 * c >>> 2 >>> 0];\n if (0 == e)\n break;\n ++c;\n 65536 <= e ? (e -= 65536, d += String.fromCharCode(55296 | e >> 10, 56320 | e & 1023)) : d += String.fromCharCode(e);\n }\n return d;\n }, sb = (a, b, c) => {\n b >>>= 0;\n c ??= 2147483647;\n if (4 > c)\n return 0;\n var d = b;\n c = d + c - 4;\n for (var e = 0; e < a.length; ++e) {\n var f = a.charCodeAt(e);\n if (55296 <= f && 57343 >= f) {\n var h = a.charCodeAt(++e);\n f = 65536 + ((f & 1023) << 10) | h & 1023;\n }\n G[b >>> 2 >>> 0] = f;\n b += 4;\n if (b + 4 > c)\n break;\n }\n G[b >>> 2 >>> 0] = 0;\n return b - d;\n }, tb = (a) => {\n for (var b = 0, c = 0; c < a.length; ++c) {\n var d = a.charCodeAt(c);\n 55296 <= d && 57343 >= d && ++c;\n b += 4;\n }\n return b;\n }, vb = (a, b) => {\n var c = eb[a];\n if (void 0 === c)\n throw a = ub(a), c = N(a), T(a), new O(`${b} has unknown type ${c}`);\n return c;\n }, wb = (a, b, c) => {\n var d = [];\n a = a.toWireType(d, c);\n d.length && (I[b >>> 2 >>> 0] = S(d));\n return a;\n }, xb = (a) => {\n try {\n a();\n } catch (b) {\n Ga(b);\n }\n }, yb = (a) => {\n if (!x)\n try {\n a();\n try {\n sa = sa = a = sa, g.onExit?.(a), x = true, ha(a, new Pa(a));\n } catch (b) {\n b instanceof Pa || "unwind" == b || ha(1, b);\n }\n } catch (b) {\n b instanceof Pa || "unwind" == b || ha(1, b);\n }\n };\n function zb() {\n var a = U, b = {};\n for (let [c, d] of Object.entries(a))\n b[c] = "function" == typeof d ? (...e) => {\n Ab.push(c);\n try {\n return d(...e);\n } finally {\n x || (Ab.pop(), t && 1 === V && 0 === Ab.length && (V = 0, xb(Bb), "undefined" != typeof Fibers && Fibers.mi()));\n }\n } : d;\n return b;\n }\n var V = 0, t = null, Cb = 0, Ab = [], Db = {}, Eb = {}, Fb = 0, Gb = null, Hb = [];\n function ca() {\n return new Promise((a, b) => {\n Gb = { resolve: a, reject: b };\n });\n }\n function Ib() {\n var a = Jb(65548), b = a + 12;\n I[a >>> 2 >>> 0] = b;\n I[a + 4 >>> 2 >>> 0] = b + 65536;\n b = Ab[0];\n var c = Db[b];\n void 0 === c && (c = Fb++, Db[b] = c, Eb[c] = b);\n G[a + 8 >>> 2 >>> 0] = c;\n return a;\n }\n function Kb(a) {\n if (!x) {\n if (0 === V) {\n var b = false, c = false;\n a((d = 0) => {\n if (!x && (Cb = d, b = true, c)) {\n V = 2;\n xb(() => Lb(t));\n "undefined" != typeof Browser && Browser.Sh.Wh && Browser.Sh.resume();\n d = false;\n try {\n var e = (0, U[Eb[G[t + 8 >>> 2 >>> 0]]])();\n } catch (k) {\n e = k, d = true;\n }\n var f = false;\n if (!t) {\n var h = Gb;\n h && (Gb = null, (d ? h.reject : h.resolve)(e), f = true);\n }\n if (d && !f)\n throw e;\n }\n });\n c = true;\n b || (V = 1, t = Ib(), "undefined" != typeof Browser && Browser.Sh.Wh && Browser.Sh.pause(), xb(() => Mb(t)));\n } else\n 2 === V ? (V = 0, xb(Nb), T(t), t = null, Hb.forEach(yb)) : Ga(`invalid state: ${V}`);\n return Cb;\n }\n }\n function Ob(a) {\n return Kb((b) => {\n a().then(b);\n });\n }\n var Pb = [], Qb = {}, Rb = (a) => {\n var b = Qb[a];\n return void 0 === b ? N(a) : b;\n }, Sb = () => "object" == typeof globalThis ? globalThis : Function("return this")(), Tb = (a) => {\n var b = Pb.length;\n Pb.push(a);\n return b;\n }, Ub = (a, b) => {\n for (var c = Array(a), d = 0; d < a; ++d)\n c[d] = vb(I[b + 4 * d >>> 2 >>> 0], "parameter " + d);\n return c;\n }, Vb = (a, b) => Object.defineProperty(b, "name", { value: a });\n function Wb(a) {\n var b = Function;\n if (!(b instanceof Function))\n throw new TypeError(`new_ called with constructor type ${typeof b} which is not a function`);\n var c = Vb(b.name || "unknownFunctionName", function() {\n });\n c.prototype = b.prototype;\n c = new c();\n a = b.apply(c, a);\n return a instanceof Object ? a : c;\n }\n var W = (a) => 0 === a % 4 && (0 !== a % 100 || 0 === a % 400), Xb = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335], Yb = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334], Zb = [], $b = (a, b) => {\n Zb.length = 0;\n for (var c; c = E[a++ >>> 0]; ) {\n var d = 105 != c;\n d &= 112 != c;\n b += d && b % 8 ? 4 : 0;\n Zb.push(112 == c ? I[b >>> 2 >>> 0] : 106 == c ? wa[b >>> 3] : 105 == c ? G[b >>> 2 >>> 0] : ya[b >>> 3 >>> 0]);\n b += d ? 8 : 4;\n }\n return Zb;\n }, ac = {}, cc = () => {\n if (!bc) {\n var a = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: ("object" == typeof navigator && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8", _: fa || "./this.program" }, b;\n for (b in ac)\n void 0 === ac[b] ? delete a[b] : a[b] = ac[b];\n var c = [];\n for (b in a)\n c.push(`${b}=${a[b]}`);\n bc = c;\n }\n return bc;\n }, bc, dc = [null, [], []], ec = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], fc = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];\n function gc(a) {\n var b = Array(bb(a) + 1);\n M(a, b, 0, b.length);\n return b;\n }\n function hc(a, b, c, d) {\n function e(p, u, y) {\n for (p = "number" == typeof p ? p.toString() : p || ""; p.length < u; )\n p = y[0] + p;\n return p;\n }\n function f(p, u) {\n return e(p, u, "0");\n }\n function h(p, u) {\n function y(B) {\n return 0 > B ? -1 : 0 < B ? 1 : 0;\n }\n var A;\n 0 === (A = y(p.getFullYear() - u.getFullYear())) && 0 === (A = y(p.getMonth() - u.getMonth())) && (A = y(p.getDate() - u.getDate()));\n return A;\n }\n function k(p) {\n switch (p.getDay()) {\n case 0:\n return new Date(p.getFullYear() - 1, 11, 29);\n case 1:\n return p;\n case 2:\n return new Date(p.getFullYear(), 0, 3);\n case 3:\n return new Date(\n p.getFullYear(),\n 0,\n 2\n );\n case 4:\n return new Date(p.getFullYear(), 0, 1);\n case 5:\n return new Date(p.getFullYear() - 1, 11, 31);\n case 6:\n return new Date(p.getFullYear() - 1, 11, 30);\n }\n }\n function l(p) {\n var u = p.Kh;\n for (p = new Date(new Date(p.Lh + 1900, 0, 1).getTime()); 0 < u; ) {\n var y = p.getMonth(), A = (W(p.getFullYear()) ? ec : fc)[y];\n if (u > A - p.getDate())\n u -= A - p.getDate() + 1, p.setDate(1), 11 > y ? p.setMonth(y + 1) : (p.setMonth(0), p.setFullYear(p.getFullYear() + 1));\n else {\n p.setDate(p.getDate() + u);\n break;\n }\n }\n y = new Date(p.getFullYear() + 1, 0, 4);\n u = k(new Date(\n p.getFullYear(),\n 0,\n 4\n ));\n y = k(y);\n return 0 >= h(u, p) ? 0 >= h(y, p) ? p.getFullYear() + 1 : p.getFullYear() : p.getFullYear() - 1;\n }\n a >>>= 0;\n b >>>= 0;\n c >>>= 0;\n d >>>= 0;\n var m = I[d + 40 >>> 2 >>> 0];\n d = { ji: G[d >>> 2 >>> 0], ii: G[d + 4 >>> 2 >>> 0], Qh: G[d + 8 >>> 2 >>> 0], Th: G[d + 12 >>> 2 >>> 0], Rh: G[d + 16 >>> 2 >>> 0], Lh: G[d + 20 >>> 2 >>> 0], Jh: G[d + 24 >>> 2 >>> 0], Kh: G[d + 28 >>> 2 >>> 0], li: G[d + 32 >>> 2 >>> 0], hi: G[d + 36 >>> 2 >>> 0], ki: m ? J(m) : "" };\n c = J(c);\n m = {\n "%c": "%a %b %d %H:%M:%S %Y",\n "%D": "%m/%d/%y",\n "%F": "%Y-%m-%d",\n "%h": "%b",\n "%r": "%I:%M:%S %p",\n "%R": "%H:%M",\n "%T": "%H:%M:%S",\n "%x": "%m/%d/%y",\n "%X": "%H:%M:%S",\n "%Ec": "%c",\n "%EC": "%C",\n "%Ex": "%m/%d/%y",\n "%EX": "%H:%M:%S",\n "%Ey": "%y",\n "%EY": "%Y",\n "%Od": "%d",\n "%Oe": "%e",\n "%OH": "%H",\n "%OI": "%I",\n "%Om": "%m",\n "%OM": "%M",\n "%OS": "%S",\n "%Ou": "%u",\n "%OU": "%U",\n "%OV": "%V",\n "%Ow": "%w",\n "%OW": "%W",\n "%Oy": "%y"\n };\n for (var n in m)\n c = c.replace(new RegExp(n, "g"), m[n]);\n var q = "Sunday Monday Tuesday Wednesday Thursday Friday Saturday".split(" "), r = "January February March April May June July August September October November December".split(" ");\n m = { "%a": (p) => q[p.Jh].substring(0, 3), "%A": (p) => q[p.Jh], "%b": (p) => r[p.Rh].substring(0, 3), "%B": (p) => r[p.Rh], "%C": (p) => f((p.Lh + 1900) / 100 | 0, 2), "%d": (p) => f(p.Th, 2), "%e": (p) => e(p.Th, 2, " "), "%g": (p) => l(p).toString().substring(2), "%G": l, "%H": (p) => f(p.Qh, 2), "%I": (p) => {\n p = p.Qh;\n 0 == p ? p = 12 : 12 < p && (p -= 12);\n return f(p, 2);\n }, "%j": (p) => {\n for (var u = 0, y = 0; y <= p.Rh - 1; u += (W(p.Lh + 1900) ? ec : fc)[y++])\n ;\n return f(p.Th + u, 3);\n }, "%m": (p) => f(p.Rh + 1, 2), "%M": (p) => f(p.ii, 2), "%n": () => "\\n", "%p": (p) => 0 <= p.Qh && 12 > p.Qh ? "AM" : "PM", "%S": (p) => f(p.ji, 2), "%t": () => " ", "%u": (p) => p.Jh || 7, "%U": (p) => f(Math.floor((p.Kh + 7 - p.Jh) / 7), 2), "%V": (p) => {\n var u = Math.floor((p.Kh + 7 - (p.Jh + 6) % 7) / 7);\n 2 >= (p.Jh + 371 - p.Kh - 2) % 7 && u++;\n if (u)\n 53 == u && (y = (p.Jh + 371 - p.Kh) % 7, 4 == y || 3 == y && W(p.Lh) || (u = 1));\n else {\n u = 52;\n var y = (p.Jh + 7 - p.Kh - 1) % 7;\n (4 == y || 5 == y && W(p.Lh % 400 - 1)) && u++;\n }\n return f(u, 2);\n }, "%w": (p) => p.Jh, "%W": (p) => f(Math.floor((p.Kh + 7 - (p.Jh + 6) % 7) / 7), 2), "%y": (p) => (p.Lh + 1900).toString().substring(2), "%Y": (p) => p.Lh + 1900, "%z": (p) => {\n p = p.hi;\n var u = 0 <= p;\n p = Math.abs(p) / 60;\n return (u ? "+" : "-") + String("0000" + (p / 60 * 100 + p % 60)).slice(-4);\n }, "%Z": (p) => p.ki, "%%": () => "%" };\n c = c.replace(/%%/g, "\\0\\0");\n for (n in m)\n c.includes(n) && (c = c.replace(new RegExp(n, "g"), m[n](d)));\n c = c.replace(/\\0\\0/g, "%");\n n = gc(c);\n if (n.length > b)\n return 0;\n z.set(n, a >>> 0);\n return n.length - 1;\n }\n for (var ic = Array(256), jc = 0; 256 > jc; ++jc)\n ic[jc] = String.fromCharCode(jc);\n cb = ic;\n O = g.BindingError = class extends Error {\n constructor(a) {\n super(a);\n this.name = "BindingError";\n }\n };\n g.InternalError = class extends Error {\n constructor(a) {\n super(a);\n this.name = "InternalError";\n }\n };\n Q.push(0, 1, void 0, 1, null, 1, true, 1, false, 1);\n g.count_emval_handles = () => Q.length / 2 - 5 - ib.length;\n var Cf = {\n bd: function(a, b, c) {\n return Ob(async () => {\n await g.bi(a, b, c);\n });\n },\n v: function(a) {\n a = new Sa(a >>> 0);\n 0 == z[a.Ih + 12 >>> 0] && (z[a.Ih + 12 >>> 0] = 1, Ra--);\n z[a.Ih + 13 >>> 0] = 0;\n Qa.push(a);\n kc(a.Nh);\n if (lc(I[a.Ih + 4 >>> 2 >>> 0]))\n a = I[a.Nh >>> 2 >>> 0];\n else {\n var b = I[a.Ih + 16 >>> 2 >>> 0];\n a = 0 !== b ? b : a.Nh;\n }\n return a;\n },\n N: () => {\n X(0, 0);\n var a = Qa.pop();\n mc(a.Nh);\n L = 0;\n },\n a: function() {\n return Za([]);\n },\n m: function(a) {\n return Za([a >>> 0]);\n },\n x: function(a, b) {\n return Za([a >>> 0, b >>> 0]);\n },\n q: function(a, b, c) {\n return Za([a >>> 0, b >>> 0, c >>> 0]);\n },\n Bb: () => {\n var a = Qa.pop();\n a || Ga("no exception to throw");\n var b = a.Nh;\n 0 == z[a.Ih + 13 >>> 0] && (Qa.push(a), z[a.Ih + 13 >>> 0] = 1, z[a.Ih + 12 >>> 0] = 0, Ra++);\n L = b;\n throw L;\n },\n s: function(a, b, c) {\n a >>>= 0;\n var d = new Sa(a);\n I[d.Ih + 16 >>> 2 >>> 0] = 0;\n I[d.Ih + 4 >>> 2 >>> 0] = b >>> 0;\n I[d.Ih + 8 >>> 2 >>> 0] = c >>> 0;\n L = a;\n Ra++;\n throw L;\n },\n fb: () => Ra,\n g: function(a) {\n L ||= a >>> 0;\n throw L;\n },\n Cb: function() {\n return 0;\n },\n $c: function() {\n },\n Mc: function() {\n },\n Oc: function() {\n },\n Gc: function() {\n return 0;\n },\n Zc: function() {\n },\n Uc: function() {\n },\n Yc: function() {\n },\n _b: function() {\n },\n Nc: function() {\n },\n Kc: function() {\n },\n _c: function() {\n },\n Lc: function() {\n },\n Wb: function(a, b, c) {\n b = N(b >>> 0);\n P(a >>> 0, { name: b, fromWireType: (d) => d, toWireType: function(d, e) {\n if ("bigint" != typeof e && "number" != typeof e)\n throw null === e ? e = "null" : (d = typeof e, e = "object" === d || "array" === d || "function" === d ? e.toString() : "" + e), new TypeError(`Cannot convert "${e}" to ${this.name}`);\n "number" == typeof e && (e = BigInt(e));\n return e;\n }, argPackAdvance: 8, readValueFromPointer: hb(b, c >>> 0, -1 == b.indexOf("u")), Mh: null });\n },\n Ec: function(a, b, c, d) {\n b = N(b >>> 0);\n P(a >>> 0, { name: b, fromWireType: function(e) {\n return !!e;\n }, toWireType: function(e, f) {\n return f ? c : d;\n }, argPackAdvance: 8, readValueFromPointer: function(e) {\n return this.fromWireType(E[e >>> 0]);\n }, Mh: null });\n },\n Cc: function(a) {\n return P(a >>> 0, lb);\n },\n Vb: function(a, b, c) {\n b = N(b >>> 0);\n P(a >>> 0, { name: b, fromWireType: (d) => d, toWireType: (d, e) => e, argPackAdvance: 8, readValueFromPointer: mb(b, c >>> 0), Mh: null });\n },\n Aa: function(a, b, c, d, e) {\n a >>>= 0;\n c >>>= 0;\n b = N(b >>> 0);\n -1 === e && (e = 4294967295);\n e = (k) => k;\n if (0 === d) {\n var f = 32 - 8 * c;\n e = (k) => k << f >>> f;\n }\n var h = b.includes("unsigned") ? function(k, l) {\n return l >>> 0;\n } : function(k, l) {\n return l;\n };\n P(a, {\n name: b,\n fromWireType: e,\n toWireType: h,\n argPackAdvance: 8,\n readValueFromPointer: hb(b, c, 0 !== d),\n Mh: null\n });\n },\n _: function(a, b, c) {\n function d(f) {\n return new e(z.buffer, I[f + 4 >>> 2 >>> 0], I[f >>> 2 >>> 0]);\n }\n var e = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array][b];\n c = N(c >>> 0);\n P(a >>> 0, { name: c, fromWireType: d, argPackAdvance: 8, readValueFromPointer: d }, { Xh: true });\n },\n Xb: function(a, b) {\n b = N(b >>> 0);\n var c = "std::string" === b;\n P(a >>> 0, { name: b, fromWireType: function(d) {\n var e = I[d >>> 2 >>> 0], f = d + 4;\n if (c)\n for (var h = f, k = 0; k <= e; ++k) {\n var l = f + k;\n if (k == e || 0 == E[l >>> 0]) {\n h = J(h, l - h);\n if (void 0 === m)\n var m = h;\n else\n m += String.fromCharCode(0), m += h;\n h = l + 1;\n }\n }\n else {\n m = Array(e);\n for (k = 0; k < e; ++k)\n m[k] = String.fromCharCode(E[f + k >>> 0]);\n m = m.join("");\n }\n T(d);\n return m;\n }, toWireType: function(d, e) {\n e instanceof ArrayBuffer && (e = new Uint8Array(e));\n var f = "string" == typeof e;\n if (!(f || e instanceof Uint8Array || e instanceof Uint8ClampedArray || e instanceof Int8Array))\n throw new O("Cannot pass non-string to std::string");\n var h = c && f ? bb(e) : e.length;\n var k = Jb(4 + h + 1), l = k + 4;\n I[k >>> 2 >>> 0] = h;\n if (c && f)\n M(e, E, l, h + 1);\n else if (f)\n for (f = 0; f < h; ++f) {\n var m = e.charCodeAt(f);\n if (255 < m)\n throw T(l), new O("String has UTF-16 code units that do not fit in 8 bits");\n E[l + f >>> 0] = m;\n }\n else\n for (f = 0; f < h; ++f)\n E[l + f >>> 0] = e[f];\n null !== d && d.push(T, k);\n return k;\n }, argPackAdvance: 8, readValueFromPointer: kb, Mh(d) {\n T(d);\n } });\n },\n Ab: function(a, b, c) {\n b >>>= 0;\n c >>>= 0;\n c = N(c);\n if (2 === b) {\n var d = ob;\n var e = pb;\n var f = qb;\n var h = (k) => ua[k >>> 1 >>> 0];\n } else\n 4 === b && (d = rb, e = sb, f = tb, h = (k) => I[k >>> 2 >>> 0]);\n P(a >>> 0, {\n name: c,\n fromWireType: (k) => {\n for (var l = I[k >>> 2 >>> 0], m, n = k + 4, q = 0; q <= l; ++q) {\n var r = k + 4 + q * b;\n if (q == l || 0 == h(r))\n n = d(n, r - n), void 0 === m ? m = n : (m += String.fromCharCode(0), m += n), n = r + b;\n }\n T(k);\n return m;\n },\n toWireType: (k, l) => {\n if ("string" != typeof l)\n throw new O(`Cannot pass non-string to C++ string type ${c}`);\n var m = f(l), n = Jb(4 + m + b);\n I[n >>> 2 >>> 0] = m / b;\n e(l, n + 4, m + b);\n null !== k && k.push(T, n);\n return n;\n },\n argPackAdvance: 8,\n readValueFromPointer: kb,\n Mh(k) {\n T(k);\n }\n });\n },\n Fc: function(a, b) {\n b = N(b >>> 0);\n P(a >>> 0, { Yh: true, name: b, argPackAdvance: 0, fromWireType: () => {\n }, toWireType: () => {\n } });\n },\n ad: () => 1,\n kd: function(a, b, c) {\n b >>>= 0;\n c >>>= 0;\n a = R(a >>> 0);\n b = vb(b, "emval::as");\n return wb(b, c, a);\n },\n Cd: function(a) {\n a >>>= 0;\n return Ob(() => {\n a = R(a);\n return a.then(S);\n });\n },\n ud: function(a, b, c, d) {\n c >>>= 0;\n d >>>= 0;\n a = Pb[a >>> 0];\n b = R(b >>> 0);\n return a(null, b, c, d);\n },\n ia: function(a, b, c, d, e) {\n c >>>= 0;\n d >>>= 0;\n e >>>= 0;\n a = Pb[a >>> 0];\n b = R(b >>> 0);\n c = Rb(c);\n return a(b, b[c], d, e);\n },\n Bc: jb,\n qd: function(a, b) {\n b >>>= 0;\n a = R(a >>> 0);\n b = R(b);\n return a == b;\n },\n zd: function(a) {\n a >>>= 0;\n if (0 === a)\n return S(Sb());\n a = Rb(a);\n return S(Sb()[a]);\n },\n ha: function(a, b, c) {\n b = Ub(a, b >>> 0);\n var d = b.shift();\n a--;\n var e = "return function (obj, func, destructorsRef, args) {\\n", f = 0, h = [];\n 0 === c && h.push("obj");\n for (var k = ["retType"], l = [d], m = 0; m < a; ++m)\n h.push("arg" + m), k.push("argType" + m), l.push(b[m]), e += ` var arg${m} = argType${m}.readValueFromPointer(args${f ? "+" + f : ""});\n`, f += b[m].argPackAdvance;\n e += ` var rv = ${1 === c ? "new func" : "func.call"}(${h.join(", ")});\n`;\n d.Yh || (k.push("emval_returnValue"), l.push(wb), e += " return emval_returnValue(retType, destructorsRef, rv);\\n");\n k.push(e + "};\\n");\n a = Wb(k)(...l);\n c = `methodCaller<(${b.map((n) => n.name).join(", ")}) => ${d.name}>`;\n return Tb(Vb(c, a));\n },\n yd: function(a, b) {\n b >>>= 0;\n a = R(a >>> 0);\n b = R(b);\n return S(a[b]);\n },\n ba: function(a) {\n a >>>= 0;\n 9 < a && (Q[a + 1] += 1);\n },\n md: function() {\n return S([]);\n },\n hd: function(a) {\n a = R(a >>> 0);\n for (var b = Array(a.length), c = 0; c < a.length; c++)\n b[c] = a[c];\n return S(b);\n },\n U: function(a) {\n return S(Rb(a >>> 0));\n },\n Xa: function() {\n return S({});\n },\n vd: function(a) {\n a >>>= 0;\n for (var b = R(a); b.length; ) {\n var c = b.pop();\n b.pop()(c);\n }\n jb(a);\n },\n sd: function(a, b, c) {\n b >>>= 0;\n c >>>= 0;\n a = R(a >>> 0);\n b = R(b);\n c = R(c);\n a[b] = c;\n },\n zb: function(a, b) {\n b >>>= 0;\n a = vb(a >>> 0, "_emval_take_value");\n a = a.readValueFromPointer(b);\n return S(a);\n },\n Rc: function(a, b) {\n a = -9007199254740992 > a || 9007199254740992 < a ? NaN : Number(a);\n b >>>= 0;\n a = new Date(1e3 * a);\n G[b >>> 2 >>> 0] = a.getUTCSeconds();\n G[b + 4 >>> 2 >>> 0] = a.getUTCMinutes();\n G[b + 8 >>> 2 >>> 0] = a.getUTCHours();\n G[b + 12 >>> 2 >>> 0] = a.getUTCDate();\n G[b + 16 >>> 2 >>> 0] = a.getUTCMonth();\n G[b + 20 >>> 2 >>> 0] = a.getUTCFullYear() - 1900;\n G[b + 24 >>> 2 >>> 0] = a.getUTCDay();\n G[b + 28 >>> 2 >>> 0] = (a.getTime() - Date.UTC(\n a.getUTCFullYear(),\n 0,\n 1,\n 0,\n 0,\n 0,\n 0\n )) / 864e5 | 0;\n },\n Sc: function(a, b) {\n a = -9007199254740992 > a || 9007199254740992 < a ? NaN : Number(a);\n b >>>= 0;\n a = new Date(1e3 * a);\n G[b >>> 2 >>> 0] = a.getSeconds();\n G[b + 4 >>> 2 >>> 0] = a.getMinutes();\n G[b + 8 >>> 2 >>> 0] = a.getHours();\n G[b + 12 >>> 2 >>> 0] = a.getDate();\n G[b + 16 >>> 2 >>> 0] = a.getMonth();\n G[b + 20 >>> 2 >>> 0] = a.getFullYear() - 1900;\n G[b + 24 >>> 2 >>> 0] = a.getDay();\n G[b + 28 >>> 2 >>> 0] = (W(a.getFullYear()) ? Xb : Yb)[a.getMonth()] + a.getDate() - 1 | 0;\n G[b + 36 >>> 2 >>> 0] = -(60 * a.getTimezoneOffset());\n var c = new Date(a.getFullYear(), 6, 1).getTimezoneOffset(), d = new Date(a.getFullYear(), 0, 1).getTimezoneOffset();\n G[b + 32 >>> 2 >>> 0] = (c != d && a.getTimezoneOffset() == Math.min(d, c)) | 0;\n },\n Tc: function(a) {\n a >>>= 0;\n var b = new Date(G[a + 20 >>> 2 >>> 0] + 1900, G[a + 16 >>> 2 >>> 0], G[a + 12 >>> 2 >>> 0], G[a + 8 >>> 2 >>> 0], G[a + 4 >>> 2 >>> 0], G[a >>> 2 >>> 0], 0), c = G[a + 32 >>> 2 >>> 0], d = b.getTimezoneOffset(), e = new Date(b.getFullYear(), 6, 1).getTimezoneOffset(), f = new Date(b.getFullYear(), 0, 1).getTimezoneOffset(), h = Math.min(f, e);\n 0 > c ? G[a + 32 >>> 2 >>> 0] = Number(e != f && h == d) : 0 < c != (h == d) && (e = Math.max(f, e), b.setTime(b.getTime() + 6e4 * ((0 < c ? h : e) - d)));\n G[a + 24 >>> 2 >>> 0] = b.getDay();\n G[a + 28 >>> 2 >>> 0] = (W(b.getFullYear()) ? Xb : Yb)[b.getMonth()] + b.getDate() - 1 | 0;\n G[a >>> 2 >>> 0] = b.getSeconds();\n G[a + 4 >>> 2 >>> 0] = b.getMinutes();\n G[a + 8 >>> 2 >>> 0] = b.getHours();\n G[a + 12 >>> 2 >>> 0] = b.getDate();\n G[a + 16 >>> 2 >>> 0] = b.getMonth();\n G[a + 20 >>> 2 >>> 0] = b.getYear();\n a = b.getTime();\n return BigInt(isNaN(a) ? -1 : a / 1e3);\n },\n Pc: function() {\n return -52;\n },\n Qc: function() {\n },\n Ic: function(a, b, c, d) {\n c >>>= 0;\n d >>>= 0;\n var e = (/* @__PURE__ */ new Date()).getFullYear(), f = new Date(e, 0, 1), h = new Date(e, 6, 1);\n e = f.getTimezoneOffset();\n var k = h.getTimezoneOffset();\n I[a >>> 0 >>> 2 >>> 0] = 60 * Math.max(e, k);\n G[b >>> 0 >>> 2 >>> 0] = Number(e != k);\n a = (l) => l.toLocaleTimeString(void 0, { hour12: false, timeZoneName: "short" }).split(" ")[1];\n f = a(f);\n h = a(h);\n k < e ? (M(f, E, c, 17), M(h, E, d, 17)) : (M(f, E, d, 17), M(h, E, c, 17));\n },\n bb: () => {\n Ga("");\n },\n A: function(a, b, c) {\n a >>>= 0;\n b = $b(b >>> 0, c >>> 0);\n return Oa[a](...b);\n },\n bc: function(a, b, c) {\n a >>>= 0;\n b = $b(b >>> 0, c >>> 0);\n return Oa[a](...b);\n },\n $b: () => Date.now(),\n Jc: function() {\n return 4294901760;\n },\n ga: () => performance.now(),\n Hc: function(a) {\n a >>>= 0;\n var b = E.length;\n if (4294901760 < a)\n return false;\n for (var c = 1; 4 >= c; c *= 2) {\n var d = b * (1 + 0.2 / c);\n d = Math.min(d, a + 100663296);\n var e = Math;\n d = Math.max(a, d);\n a: {\n e = (e.min.call(e, 4294901760, d + (65536 - d % 65536) % 65536) - ra.buffer.byteLength + 65535) / 65536;\n try {\n ra.grow(e);\n za();\n var f = 1;\n break a;\n } catch (h) {\n }\n f = void 0;\n }\n if (f)\n return true;\n }\n return false;\n },\n Wc: function(a, b) {\n a >>>= 0;\n b >>>= 0;\n var c = 0;\n cc().forEach((d, e) => {\n var f = b + c;\n e = I[a + 4 * e >>> 2 >>> 0] = f;\n for (f = 0; f < d.length; ++f)\n z[e++ >>> 0] = d.charCodeAt(f);\n z[e >>> 0] = 0;\n c += d.length + 1;\n });\n return 0;\n },\n Xc: function(a, b) {\n a >>>= 0;\n b >>>= 0;\n var c = cc();\n I[a >>> 2 >>> 0] = c.length;\n var d = 0;\n c.forEach((e) => d += e.length + 1);\n I[b >>> 2 >>> 0] = d;\n return 0;\n },\n Db: () => 52,\n Zb: function() {\n return 52;\n },\n Vc: function() {\n return 70;\n },\n Yb: function(a, b, c, d) {\n b >>>= 0;\n c >>>= 0;\n d >>>= 0;\n for (var e = 0, f = 0; f < c; f++) {\n var h = I[b >>> 2 >>> 0], k = I[b + 4 >>> 2 >>> 0];\n b += 8;\n for (var l = 0; l < k; l++) {\n var m = E[h + l >>> 0], n = dc[a];\n 0 === m || 10 === m ? ((1 === a ? qa : w)(ab(n, 0)), n.length = 0) : n.push(m);\n }\n e += k;\n }\n I[d >>> 2 >>> 0] = e;\n return 0;\n },\n xb: nc,\n cd: oc,\n ua: pc,\n W: qc,\n $: rc,\n ra: sc,\n ta: tc,\n dd: uc,\n ob: vc,\n P: wc,\n z: xc,\n b: yc,\n Ub: zc,\n ya: Ac,\n e: Bc,\n kb: Cc,\n h: Dc,\n X: Ec,\n i: Fc,\n ed: Gc,\n j: Hc,\n t: Ic,\n r: Jc,\n o: Kc,\n Wa: Lc,\n Ca: Mc,\n ma: Nc,\n Qb: Oc,\n db: Pc,\n Ib: Qc,\n mb: Rc,\n kc: Sc,\n xc: Tc,\n hc: Uc,\n ic: Vc,\n ac: Wc,\n oa: Xc,\n yb: Yc,\n Ba: Zc,\n Eb: $c,\n ea: ad,\n jc: bd,\n Ta: cd,\n F: dd,\n G: ed,\n Gb: fd,\n jd: gd,\n qa: hd,\n O: jd,\n V: kd,\n T: ld,\n y: md,\n Fb: nd,\n gc: od,\n D: pd,\n Hb: qd,\n id: rd,\n Ua: sd,\n wa: td,\n lc: ud,\n cc: vd,\n Nb: wd,\n aa: xd,\n I: yd,\n C: zd,\n _a: Ad,\n fc: Bd,\n Q: Cd,\n d: Dd,\n ab: Ed,\n n: Fd,\n Ya: Gd,\n va: Hd,\n wb: Id,\n f: Jd,\n yc: Kd,\n da: Ld,\n gb: Md,\n Da: Nd,\n lb: Od,\n hb: Pd,\n c: Qd,\n vc: Rd,\n od: Sd,\n k: Td,\n tc: Ud,\n l: Vd,\n wc: Wd,\n sc: Xd,\n rd: Yd,\n p: Zd,\n Ra: $d,\n tb: ae,\n Qa: be,\n Kb: ce,\n B: de,\n K: ee,\n S: fe,\n $a: ge,\n pc: he,\n ub: ie,\n za: je,\n ka: ke,\n xa: le,\n Sb: me,\n La: ne,\n jb: oe,\n Ga: pe,\n nc: qe,\n Ha: re,\n Ia: se,\n fd: te,\n xd: ue,\n Z: ve,\n pa: we,\n pd: xe,\n wd: ye,\n Mb: ze,\n Ma: Ae,\n Ka: Be,\n Tb: Ce,\n rc: De,\n Ja: Ee,\n Na: Fe,\n pb: Ge,\n la: He,\n Ea: Ie,\n mc: Je,\n qc: Ke,\n Jb: Le,\n Fa: Me,\n ja: Ne,\n Ad: Oe,\n nd: Pe,\n R: Qe,\n eb: Re,\n Za: Se,\n ec: Te,\n ib: Ue,\n E: Ve,\n M: We,\n Va: Xe,\n ld: Ye,\n ca: Ze,\n nb: $e,\n na: af,\n dc: bf,\n Ac: cf,\n u: df,\n L: ef,\n td: ff,\n Pb: gf,\n oc: hf,\n Bd: jf,\n Ob: kf,\n Lb: lf,\n cb: mf,\n zc: nf,\n Rb: of,\n Oa: pf,\n Y: qf,\n uc: rf,\n J: sf,\n gd: tf,\n vb: uf,\n sa: vf,\n H: wf,\n rb: xf,\n Pa: yf,\n Sa: zf,\n sb: Af,\n qb: Bf,\n w: function(a) {\n return a >>> 0;\n },\n Dc: hc,\n fa: function(a, b, c, d) {\n return hc(a >>> 0, b >>> 0, c >>> 0, d >>> 0);\n }\n }, U = function() {\n function a(c) {\n U = c.exports;\n U = zb();\n U = Df();\n ra = U.Dd;\n za();\n Ba.unshift(U.Ed);\n Da--;\n 0 == Da && (null !== Ea && (clearInterval(Ea), Ea = null), Fa && (c = Fa, Fa = null, c()));\n return U;\n }\n var b = { a: Cf };\n Da++;\n if (g.instantiateWasm)\n try {\n return g.instantiateWasm(b, a);\n } catch (c) {\n w(`Module.instantiateWasm callback failed with error: ${c}`), ba(c);\n }\n Na(b, function(c) {\n a(c.instance);\n }).catch(ba);\n return {};\n }(), ub = (a) => (ub = U.Fd)(a);\n g._OrtInit = (a, b) => (g._OrtInit = U.Gd)(a, b);\n g._OrtGetLastError = (a, b) => (g._OrtGetLastError = U.Hd)(a, b);\n g._OrtCreateSessionOptions = (a, b, c, d, e, f, h, k, l, m) => (g._OrtCreateSessionOptions = U.Id)(a, b, c, d, e, f, h, k, l, m);\n g._OrtAppendExecutionProvider = (a, b) => (g._OrtAppendExecutionProvider = U.Jd)(a, b);\n g._OrtAddFreeDimensionOverride = (a, b, c) => (g._OrtAddFreeDimensionOverride = U.Kd)(a, b, c);\n g._OrtAddSessionConfigEntry = (a, b, c) => (g._OrtAddSessionConfigEntry = U.Ld)(a, b, c);\n g._OrtReleaseSessionOptions = (a) => (g._OrtReleaseSessionOptions = U.Md)(a);\n g._OrtCreateSession = (a, b, c) => (g._OrtCreateSession = U.Nd)(a, b, c);\n g._OrtReleaseSession = (a) => (g._OrtReleaseSession = U.Od)(a);\n g._OrtGetInputOutputCount = (a, b, c) => (g._OrtGetInputOutputCount = U.Pd)(a, b, c);\n g._OrtGetInputName = (a, b) => (g._OrtGetInputName = U.Qd)(a, b);\n g._OrtGetOutputName = (a, b) => (g._OrtGetOutputName = U.Rd)(a, b);\n g._OrtFree = (a) => (g._OrtFree = U.Sd)(a);\n g._OrtCreateTensor = (a, b, c, d, e, f) => (g._OrtCreateTensor = U.Td)(a, b, c, d, e, f);\n g._OrtGetTensorData = (a, b, c, d, e) => (g._OrtGetTensorData = U.Ud)(a, b, c, d, e);\n g._OrtReleaseTensor = (a) => (g._OrtReleaseTensor = U.Vd)(a);\n g._OrtCreateRunOptions = (a, b, c, d) => (g._OrtCreateRunOptions = U.Wd)(a, b, c, d);\n g._OrtAddRunConfigEntry = (a, b, c) => (g._OrtAddRunConfigEntry = U.Xd)(a, b, c);\n g._OrtReleaseRunOptions = (a) => (g._OrtReleaseRunOptions = U.Yd)(a);\n g._OrtCreateBinding = (a) => (g._OrtCreateBinding = U.Zd)(a);\n g._OrtBindInput = (a, b, c) => (g._OrtBindInput = U._d)(a, b, c);\n g._OrtBindOutput = (a, b, c, d) => (g._OrtBindOutput = U.$d)(a, b, c, d);\n g._OrtClearBoundOutputs = (a) => (g._OrtClearBoundOutputs = U.ae)(a);\n g._OrtReleaseBinding = (a) => (g._OrtReleaseBinding = U.be)(a);\n g._OrtRunWithBinding = (a, b, c, d, e) => (g._OrtRunWithBinding = U.ce)(a, b, c, d, e);\n g._OrtRun = (a, b, c, d, e, f, h, k) => (g._OrtRun = U.de)(a, b, c, d, e, f, h, k);\n g._OrtEndProfiling = (a) => (g._OrtEndProfiling = U.ee)(a);\n g._JsepOutput = (a, b, c) => (g._JsepOutput = U.fe)(a, b, c);\n g._JsepGetNodeName = (a) => (g._JsepGetNodeName = U.ge)(a);\n var Jb = g._malloc = (a) => (Jb = g._malloc = U.he)(a), T = g._free = (a) => (T = g._free = U.ie)(a), X = (a, b) => (X = U.ke)(a, b), Ta = (a) => (Ta = U.le)(a), Y = (a) => (Y = U.me)(a), Ef = (a) => (Ef = U.ne)(a), Z = () => (Z = U.oe)(), mc = (a) => (mc = U.pe)(a), kc = (a) => (kc = U.qe)(a), Ua = (a, b, c) => (Ua = U.re)(a, b, c), lc = (a) => (lc = U.se)(a), dynCall_vii = g.dynCall_vii = (a, b, c) => (dynCall_vii = g.dynCall_vii = U.te)(a, b, c), Ff = g.dynCall_iiii = (a, b, c, d) => (Ff = g.dynCall_iiii = U.ue)(a, b, c, d), dynCall_iii = g.dynCall_iii = (a, b, c) => (dynCall_iii = g.dynCall_iii = U.ve)(a, b, c), Gf = g.dynCall_ii = (a, b) => (Gf = g.dynCall_ii = U.we)(a, b), Hf = g.dynCall_iiiiiii = (a, b, c, d, e, f, h) => (Hf = g.dynCall_iiiiiii = U.xe)(a, b, c, d, e, f, h), dynCall_vi = g.dynCall_vi = (a, b) => (dynCall_vi = g.dynCall_vi = U.ye)(a, b), dynCall_v = g.dynCall_v = (a) => (dynCall_v = g.dynCall_v = U.ze)(a), If = g.dynCall_iiiiii = (a, b, c, d, e, f) => (If = g.dynCall_iiiiii = U.Ae)(a, b, c, d, e, f), Jf = g.dynCall_iiij = (a, b, c, d) => (Jf = g.dynCall_iiij = U.Be)(a, b, c, d), Kf = g.dynCall_iiiii = (a, b, c, d, e) => (Kf = g.dynCall_iiiii = U.Ce)(a, b, c, d, e), Lf = g.dynCall_viii = (a, b, c, d) => (Lf = g.dynCall_viii = U.De)(a, b, c, d), Mf = g.dynCall_viiiii = (a, b, c, d, e, f) => (Mf = g.dynCall_viiiii = U.Ee)(a, b, c, d, e, f), Nf = g.dynCall_viiii = (a, b, c, d, e) => (Nf = g.dynCall_viiii = U.Fe)(a, b, c, d, e), Of = g.dynCall_viiiiii = (a, b, c, d, e, f, h) => (Of = g.dynCall_viiiiii = U.Ge)(a, b, c, d, e, f, h), Pf = g.dynCall_viiji = (a, b, c, d, e) => (Pf = g.dynCall_viiji = U.He)(a, b, c, d, e), Qf = g.dynCall_viiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q) => (Qf = g.dynCall_viiiiiiiiiii = U.Ie)(a, b, c, d, e, f, h, k, l, m, n, q), Rf = g.dynCall_viiijjjii = (a, b, c, d, e, f, h, k, l) => (Rf = g.dynCall_viiijjjii = U.Je)(a, b, c, d, e, f, h, k, l), Sf = g.dynCall_iid = (a, b, c) => (Sf = g.dynCall_iid = U.Ke)(a, b, c), Tf = g.dynCall_iif = (a, b, c) => (Tf = g.dynCall_iif = U.Le)(a, b, c), Uf = g.dynCall_iij = (a, b, c) => (Uf = g.dynCall_iij = U.Me)(a, b, c), Vf = g.dynCall_jii = (a, b, c) => (Vf = g.dynCall_jii = U.Ne)(a, b, c), Wf = g.dynCall_i = (a) => (Wf = g.dynCall_i = U.Oe)(a), Xf = g.dynCall_viiiiiiii = (a, b, c, d, e, f, h, k, l) => (Xf = g.dynCall_viiiiiiii = U.Pe)(a, b, c, d, e, f, h, k, l), Yf = g.dynCall_viiiiij = (a, b, c, d, e, f, h) => (Yf = g.dynCall_viiiiij = U.Qe)(a, b, c, d, e, f, h), Zf = g.dynCall_ji = (a, b) => (Zf = g.dynCall_ji = U.Re)(a, b), $f = g.dynCall_viij = (a, b, c, d) => ($f = g.dynCall_viij = U.Se)(a, b, c, d), ag = g.dynCall_iiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q) => (ag = g.dynCall_iiiiiiiiiiii = U.Te)(a, b, c, d, e, f, h, k, l, m, n, q), bg = g.dynCall_viiiiiiiii = (a, b, c, d, e, f, h, k, l, m) => (bg = g.dynCall_viiiiiiiii = U.Ue)(a, b, c, d, e, f, h, k, l, m), cg = g.dynCall_ij = (a, b) => (cg = g.dynCall_ij = U.Ve)(a, b), dg = g.dynCall_iiiiij = (a, b, c, d, e, f) => (dg = g.dynCall_iiiiij = U.We)(a, b, c, d, e, f), eg = g.dynCall_j = (a) => (eg = g.dynCall_j = U.Xe)(a), fg = g.dynCall_vij = (a, b, c) => (fg = g.dynCall_vij = U.Ye)(a, b, c), gg = g.dynCall_viijjjiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q) => (gg = g.dynCall_viijjjiiiiii = U.Ze)(a, b, c, d, e, f, h, k, l, m, n, q), hg = g.dynCall_viiijiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q) => (hg = g.dynCall_viiijiiiiiii = U._e)(a, b, c, d, e, f, h, k, l, m, n, q), ig = g.dynCall_iiiiiiii = (a, b, c, d, e, f, h, k) => (ig = g.dynCall_iiiiiiii = U.$e)(a, b, c, d, e, f, h, k), jg = g.dynCall_viiiiiii = (a, b, c, d, e, f, h, k) => (jg = g.dynCall_viiiiiii = U.af)(a, b, c, d, e, f, h, k), kg = g.dynCall_iiiiiiiij = (a, b, c, d, e, f, h, k, l) => (kg = g.dynCall_iiiiiiiij = U.bf)(a, b, c, d, e, f, h, k, l), lg = g.dynCall_viiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (lg = g.dynCall_viiiiiiiiiiiii = U.cf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), mg = g.dynCall_iiiiiiiii = (a, b, c, d, e, f, h, k, l) => (mg = g.dynCall_iiiiiiiii = U.df)(a, b, c, d, e, f, h, k, l), ng = g.dynCall_iiiiijiiiii = (a, b, c, d, e, f, h, k, l, m, n) => (ng = g.dynCall_iiiiijiiiii = U.ef)(a, b, c, d, e, f, h, k, l, m, n), og = g.dynCall_vijjjiiij = (a, b, c, d, e, f, h, k, l) => (og = g.dynCall_vijjjiiij = U.ff)(a, b, c, d, e, f, h, k, l), pg = g.dynCall_fi = (a, b) => (pg = g.dynCall_fi = U.gf)(a, b), qg = g.dynCall_fii = (a, b, c) => (qg = g.dynCall_fii = U.hf)(a, b, c), rg = g.dynCall_di = (a, b) => (rg = g.dynCall_di = U.jf)(a, b), sg = g.dynCall_dii = (a, b, c) => (sg = g.dynCall_dii = U.kf)(a, b, c), tg = g.dynCall_vijj = (a, b, c, d) => (tg = g.dynCall_vijj = U.lf)(a, b, c, d), ug = g.dynCall_iiiiiiiiii = (a, b, c, d, e, f, h, k, l, m) => (ug = g.dynCall_iiiiiiiiii = U.mf)(a, b, c, d, e, f, h, k, l, m), vg = g.dynCall_viijiii = (a, b, c, d, e, f, h) => (vg = g.dynCall_viijiii = U.nf)(a, b, c, d, e, f, h), wg = g.dynCall_viid = (a, b, c, d) => (wg = g.dynCall_viid = U.of)(a, b, c, d), xg = g.dynCall_viffiii = (a, b, c, d, e, f, h) => (xg = g.dynCall_viffiii = U.pf)(a, b, c, d, e, f, h), yg = g.dynCall_viifiii = (a, b, c, d, e, f, h) => (yg = g.dynCall_viifiii = U.qf)(a, b, c, d, e, f, h), zg = g.dynCall_viiiiidiidi = (a, b, c, d, e, f, h, k, l, m, n) => (zg = g.dynCall_viiiiidiidi = U.rf)(a, b, c, d, e, f, h, k, l, m, n), Ag = g.dynCall_viiiiiiiiidi = (a, b, c, d, e, f, h, k, l, m, n, q) => (Ag = g.dynCall_viiiiiiiiidi = U.sf)(a, b, c, d, e, f, h, k, l, m, n, q), Bg = g.dynCall_jiii = (a, b, c, d) => (Bg = g.dynCall_jiii = U.tf)(a, b, c, d), Cg = g.dynCall_vjiiiiii = (a, b, c, d, e, f, h, k) => (Cg = g.dynCall_vjiiiiii = U.uf)(a, b, c, d, e, f, h, k), Dg = g.dynCall_viiid = (a, b, c, d, e) => (Dg = g.dynCall_viiid = U.vf)(a, b, c, d, e), Eg = g.dynCall_viiiiiiiiiji = (a, b, c, d, e, f, h, k, l, m, n, q) => (Eg = g.dynCall_viiiiiiiiiji = U.wf)(a, b, c, d, e, f, h, k, l, m, n, q), Fg = g.dynCall_viji = (a, b, c, d) => (Fg = g.dynCall_viji = U.xf)(a, b, c, d), Gg = g.dynCall_vijjjjjjjjjjjjji = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => (Gg = g.dynCall_vijjjjjjjjjjjjji = U.yf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y), Hg = g.dynCall_viiiji = (a, b, c, d, e, f) => (Hg = g.dynCall_viiiji = U.zf)(a, b, c, d, e, f), Ig = g.dynCall_vijjjiiji = (a, b, c, d, e, f, h, k, l) => (Ig = g.dynCall_vijjjiiji = U.Af)(a, b, c, d, e, f, h, k, l), Jg = g.dynCall_iiiji = (a, b, c, d, e) => (Jg = g.dynCall_iiiji = U.Bf)(a, b, c, d, e), Kg = g.dynCall_iiijiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (Kg = g.dynCall_iiijiiiiiiiiii = U.Cf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), Lg = g.dynCall_vj = (a, b) => (Lg = g.dynCall_vj = U.Df)(a, b), Mg = g.dynCall_jjj = (a, b, c) => (Mg = g.dynCall_jjj = U.Ef)(a, b, c), Ng = g.dynCall_iiijiiiiii = (a, b, c, d, e, f, h, k, l, m) => (Ng = g.dynCall_iiijiiiiii = U.Ff)(a, b, c, d, e, f, h, k, l, m), Og = g.dynCall_vfiii = (a, b, c, d, e) => (Og = g.dynCall_vfiii = U.Gf)(a, b, c, d, e), Pg = g.dynCall_viiiiff = (a, b, c, d, e, f, h) => (Pg = g.dynCall_viiiiff = U.Hf)(a, b, c, d, e, f, h), Qg = g.dynCall_viiiiiff = (a, b, c, d, e, f, h, k) => (Qg = g.dynCall_viiiiiff = U.If)(a, b, c, d, e, f, h, k), Rg = g.dynCall_viiff = (a, b, c, d, e) => (Rg = g.dynCall_viiff = U.Jf)(a, b, c, d, e), Sg = g.dynCall_viiiiiiiiifiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (Sg = g.dynCall_viiiiiiiiifiii = U.Kf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), Tg = g.dynCall_viiiiiiiijj = (a, b, c, d, e, f, h, k, l, m, n) => (Tg = g.dynCall_viiiiiiiijj = U.Lf)(a, b, c, d, e, f, h, k, l, m, n), Ug = g.dynCall_iiiiiiiiiiiiiifii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) => (Ug = g.dynCall_iiiiiiiiiiiiiifii = U.Mf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A), Vg = g.dynCall_viiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Vg = g.dynCall_viiiiiiiiiiii = U.Nf)(a, b, c, d, e, f, h, k, l, m, n, q, r), Wg = g.dynCall_iiiiiiiiiiiiiiiiifii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) => (Wg = g.dynCall_iiiiiiiiiiiiiiiiifii = U.Of)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D), Xg = g.dynCall_vijjiiiiii = (a, b, c, d, e, f, h, k, l, m) => (Xg = g.dynCall_vijjiiiiii = U.Pf)(a, b, c, d, e, f, h, k, l, m), Yg = g.dynCall_iiiijjj = (a, b, c, d, e, f, h) => (Yg = g.dynCall_iiiijjj = U.Qf)(a, b, c, d, e, f, h), Zg = g.dynCall_viiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n) => (Zg = g.dynCall_viiiiiiiiii = U.Rf)(a, b, c, d, e, f, h, k, l, m, n), $g = g.dynCall_iiijjj = (a, b, c, d, e, f) => ($g = g.dynCall_iiijjj = U.Sf)(a, b, c, d, e, f), ah = g.dynCall_fffffff = (a, b, c, d, e, f, h) => (ah = g.dynCall_fffffff = U.Tf)(a, b, c, d, e, f, h), bh = g.dynCall_viiiij = (a, b, c, d, e, f) => (bh = g.dynCall_viiiij = U.Uf)(a, b, c, d, e, f), ch = g.dynCall_viiiiiijiifiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (ch = g.dynCall_viiiiiijiifiii = U.Vf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), dh = g.dynCall_vjjjjjjffjifiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B) => (dh = g.dynCall_vjjjjjjffjifiiiiii = U.Wf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B), eh = g.dynCall_viiiiiiffjifiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) => (eh = g.dynCall_viiiiiiffjifiiiii = U.Xf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A), fh = g.dynCall_viiiiiiffjfiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => (fh = g.dynCall_viiiiiiffjfiiiii = U.Yf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y), gh = g.dynCall_viiiiiiffjiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => (gh = g.dynCall_viiiiiiffjiiiii = U.Zf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u), hh = g.dynCall_vjjjjjjjjfffiiifiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) => (hh = g.dynCall_vjjjjjjjjfffiiifiiiii = U._f)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F), ih = g.dynCall_vjjjjjjfffifijiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C) => (ih = g.dynCall_vjjjjjjfffifijiiiii = U.$f)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C), jh = g.dynCall_vjjjjjjfffifiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B) => (jh = g.dynCall_vjjjjjjfffifiiiiii = U.ag)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B), kh = g.dynCall_vjjjjjjjjfffjifiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) => (kh = g.dynCall_vjjjjjjjjfffjifiiiiii = U.bg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F), lh = g.dynCall_vijiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (lh = g.dynCall_vijiiiiiiiiii = U.cg)(a, b, c, d, e, f, h, k, l, m, n, q, r), mh = g.dynCall_vijjfffiii = (a, b, c, d, e, f, h, k, l, m) => (mh = g.dynCall_vijjfffiii = U.dg)(a, b, c, d, e, f, h, k, l, m), nh = g.dynCall_viiiiiiijiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (nh = g.dynCall_viiiiiiijiiii = U.eg)(a, b, c, d, e, f, h, k, l, m, n, q, r), oh = g.dynCall_vijjjjjjifiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => (oh = g.dynCall_vijjjjjjifiiiii = U.fg)(\n a,\n b,\n c,\n d,\n e,\n f,\n h,\n k,\n l,\n m,\n n,\n q,\n r,\n p,\n u\n ), ph = g.dynCall_viifi = (a, b, c, d, e) => (ph = g.dynCall_viifi = U.gg)(a, b, c, d, e), qh = g.dynCall_vjjjjjiiii = (a, b, c, d, e, f, h, k, l, m) => (qh = g.dynCall_vjjjjjiiii = U.hg)(a, b, c, d, e, f, h, k, l, m), rh = g.dynCall_vjjjjfiii = (a, b, c, d, e, f, h, k, l) => (rh = g.dynCall_vjjjjfiii = U.ig)(a, b, c, d, e, f, h, k, l), sh = g.dynCall_viiiiiijiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (sh = g.dynCall_viiiiiijiiiiii = U.jg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), th = g.dynCall_vijjii = (a, b, c, d, e, f) => (th = g.dynCall_vijjii = U.kg)(a, b, c, d, e, f), uh = g.dynCall_viiiiijjiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (uh = g.dynCall_viiiiijjiiiii = U.lg)(a, b, c, d, e, f, h, k, l, m, n, q, r), vh = g.dynCall_iiiiiji = (a, b, c, d, e, f, h) => (vh = g.dynCall_iiiiiji = U.mg)(a, b, c, d, e, f, h), wh = g.dynCall_iiiiji = (a, b, c, d, e, f) => (wh = g.dynCall_iiiiji = U.ng)(a, b, c, d, e, f), xh = g.dynCall_viiiiijiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (xh = g.dynCall_viiiiijiiiiii = U.og)(a, b, c, d, e, f, h, k, l, m, n, q, r), yh = g.dynCall_viiijiiiiii = (a, b, c, d, e, f, h, k, l, m, n) => (yh = g.dynCall_viiijiiiiii = U.pg)(a, b, c, d, e, f, h, k, l, m, n), zh = g.dynCall_viijj = (a, b, c, d, e) => (zh = g.dynCall_viijj = U.qg)(a, b, c, d, e), Ah = g.dynCall_viiiijii = (a, b, c, d, e, f, h, k) => (Ah = g.dynCall_viiiijii = U.rg)(a, b, c, d, e, f, h, k), Bh = g.dynCall_viijjiii = (a, b, c, d, e, f, h, k) => (Bh = g.dynCall_viijjiii = U.sg)(a, b, c, d, e, f, h, k), Ch = g.dynCall_ijii = (a, b, c, d) => (Ch = g.dynCall_ijii = U.tg)(a, b, c, d), Dh = g.dynCall_viiiiijjji = (a, b, c, d, e, f, h, k, l, m) => (Dh = g.dynCall_viiiiijjji = U.ug)(a, b, c, d, e, f, h, k, l, m), Eh = g.dynCall_vijjjjiij = (a, b, c, d, e, f, h, k, l) => (Eh = g.dynCall_vijjjjiij = U.vg)(a, b, c, d, e, f, h, k, l), Fh = g.dynCall_viiiiijij = (a, b, c, d, e, f, h, k, l) => (Fh = g.dynCall_viiiiijij = U.wg)(a, b, c, d, e, f, h, k, l), Gh = g.dynCall_viiiiiijij = (a, b, c, d, e, f, h, k, l, m) => (Gh = g.dynCall_viiiiiijij = U.xg)(a, b, c, d, e, f, h, k, l, m), Hh = g.dynCall_vijiii = (a, b, c, d, e, f) => (Hh = g.dynCall_vijiii = U.yg)(a, b, c, d, e, f), Ih = g.dynCall_viiiiiiiiifi = (a, b, c, d, e, f, h, k, l, m, n, q) => (Ih = g.dynCall_viiiiiiiiifi = U.zg)(a, b, c, d, e, f, h, k, l, m, n, q), Jh = g.dynCall_iiijiiii = (a, b, c, d, e, f, h, k) => (Jh = g.dynCall_iiijiiii = U.Ag)(a, b, c, d, e, f, h, k), Kh = g.dynCall_viiiiiijjiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (Kh = g.dynCall_viiiiiijjiiiii = U.Bg)(\n a,\n b,\n c,\n d,\n e,\n f,\n h,\n k,\n l,\n m,\n n,\n q,\n r,\n p\n ), Lh = g.dynCall_viiiiiiijiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => (Lh = g.dynCall_viiiiiiijiiiiii = U.Cg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u), Mh = g.dynCall_vif = (a, b, c) => (Mh = g.dynCall_vif = U.Dg)(a, b, c), Nh = g.dynCall_viif = (a, b, c, d) => (Nh = g.dynCall_viif = U.Eg)(a, b, c, d), Oh = g.dynCall_fiii = (a, b, c, d) => (Oh = g.dynCall_fiii = U.Fg)(a, b, c, d), Ph = g.dynCall_diii = (a, b, c, d) => (Ph = g.dynCall_diii = U.Gg)(a, b, c, d), Qh = g.dynCall_viiiiiifii = (a, b, c, d, e, f, h, k, l, m) => (Qh = g.dynCall_viiiiiifii = U.Hg)(a, b, c, d, e, f, h, k, l, m), Rh = g.dynCall_viiiiijiiiiiiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F, H, K, Va, Wa, Xa) => (Rh = g.dynCall_viiiiijiiiiiiiiiiiiiiiiiii = U.Ig)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F, H, K, Va, Wa, Xa), Sh = g.dynCall_viijji = (a, b, c, d, e, f) => (Sh = g.dynCall_viijji = U.Jg)(a, b, c, d, e, f), Th = g.dynCall_iiiiiiiiiiiji = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Th = g.dynCall_iiiiiiiiiiiji = U.Kg)(a, b, c, d, e, f, h, k, l, m, n, q, r), Uh = g.dynCall_viifiifijjjii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Uh = g.dynCall_viifiifijjjii = U.Lg)(a, b, c, d, e, f, h, k, l, m, n, q, r), Vh = g.dynCall_viiiiiiiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) => (Vh = g.dynCall_viiiiiiiiiiiiiiiiiiii = U.Mg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F), Wh = g.dynCall_viiiiifiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Wh = g.dynCall_viiiiifiiiiii = U.Ng)(a, b, c, d, e, f, h, k, l, m, n, q, r), Xh = g.dynCall_vijiiiiiiijjii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (Xh = g.dynCall_vijiiiiiiijjii = U.Og)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), Yh = g.dynCall_viiiiiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C) => (Yh = g.dynCall_viiiiiiiiiiiiiiiiii = U.Pg)(\n a,\n b,\n c,\n d,\n e,\n f,\n h,\n k,\n l,\n m,\n n,\n q,\n r,\n p,\n u,\n y,\n A,\n B,\n C\n ), Zh = g.dynCall_viiiiiiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) => (Zh = g.dynCall_viiiiiiiiiiiiiiiiiii = U.Qg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D), $h = g.dynCall_viiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => ($h = g.dynCall_viiiiiiiiiiiiiii = U.Rg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y), ai = g.dynCall_viiiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) => (ai = g.dynCall_viiiiiiiiiiiiiiii = U.Sg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A), bi = g.dynCall_viiiijjj = (a, b, c, d, e, f, h, k) => (bi = g.dynCall_viiiijjj = U.Tg)(a, b, c, d, e, f, h, k), ci = g.dynCall_iiiiid = (a, b, c, d, e, f) => (ci = g.dynCall_iiiiid = U.Ug)(a, b, c, d, e, f), di = g.dynCall_viiiiiiijjj = (a, b, c, d, e, f, h, k, l, m, n) => (di = g.dynCall_viiiiiiijjj = U.Vg)(a, b, c, d, e, f, h, k, l, m, n), ei = g.dynCall_iiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n) => (ei = g.dynCall_iiiiiiiiiii = U.Wg)(a, b, c, d, e, f, h, k, l, m, n), fi = g.dynCall_iiiiiiiiiiiiiiiiiifi = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) => (fi = g.dynCall_iiiiiiiiiiiiiiiiiifi = U.Xg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D), gi = g.dynCall_viiif = (a, b, c, d, e) => (gi = g.dynCall_viiif = U.Yg)(a, b, c, d, e), hi = g.dynCall_viiijiiiii = (a, b, c, d, e, f, h, k, l, m) => (hi = g.dynCall_viiijiiiii = U.Zg)(a, b, c, d, e, f, h, k, l, m), ii = g.dynCall_viiij = (a, b, c, d, e) => (ii = g.dynCall_viiij = U._g)(a, b, c, d, e), ji = g.dynCall_iijjj = (a, b, c, d, e) => (ji = g.dynCall_iijjj = U.$g)(a, b, c, d, e), ki = g.dynCall_viiiiji = (a, b, c, d, e, f, h) => (ki = g.dynCall_viiiiji = U.ah)(a, b, c, d, e, f, h), li = g.dynCall_iijjji = (a, b, c, d, e, f) => (li = g.dynCall_iijjji = U.bh)(a, b, c, d, e, f), mi = g.dynCall_ijijji = (a, b, c, d, e, f) => (mi = g.dynCall_ijijji = U.ch)(\n a,\n b,\n c,\n d,\n e,\n f\n ), ni = g.dynCall_viiijjiii = (a, b, c, d, e, f, h, k, l) => (ni = g.dynCall_viiijjiii = U.dh)(a, b, c, d, e, f, h, k, l), oi = g.dynCall_iiiiijji = (a, b, c, d, e, f, h, k) => (oi = g.dynCall_iiiiijji = U.eh)(a, b, c, d, e, f, h, k), pi = g.dynCall_iiiifi = (a, b, c, d, e, f) => (pi = g.dynCall_iiiifi = U.fh)(a, b, c, d, e, f), qi = g.dynCall_iiijii = (a, b, c, d, e, f) => (qi = g.dynCall_iiijii = U.gh)(a, b, c, d, e, f), ri = g.dynCall_iiiiiiiiijii = (a, b, c, d, e, f, h, k, l, m, n, q) => (ri = g.dynCall_iiiiiiiiijii = U.hh)(a, b, c, d, e, f, h, k, l, m, n, q), si = g.dynCall_iiiijjii = (a, b, c, d, e, f, h, k) => (si = g.dynCall_iiiijjii = U.ih)(a, b, c, d, e, f, h, k), ti = g.dynCall_iiiiiijjjii = (a, b, c, d, e, f, h, k, l, m, n) => (ti = g.dynCall_iiiiiijjjii = U.jh)(a, b, c, d, e, f, h, k, l, m, n), ui = g.dynCall_iiijiii = (a, b, c, d, e, f, h) => (ui = g.dynCall_iiijiii = U.kh)(a, b, c, d, e, f, h), vi = g.dynCall_iiiiiiiijjjfi = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (vi = g.dynCall_iiiiiiiijjjfi = U.lh)(a, b, c, d, e, f, h, k, l, m, n, q, r), wi = g.dynCall_iijiiii = (a, b, c, d, e, f, h) => (wi = g.dynCall_iijiiii = U.mh)(a, b, c, d, e, f, h), xi = g.dynCall_iijjjii = (a, b, c, d, e, f, h) => (xi = g.dynCall_iijjjii = U.nh)(a, b, c, d, e, f, h), yi = g.dynCall_jij = (a, b, c) => (yi = g.dynCall_jij = U.oh)(a, b, c), zi = g.dynCall_iiji = (a, b, c, d) => (zi = g.dynCall_iiji = U.ph)(a, b, c, d), Ai = g.dynCall_iiif = (a, b, c, d) => (Ai = g.dynCall_iiif = U.qh)(a, b, c, d), Bi = g.dynCall_vidi = (a, b, c, d) => (Bi = g.dynCall_vidi = U.rh)(a, b, c, d), Ci = g.dynCall_vjiii = (a, b, c, d, e) => (Ci = g.dynCall_vjiii = U.sh)(a, b, c, d, e), Di = g.dynCall_diiii = (a, b, c, d, e) => (Di = g.dynCall_diiii = U.th)(a, b, c, d, e), Ei = g.dynCall_diiiii = (a, b, c, d, e, f) => (Ei = g.dynCall_diiiii = U.uh)(a, b, c, d, e, f), Fi = g.dynCall_viiijjiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q) => (Fi = g.dynCall_viiijjiiiiii = U.vh)(a, b, c, d, e, f, h, k, l, m, n, q), Gi = g.dynCall_viijjijjjjiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Gi = g.dynCall_viijjijjjjiii = U.wh)(a, b, c, d, e, f, h, k, l, m, n, q, r), Hi = g.dynCall_iiiij = (a, b, c, d, e) => (Hi = g.dynCall_iiiij = U.xh)(a, b, c, d, e), Ii = g.dynCall_viiijii = (a, b, c, d, e, f, h) => (Ii = g.dynCall_viiijii = U.yh)(a, b, c, d, e, f, h), Ji = g.dynCall_viijiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Ji = g.dynCall_viijiiiiiiiii = U.zh)(a, b, c, d, e, f, h, k, l, m, n, q, r), Ki = g.dynCall_fiiii = (a, b, c, d, e) => (Ki = g.dynCall_fiiii = U.Ah)(a, b, c, d, e), Li = g.dynCall_jfi = (a, b, c) => (Li = g.dynCall_jfi = U.Bh)(a, b, c), Mi = g.dynCall_viiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => (Mi = g.dynCall_viiiiiiiiiiiiii = U.Ch)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u), Ni = g.dynCall_jiij = (a, b, c, d) => (Ni = g.dynCall_jiij = U.Dh)(a, b, c, d), Mb = (a) => (Mb = U.Eh)(a), Bb = () => (Bb = U.Fh)(), Lb = (a) => (Lb = U.Gh)(a), Nb = () => (Nb = U.Hh)();\n g.___start_em_js = 1275044;\n g.___stop_em_js = 1275205;\n function Dc(a, b, c, d) {\n var e = Z();\n try {\n return Ff(a, b, c, d);\n } catch (f) {\n Y(e);\n if (f !== f + 0)\n throw f;\n X(1, 0);\n }\n }\n function Bc(a, b, c) {\n var d = Z();\n try {\n return dynCall_iii(a, b, c);\n } catch (e) {\n Y(d);\n if (e !== e + 0)\n throw e;\n X(1, 0);\n }\n }\n function Jd(a, b, c) {\n var d = Z();\n try {\n dynCall_vii(a, b, c);\n } catch (e) {\n Y(d);\n if (e !== e + 0)\n throw e;\n X(1, 0);\n }\n }\n function yc(a, b) {\n var c = Z();\n try {\n return Gf(a, b);\n } catch (d) {\n Y(c);\n if (d !== d + 0)\n throw d;\n X(1, 0);\n }\n }\n function Fd(a, b) {\n var c = Z();\n try {\n dynCall_vi(a, b);\n } catch (d) {\n Y(c);\n if (d !== d + 0)\n throw d;\n X(1, 0);\n }\n }\n function dd(a, b, c, d) {\n var e = Z();\n try {\n return Jf(a, b, c, d);\n } catch (f) {\n Y(e);\n if (f !== f + 0)\n throw f;\n X(1, 0);\n }\n }\n function Dd(a) {\n var b = Z();\n try {\n dynCall_v(a);\n } catch (c) {\n Y(b);\n if (c !== c + 0)\n throw c;\n X(1, 0);\n }\n }\n function Ic(a, b, c, d, e, f, h) {\n var k = Z();\n try {\n return Hf(a, b, c, d, e, f, h);\n } catch (l) {\n Y(k);\n if (l !== l + 0)\n throw l;\n X(1, 0);\n }\n }\n function Hc(a, b, c, d, e, f) {\n var h = Z();\n try {\n return If(a, b, c, d, e, f);\n } catch (k) {\n Y(h);\n if (k !== k + 0)\n throw k;\n X(1, 0);\n }\n }\n function Fc(a, b, c, d, e) {\n var f = Z();\n try {\n return Kf(a, b, c, d, e);\n } catch (h) {\n Y(f);\n if (h !== h + 0)\n throw h;\n X(1, 0);\n }\n }\n function Qd(a, b, c, d) {\n var e = Z();\n try {\n Lf(a, b, c, d);\n } catch (f) {\n Y(e);\n if (f !== f + 0)\n throw f;\n X(1, 0);\n }\n }\n function Td(a, b, c, d, e) {\n var f = Z();\n try {\n Nf(a, b, c, d, e);\n } catch (h) {\n Y(f);\n if (h !== h + 0)\n throw h;\n X(1, 0);\n }\n }\n function Vd(a, b, c, d, e, f) {\n var h = Z();\n try {\n Mf(a, b, c, d, e, f);\n } catch (k) {\n Y(h);\n if (k !== k + 0)\n throw k;\n X(1, 0);\n }\n }\n function Zd(a, b, c, d, e, f, h) {\n var k = Z();\n try {\n Of(a, b, c, d, e, f, h);\n } catch (l) {\n Y(k);\n if (l !== l + 0)\n throw l;\n X(1, 0);\n }\n }\n function ke(a, b, c, d, e, f, h, k, l, m, n, q) {\n var r = Z();\n try {\n Qf(a, b, c, d, e, f, h, k, l, m, n, q);\n } catch (p) {\n Y(r);\n if (p !== p + 0)\n throw p;\n X(1, 0);\n }\n }\n function zc(a, b, c) {\n var d = Z();\n try {\n return Sf(a, b, c);\n } catch (e) {\n Y(d);\n if (e !== e + 0)\n throw e;\n X(1, 0);\n }\n }\n function Ac(a, b, c) {\n var d = Z();\n try {\n return Tf(a, b, c);\n } catch (e) {\n Y(d);\n if (e !== e + 0)\n throw e;\n X(1, 0);\n }\n }\n function md(a, b, c) {\n var d = Z();\n try {\n return Uf(a, b, c);\n } catch (e) {\n Y(d);\n if (e !== e + 0)\n throw e;\n X(1, 0);\n }\n }\n function yd(a, b, c) {\n var d = Z();\n try {\n return Vf(a, b, c);\n } catch (e) {\n Y(d);\n if (e !== e + 0)\n throw e;\n X(1, 0);\n return 0n;\n }\n }\n function ee(a, b, c, d, e, f, h, k, l) {\n var m = Z();\n try {\n Xf(a, b, c, d, e, f, h, k, l);\n } catch (n) {\n Y(m);\n if (n !== n + 0)\n throw n;\n X(1, 0);\n }\n }\n function xc(a) {\n var b = Z();\n try {\n return Wf(a);\n } catch (c) {\n Y(b);\n if (c !== c + 0)\n throw c;\n X(1, 0);\n }\n }\n function df(a, b, c) {\n var d = Z();\n try {\n fg(a, b, c);\n } catch (e) {\n Y(d);\n if (e !== e + 0)\n throw e;\n X(1, 0);\n }\n }\n function We(a, b, c, d, e) {\n var f = Z();\n try {\n Pf(a, b, c, d, e);\n } catch (h) {\n Y(f);\n if (h !== h + 0)\n throw h;\n X(1, 0);\n }\n }\n function Ce(a, b, c, d, e, f, h) {\n var k = Z();\n try {\n Yf(a, b, c, d, e, f, h);\n } catch (l) {\n Y(k);\n if (l !== l + 0)\n throw l;\n X(1, 0);\n }\n }\n function cf(a, b, c, d, e, f, h, k, l, m, n, q) {\n var r = Z();\n try {\n gg(a, b, c, d, e, f, h, k, l, m, n, q);\n } catch (p) {\n Y(r);\n if (p !== p + 0)\n throw p;\n X(1, 0);\n }\n }\n function Re(a, b, c, d, e, f, h, k, l, m, n, q) {\n var r = Z();\n try {\n hg(a, b, c, d, e, f, h, k, l, m, n, q);\n } catch (p) {\n Y(r);\n if (p !== p + 0)\n throw p;\n X(1, 0);\n }\n }\n function Jc(a, b, c, d, e, f, h, k) {\n var l = Z();\n try {\n return ig(a, b, c, d, e, f, h, k);\n } catch (m) {\n Y(l);\n if (m !== m + 0)\n throw m;\n X(1, 0);\n }\n }\n function de(a, b, c, d, e, f, h, k) {\n var l = Z();\n try {\n jg(a, b, c, d, e, f, h, k);\n } catch (m) {\n Y(l);\n if (m !== m + 0)\n throw m;\n X(1, 0);\n }\n }\n function Nc(a, b, c, d, e, f, h, k, l, m, n, q) {\n var r = Z();\n try {\n return ag(a, b, c, d, e, f, h, k, l, m, n, q);\n } catch (p) {\n Y(r);\n if (p !== p + 0)\n throw p;\n X(1, 0);\n }\n }\n function fe(a, b, c, d, e, f, h, k, l, m) {\n var n = Z();\n try {\n bg(a, b, c, d, e, f, h, k, l, m);\n } catch (q) {\n Y(n);\n if (q !== q + 0)\n throw q;\n X(1, 0);\n }\n }\n function me(a, b, c, d, e, f, h, k, l, m, n, q, r, p) {\n var u = Z();\n try {\n lg(a, b, c, d, e, f, h, k, l, m, n, q, r, p);\n } catch (y) {\n Y(u);\n if (y !== y + 0)\n throw y;\n X(1, 0);\n }\n }\n function Yc(a, b, c, d, e, f, h, k, l, m, n) {\n var q = Z();\n try {\n return ng(a, b, c, d, e, f, h, k, l, m, n);\n } catch (r) {\n Y(q);\n if (r !== r + 0)\n throw r;\n X(1, 0);\n }\n }\n function Kc(a, b, c, d, e, f, h, k, l) {\n var m = Z();\n try {\n return mg(a, b, c, d, e, f, h, k, l);\n } catch (n) {\n Y(m);\n if (n !== n + 0)\n throw n;\n X(1, 0);\n }\n }\n function nf(a, b, c, d, e, f, h, k, l) {\n var m = Z();\n try {\n og(a, b, c, d, e, f, h, k, l);\n } catch (n) {\n Y(m);\n if (n !== n + 0)\n throw n;\n X(1, 0);\n }\n }\n function Ve(a, b, c, d) {\n var e = Z();\n try {\n $f(a, b, c, d);\n } catch (f) {\n Y(e);\n if (f !== f + 0)\n throw f;\n X(1, 0);\n }\n }\n function tc(a, b) {\n var c = Z();\n try {\n return pg(a, b);\n } catch (d) {\n Y(c);\n if (d !== d + 0)\n throw d;\n X(1, 0);\n }\n }\n function xd(a, b) {\n var c = Z();\n try {\n return Zf(a, b);\n } catch (d) {\n Y(c);\n if (d !== d + 0)\n throw d;\n X(1, 0);\n return 0n;\n }\n }\n function nc(a, b) {\n var c = Z();\n try {\n return rg(a, b);\n } catch (d) {\n Y(c);\n if (d !== d + 0)\n throw d;\n X(1, 0);\n }\n }\n function jf(a, b, c, d) {\n var e = Z();\n try {\n tg(a, b, c, d);\n } catch (f) {\n Y(e);\n if (f !== f + 0)\n throw f;\n X(1, 0);\n }\n }\n function Oe(a, b, c, d, e, f, h) {\n var k = Z();\n try {\n Ii(a, b, c, d, e, f, h);\n } catch (l) {\n Y(k);\n if (l !== l + 0)\n throw l;\n X(1, 0);\n }\n }\n function Ze(a, b, c, d, e) {\n var f = Z();\n try {\n zh(a, b, c, d, e);\n } catch (h) {\n Y(f);\n if (h !== h + 0)\n throw h;\n X(1, 0);\n }\n }\n function Lc(a, b, c, d, e, f, h, k, l, m) {\n var n = Z();\n try {\n return ug(a, b, c, d, e, f, h, k, l, m);\n } catch (q) {\n Y(n);\n if (q !== q + 0)\n throw q;\n X(1, 0);\n }\n }\n function Xe(a, b, c, d, e, f, h) {\n var k = Z();\n try {\n vg(a, b, c, d, e, f, h);\n } catch (l) {\n Y(k);\n if (l !== l + 0)\n throw l;\n X(1, 0);\n }\n }\n function Kd(a, b, c, d) {\n var e = Z();\n try {\n wg(a, b, c, d);\n } catch (f) {\n Y(e);\n if (f !== f + 0)\n throw f;\n X(1, 0);\n }\n }\n function Tc(a, b, c, d, e, f, h, k, l) {\n var m = Z();\n try {\n return kg(a, b, c, d, e, f, h, k, l);\n } catch (n) {\n Y(m);\n if (n !== n + 0)\n throw n;\n X(1, 0);\n }\n }\n function Id(a, b, c, d, e, f, h) {\n var k = Z();\n try {\n xg(a, b, c, d, e, f, h);\n } catch (l) {\n Y(k);\n if (l !== l + 0)\n throw l;\n X(1, 0);\n }\n }\n function Ue(a, b, c, d, e, f, h, k, l) {\n var m = Z();\n try {\n Rf(a, b, c, d, e, f, h, k, l);\n } catch (n) {\n Y(m);\n if (n !== n + 0)\n throw n;\n X(1, 0);\n }\n }\n function Pd(a, b, c, d, e, f, h) {\n var k = Z();\n try {\n yg(a, b, c, d, e, f, h);\n } catch (l) {\n Y(k);\n if (l !== l + 0)\n throw l;\n X(1, 0);\n }\n }\n function Wd(a, b, c, d, e, f, h, k, l, m, n) {\n var q = Z();\n try {\n zg(a, b, c, d, e, f, h, k, l, m, n);\n } catch (r) {\n Y(q);\n if (r !== r + 0)\n throw r;\n X(1, 0);\n }\n }\n function zd(a, b, c, d) {\n var e = Z();\n try {\n return Bg(a, b, c, d);\n } catch (f) {\n Y(e);\n if (f !== f + 0)\n throw f;\n X(1, 0);\n return 0n;\n }\n }\n function uf(a, b, c, d, e, f, h, k) {\n var l = Z();\n try {\n Cg(a, b, c, d, e, f, h, k);\n } catch (m) {\n Y(l);\n if (m !== m + 0)\n throw m;\n X(1, 0);\n }\n }\n function Rd(a, b, c, d, e) {\n var f = Z();\n try {\n Dg(a, b, c, d, e);\n } catch (h) {\n Y(f);\n if (h !== h + 0)\n throw h;\n X(1, 0);\n }\n }\n function ef(a, b, c, d) {\n var e = Z();\n try {\n Fg(a, b, c, d);\n } catch (f) {\n Y(e);\n if (f !== f + 0)\n throw f;\n X(1, 0);\n }\n }\n function rf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) {\n var A = Z();\n try {\n Gg(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y);\n } catch (B) {\n Y(A);\n if (B !== B + 0)\n throw B;\n X(1, 0);\n }\n }\n function Ne(a, b, c, d, e, f) {\n var h = Z();\n try {\n Hg(a, b, c, d, e, f);\n } catch (k) {\n Y(h);\n if (k !== k + 0)\n throw k;\n X(1, 0);\n }\n }\n function of(a, b, c, d, e, f, h, k, l) {\n var m = Z();\n try {\n Ig(a, b, c, d, e, f, h, k, l);\n } catch (n) {\n Y(m);\n if (n !== n + 0)\n throw n;\n X(1, 0);\n }\n }\n function ed(a, b, c, d, e) {\n var f = Z();\n try {\n return Jg(a, b, c, d, e);\n } catch (h) {\n Y(f);\n if (h !== h + 0)\n throw h;\n X(1, 0);\n }\n }\n function kd(a, b, c, d, e, f, h, k, l, m, n, q, r, p) {\n var u = Z();\n try {\n return Kg(a, b, c, d, e, f, h, k, l, m, n, q, r, p);\n } catch (y) {\n Y(u);\n if (y !== y + 0)\n throw y;\n X(1, 0);\n }\n }\n function sf(a, b) {\n var c = Z();\n try {\n Lg(a, b);\n } catch (d) {\n Y(c);\n if (d !== d + 0)\n throw d;\n X(1, 0);\n }\n }\n function Cd(a, b, c) {\n var d = Z();\n try {\n return Mg(a, b, c);\n } catch (e) {\n Y(d);\n if (e !== e + 0)\n throw e;\n X(1, 0);\n return 0n;\n }\n }\n function jd(a, b, c, d, e, f, h, k, l, m) {\n var n = Z();\n try {\n return Ng(a, b, c, d, e, f, h, k, l, m);\n } catch (q) {\n Y(n);\n if (q !== q + 0)\n throw q;\n X(1, 0);\n }\n }\n function ie(a, b, c, d, e, f, h, k, l, m, n, q, r, p) {\n var u = Z();\n try {\n Sg(a, b, c, d, e, f, h, k, l, m, n, q, r, p);\n } catch (y) {\n Y(u);\n if (y !== y + 0)\n throw y;\n X(1, 0);\n }\n }\n function Ed(a, b, c, d, e) {\n var f = Z();\n try {\n Og(a, b, c, d, e);\n } catch (h) {\n Y(f);\n if (h !== h + 0)\n throw h;\n X(1, 0);\n }\n }\n function Ud(a, b, c, d, e, f, h) {\n var k = Z();\n try {\n Pg(a, b, c, d, e, f, h);\n } catch (l) {\n Y(k);\n if (l !== l + 0)\n throw l;\n X(1, 0);\n }\n }\n function Md(a, b, c, d, e) {\n var f = Z();\n try {\n Rg(a, b, c, d, e);\n } catch (h) {\n Y(f);\n if (h !== h + 0)\n throw h;\n X(1, 0);\n }\n }\n function Xd(a, b, c, d, e, f, h, k) {\n var l = Z();\n try {\n Qg(a, b, c, d, e, f, h, k);\n } catch (m) {\n Y(l);\n if (m !== m + 0)\n throw m;\n X(1, 0);\n }\n }\n function ue(a, b, c, d, e, f, h, k, l, m, n) {\n var q = Z();\n try {\n Tg(a, b, c, d, e, f, h, k, l, m, n);\n } catch (r) {\n Y(q);\n if (r !== r + 0)\n throw r;\n X(1, 0);\n }\n }\n function Oc(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) {\n var B = Z();\n try {\n return Ug(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A);\n } catch (C) {\n Y(B);\n if (C !== C + 0)\n throw C;\n X(1, 0);\n }\n }\n function le(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n var p = Z();\n try {\n Vg(a, b, c, d, e, f, h, k, l, m, n, q, r);\n } catch (u) {\n Y(p);\n if (u !== u + 0)\n throw u;\n X(1, 0);\n }\n }\n function sd(a, b) {\n var c = Z();\n try {\n return cg(a, b);\n } catch (d) {\n Y(c);\n if (d !== d + 0)\n throw d;\n X(1, 0);\n }\n }\n function wc(a, b, c, d, e) {\n var f = Z();\n try {\n return Ki(a, b, c, d, e);\n } catch (h) {\n Y(f);\n if (h !== h + 0)\n throw h;\n X(1, 0);\n }\n }\n function Pc(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) {\n var F = Z();\n try {\n return Wg(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D);\n } catch (H) {\n Y(F);\n if (H !== H + 0)\n throw H;\n X(1, 0);\n }\n }\n function mf(a, b, c, d, e, f, h, k, l, m) {\n var n = Z();\n try {\n Xg(a, b, c, d, e, f, h, k, l, m);\n } catch (q) {\n Y(n);\n if (q !== q + 0)\n throw q;\n X(1, 0);\n }\n }\n function cd(a, b, c, d, e, f, h) {\n var k = Z();\n try {\n return Yg(a, b, c, d, e, f, h);\n } catch (l) {\n Y(k);\n if (l !== l + 0)\n throw l;\n X(1, 0);\n }\n }\n function je(a, b, c, d, e, f, h, k, l, m, n) {\n var q = Z();\n try {\n Zg(a, b, c, d, e, f, h, k, l, m, n);\n } catch (r) {\n Y(q);\n if (r !== r + 0)\n throw r;\n X(1, 0);\n }\n }\n function ld(a, b, c, d, e, f) {\n var h = Z();\n try {\n return $g(a, b, c, d, e, f);\n } catch (k) {\n Y(h);\n if (k !== k + 0)\n throw k;\n X(1, 0);\n }\n }\n function Ie(a, b, c, d, e, f) {\n var h = Z();\n try {\n bh(a, b, c, d, e, f);\n } catch (k) {\n Y(h);\n if (k !== k + 0)\n throw k;\n X(1, 0);\n }\n }\n function ye(a, b, c, d, e, f, h, k, l, m, n, q, r, p) {\n var u = Z();\n try {\n ch(a, b, c, d, e, f, h, k, l, m, n, q, r, p);\n } catch (y) {\n Y(u);\n if (y !== y + 0)\n throw y;\n X(1, 0);\n }\n }\n function zf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B) {\n var C = Z();\n try {\n dh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B);\n } catch (D) {\n Y(C);\n if (D !== D + 0)\n throw D;\n X(1, 0);\n }\n }\n function ae(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) {\n var B = Z();\n try {\n eh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A);\n } catch (C) {\n Y(B);\n if (C !== C + 0)\n throw C;\n X(1, 0);\n }\n }\n function $d(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) {\n var A = Z();\n try {\n fh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y);\n } catch (B) {\n Y(A);\n if (B !== B + 0)\n throw B;\n X(1, 0);\n }\n }\n function be(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) {\n var y = Z();\n try {\n gh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u);\n } catch (A) {\n Y(y);\n if (A !== A + 0)\n throw A;\n X(1, 0);\n }\n }\n function Af(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) {\n var H = Z();\n try {\n hh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F);\n } catch (K) {\n Y(H);\n if (K !== K + 0)\n throw K;\n X(1, 0);\n }\n }\n function yf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C) {\n var D = Z();\n try {\n ih(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C);\n } catch (F) {\n Y(D);\n if (F !== F + 0)\n throw F;\n X(1, 0);\n }\n }\n function xf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B) {\n var C = Z();\n try {\n jh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B);\n } catch (D) {\n Y(C);\n if (D !== D + 0)\n throw D;\n X(1, 0);\n }\n }\n function Bf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) {\n var H = Z();\n try {\n kh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F);\n } catch (K) {\n Y(H);\n if (K !== K + 0)\n throw K;\n X(1, 0);\n }\n }\n function gf(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n var p = Z();\n try {\n lh(a, b, c, d, e, f, h, k, l, m, n, q, r);\n } catch (u) {\n Y(p);\n if (u !== u + 0)\n throw u;\n X(1, 0);\n }\n }\n function kf(a, b, c, d, e, f, h, k, l, m) {\n var n = Z();\n try {\n mh(a, b, c, d, e, f, h, k, l, m);\n } catch (q) {\n Y(n);\n if (q !== q + 0)\n throw q;\n X(1, 0);\n }\n }\n function ve(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n var p = Z();\n try {\n nh(a, b, c, d, e, f, h, k, l, m, n, q, r);\n } catch (u) {\n Y(p);\n if (u !== u + 0)\n throw u;\n X(1, 0);\n }\n }\n function qf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) {\n var y = Z();\n try {\n oh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u);\n } catch (A) {\n Y(y);\n if (A !== A + 0)\n throw A;\n X(1, 0);\n }\n }\n function wf(a, b, c, d, e, f, h, k, l, m) {\n var n = Z();\n try {\n qh(a, b, c, d, e, f, h, k, l, m);\n } catch (q) {\n Y(n);\n if (q !== q + 0)\n throw q;\n X(1, 0);\n }\n }\n function vf(a, b, c, d, e, f, h, k, l) {\n var m = Z();\n try {\n rh(a, b, c, d, e, f, h, k, l);\n } catch (n) {\n Y(m);\n if (n !== n + 0)\n throw n;\n X(1, 0);\n }\n }\n function sc(a, b, c, d, e, f, h) {\n var k = Z();\n try {\n return ah(a, b, c, d, e, f, h);\n } catch (l) {\n Y(k);\n if (l !== l + 0)\n throw l;\n X(1, 0);\n }\n }\n function Nd(a, b, c, d, e) {\n var f = Z();\n try {\n ph(a, b, c, d, e);\n } catch (h) {\n Y(f);\n if (h !== h + 0)\n throw h;\n X(1, 0);\n }\n }\n function wd(a, b, c) {\n var d = Z();\n try {\n return Li(a, b, c);\n } catch (e) {\n Y(d);\n if (e !== e + 0)\n throw e;\n X(1, 0);\n return 0n;\n }\n }\n function ze(a, b, c, d, e, f, h, k, l, m, n, q, r, p) {\n var u = Z();\n try {\n sh(a, b, c, d, e, f, h, k, l, m, n, q, r, p);\n } catch (y) {\n Y(u);\n if (y !== y + 0)\n throw y;\n X(1, 0);\n }\n }\n function Ge(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n var p = Z();\n try {\n uh(a, b, c, d, e, f, h, k, l, m, n, q, r);\n } catch (u) {\n Y(p);\n if (u !== u + 0)\n throw u;\n X(1, 0);\n }\n }\n function Xc(a, b, c, d, e, f, h) {\n var k = Z();\n try {\n return vh(a, b, c, d, e, f, h);\n } catch (l) {\n Y(k);\n if (l !== l + 0)\n throw l;\n X(1, 0);\n }\n }\n function ad(a, b, c, d, e, f) {\n var h = Z();\n try {\n return wh(a, b, c, d, e, f);\n } catch (k) {\n Y(h);\n if (k !== k + 0)\n throw k;\n X(1, 0);\n }\n }\n function De(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n var p = Z();\n try {\n xh(a, b, c, d, e, f, h, k, l, m, n, q, r);\n } catch (u) {\n Y(p);\n if (u !== u + 0)\n throw u;\n X(1, 0);\n }\n }\n function lf(a, b, c, d, e, f) {\n var h = Z();\n try {\n th(a, b, c, d, e, f);\n } catch (k) {\n Y(h);\n if (k !== k + 0)\n throw k;\n X(1, 0);\n }\n }\n function Qe(a, b, c, d, e, f, h, k, l, m, n) {\n var q = Z();\n try {\n yh(a, b, c, d, e, f, h, k, l, m, n);\n } catch (r) {\n Y(q);\n if (r !== r + 0)\n throw r;\n X(1, 0);\n }\n }\n function Ke(a, b, c, d, e, f, h, k) {\n var l = Z();\n try {\n Ah(a, b, c, d, e, f, h, k);\n } catch (m) {\n Y(l);\n if (m !== m + 0)\n throw m;\n X(1, 0);\n }\n }\n function af(a, b, c, d, e, f, h, k) {\n var l = Z();\n try {\n Bh(a, b, c, d, e, f, h, k);\n } catch (m) {\n Y(l);\n if (m !== m + 0)\n throw m;\n X(1, 0);\n }\n }\n function td(a, b, c, d) {\n var e = Z();\n try {\n return Ch(a, b, c, d);\n } catch (f) {\n Y(e);\n if (f !== f + 0)\n throw f;\n X(1, 0);\n }\n }\n function He(a, b, c, d, e, f, h, k, l, m) {\n var n = Z();\n try {\n Dh(a, b, c, d, e, f, h, k, l, m);\n } catch (q) {\n Y(n);\n if (q !== q + 0)\n throw q;\n X(1, 0);\n }\n }\n function pf(a, b, c, d, e, f, h, k, l) {\n var m = Z();\n try {\n Eh(a, b, c, d, e, f, h, k, l);\n } catch (n) {\n Y(m);\n if (n !== n + 0)\n throw n;\n X(1, 0);\n }\n }\n function Fe(a, b, c, d, e, f, h, k, l) {\n var m = Z();\n try {\n Fh(a, b, c, d, e, f, h, k, l);\n } catch (n) {\n Y(m);\n if (n !== n + 0)\n throw n;\n X(1, 0);\n }\n }\n function Ae(a, b, c, d, e, f, h, k, l, m) {\n var n = Z();\n try {\n Gh(a, b, c, d, e, f, h, k, l, m);\n } catch (q) {\n Y(n);\n if (q !== q + 0)\n throw q;\n X(1, 0);\n }\n }\n function ff(a, b, c, d, e, f) {\n var h = Z();\n try {\n Hh(a, b, c, d, e, f);\n } catch (k) {\n Y(h);\n if (k !== k + 0)\n throw k;\n X(1, 0);\n }\n }\n function he(a, b, c, d, e, f, h, k, l, m, n, q) {\n var r = Z();\n try {\n Ih(a, b, c, d, e, f, h, k, l, m, n, q);\n } catch (p) {\n Y(r);\n if (p !== p + 0)\n throw p;\n X(1, 0);\n }\n }\n function hd(a, b, c, d, e, f, h, k) {\n var l = Z();\n try {\n return Jh(a, b, c, d, e, f, h, k);\n } catch (m) {\n Y(l);\n if (m !== m + 0)\n throw m;\n X(1, 0);\n }\n }\n function ne(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) {\n var y = Z();\n try {\n Mi(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u);\n } catch (A) {\n Y(y);\n if (A !== A + 0)\n throw A;\n X(1, 0);\n }\n }\n function Be(a, b, c, d, e, f, h, k, l, m, n, q, r, p) {\n var u = Z();\n try {\n Kh(a, b, c, d, e, f, h, k, l, m, n, q, r, p);\n } catch (y) {\n Y(u);\n if (y !== y + 0)\n throw y;\n X(1, 0);\n }\n }\n function we(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) {\n var y = Z();\n try {\n Lh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u);\n } catch (A) {\n Y(y);\n if (A !== A + 0)\n throw A;\n X(1, 0);\n }\n }\n function Hd(a, b, c) {\n var d = Z();\n try {\n Mh(a, b, c);\n } catch (e) {\n Y(d);\n if (e !== e + 0)\n throw e;\n X(1, 0);\n }\n }\n function vc(a, b, c, d) {\n var e = Z();\n try {\n return Oh(a, b, c, d);\n } catch (f) {\n Y(e);\n if (f !== f + 0)\n throw f;\n X(1, 0);\n }\n }\n function pc(a, b, c, d) {\n var e = Z();\n try {\n return Ph(a, b, c, d);\n } catch (f) {\n Y(e);\n if (f !== f + 0)\n throw f;\n X(1, 0);\n }\n }\n function ce(a, b, c, d, e, f, h, k, l, m) {\n var n = Z();\n try {\n Qh(a, b, c, d, e, f, h, k, l, m);\n } catch (q) {\n Y(n);\n if (q !== q + 0)\n throw q;\n X(1, 0);\n }\n }\n function Ee(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F, H, K, Va, Wa, Xa) {\n var Qi = Z();\n try {\n Rh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F, H, K, Va, Wa, Xa);\n } catch (Ya) {\n Y(Qi);\n if (Ya !== Ya + 0)\n throw Ya;\n X(1, 0);\n }\n }\n function $e(a, b, c, d, e, f) {\n var h = Z();\n try {\n Sh(a, b, c, d, e, f);\n } catch (k) {\n Y(h);\n if (k !== k + 0)\n throw k;\n X(1, 0);\n }\n }\n function Rc(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n var p = Z();\n try {\n return Th(a, b, c, d, e, f, h, k, l, m, n, q, r);\n } catch (u) {\n Y(p);\n if (u !== u + 0)\n throw u;\n X(1, 0);\n }\n }\n function Od(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n var p = Z();\n try {\n Uh(a, b, c, d, e, f, h, k, l, m, n, q, r);\n } catch (u) {\n Y(p);\n if (u !== u + 0)\n throw u;\n X(1, 0);\n }\n }\n function se(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) {\n var H = Z();\n try {\n Vh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F);\n } catch (K) {\n Y(H);\n if (K !== K + 0)\n throw K;\n X(1, 0);\n }\n }\n function Yd(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n var p = Z();\n try {\n Wh(a, b, c, d, e, f, h, k, l, m, n, q, r);\n } catch (u) {\n Y(p);\n if (u !== u + 0)\n throw u;\n X(1, 0);\n }\n }\n function hf(a, b, c, d, e, f, h, k, l, m, n, q, r, p) {\n var u = Z();\n try {\n Xh(a, b, c, d, e, f, h, k, l, m, n, q, r, p);\n } catch (y) {\n Y(u);\n if (y !== y + 0)\n throw y;\n X(1, 0);\n }\n }\n function re(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) {\n var F = Z();\n try {\n Zh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D);\n } catch (H) {\n Y(F);\n if (H !== H + 0)\n throw H;\n X(1, 0);\n }\n }\n function pe(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) {\n var B = Z();\n try {\n ai(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A);\n } catch (C) {\n Y(B);\n if (C !== C + 0)\n throw C;\n X(1, 0);\n }\n }\n function qe(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C) {\n var D = Z();\n try {\n Yh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C);\n } catch (F) {\n Y(D);\n if (F !== F + 0)\n throw F;\n X(1, 0);\n }\n }\n function Le(a, b, c, d, e, f, h, k) {\n var l = Z();\n try {\n bi(a, b, c, d, e, f, h, k);\n } catch (m) {\n Y(l);\n if (m !== m + 0)\n throw m;\n X(1, 0);\n }\n }\n function xe(a, b, c, d, e, f, h, k, l, m, n) {\n var q = Z();\n try {\n di(a, b, c, d, e, f, h, k, l, m, n);\n } catch (r) {\n Y(q);\n if (r !== r + 0)\n throw r;\n X(1, 0);\n }\n }\n function Mc(a, b, c, d, e, f, h, k, l, m, n) {\n var q = Z();\n try {\n return ei(a, b, c, d, e, f, h, k, l, m, n);\n } catch (r) {\n Y(q);\n if (r !== r + 0)\n throw r;\n X(1, 0);\n }\n }\n function Qc(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) {\n var F = Z();\n try {\n return fi(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D);\n } catch (H) {\n Y(F);\n if (H !== H + 0)\n throw H;\n X(1, 0);\n }\n }\n function Sd(a, b, c, d, e) {\n var f = Z();\n try {\n gi(a, b, c, d, e);\n } catch (h) {\n Y(f);\n if (h !== h + 0)\n throw h;\n X(1, 0);\n }\n }\n function ge(a, b, c, d, e, f, h, k, l, m, n, q) {\n var r = Z();\n try {\n Ag(a, b, c, d, e, f, h, k, l, m, n, q);\n } catch (p) {\n Y(r);\n if (p !== p + 0)\n throw p;\n X(1, 0);\n }\n }\n function Pe(a, b, c, d, e, f, h, k, l, m) {\n var n = Z();\n try {\n hi(a, b, c, d, e, f, h, k, l, m);\n } catch (q) {\n Y(n);\n if (q !== q + 0)\n throw q;\n X(1, 0);\n }\n }\n function Me(a, b, c, d, e) {\n var f = Z();\n try {\n ii(a, b, c, d, e);\n } catch (h) {\n Y(f);\n if (h !== h + 0)\n throw h;\n X(1, 0);\n }\n }\n function Ye(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n var p = Z();\n try {\n Ji(a, b, c, d, e, f, h, k, l, m, n, q, r);\n } catch (u) {\n Y(p);\n if (u !== u + 0)\n throw u;\n X(1, 0);\n }\n }\n function pd(a, b, c, d, e) {\n var f = Z();\n try {\n return ji(a, b, c, d, e);\n } catch (h) {\n Y(f);\n if (h !== h + 0)\n throw h;\n X(1, 0);\n }\n }\n function Ad(a, b, c, d) {\n var e = Z();\n try {\n return Ni(a, b, c, d);\n } catch (f) {\n Y(e);\n if (f !== f + 0)\n throw f;\n X(1, 0);\n return 0n;\n }\n }\n function Je(a, b, c, d, e, f, h) {\n var k = Z();\n try {\n ki(a, b, c, d, e, f, h);\n } catch (l) {\n Y(k);\n if (l !== l + 0)\n throw l;\n X(1, 0);\n }\n }\n function qd(a, b, c, d, e, f) {\n var h = Z();\n try {\n return li(a, b, c, d, e, f);\n } catch (k) {\n Y(h);\n if (k !== k + 0)\n throw k;\n X(1, 0);\n }\n }\n function ud(a, b, c, d, e, f) {\n var h = Z();\n try {\n return mi(a, b, c, d, e, f);\n } catch (k) {\n Y(h);\n if (k !== k + 0)\n throw k;\n X(1, 0);\n }\n }\n function Se(a, b, c, d, e, f, h, k, l) {\n var m = Z();\n try {\n ni(a, b, c, d, e, f, h, k, l);\n } catch (n) {\n Y(m);\n if (n !== n + 0)\n throw n;\n X(1, 0);\n }\n }\n function Ld(a, b, c, d) {\n var e = Z();\n try {\n Nh(a, b, c, d);\n } catch (f) {\n Y(e);\n if (f !== f + 0)\n throw f;\n X(1, 0);\n }\n }\n function Zc(a, b, c, d, e, f, h, k) {\n var l = Z();\n try {\n return oi(a, b, c, d, e, f, h, k);\n } catch (m) {\n Y(l);\n if (m !== m + 0)\n throw m;\n X(1, 0);\n }\n }\n function Ec(a, b, c, d, e, f) {\n var h = Z();\n try {\n return pi(a, b, c, d, e, f);\n } catch (k) {\n Y(h);\n if (k !== k + 0)\n throw k;\n X(1, 0);\n }\n }\n function fd(a, b, c, d, e, f) {\n var h = Z();\n try {\n return qi(a, b, c, d, e, f);\n } catch (k) {\n Y(h);\n if (k !== k + 0)\n throw k;\n X(1, 0);\n }\n }\n function Sc(a, b, c, d, e, f, h, k, l, m, n, q) {\n var r = Z();\n try {\n return ri(a, b, c, d, e, f, h, k, l, m, n, q);\n } catch (p) {\n Y(r);\n if (p !== p + 0)\n throw p;\n X(1, 0);\n }\n }\n function bd(a, b, c, d, e, f, h, k) {\n var l = Z();\n try {\n return si(a, b, c, d, e, f, h, k);\n } catch (m) {\n Y(l);\n if (m !== m + 0)\n throw m;\n X(1, 0);\n }\n }\n function Vc(a, b, c, d, e, f, h, k, l, m, n) {\n var q = Z();\n try {\n return ti(a, b, c, d, e, f, h, k, l, m, n);\n } catch (r) {\n Y(q);\n if (r !== r + 0)\n throw r;\n X(1, 0);\n }\n }\n function gd(a, b, c, d, e, f, h) {\n var k = Z();\n try {\n return ui(a, b, c, d, e, f, h);\n } catch (l) {\n Y(k);\n if (l !== l + 0)\n throw l;\n X(1, 0);\n }\n }\n function Uc(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n var p = Z();\n try {\n return vi(a, b, c, d, e, f, h, k, l, m, n, q, r);\n } catch (u) {\n Y(p);\n if (u !== u + 0)\n throw u;\n X(1, 0);\n }\n }\n function od(a, b, c, d, e, f, h) {\n var k = Z();\n try {\n return wi(a, b, c, d, e, f, h);\n } catch (l) {\n Y(k);\n if (l !== l + 0)\n throw l;\n X(1, 0);\n }\n }\n function rd(a, b, c, d, e, f, h) {\n var k = Z();\n try {\n return xi(a, b, c, d, e, f, h);\n } catch (l) {\n Y(k);\n if (l !== l + 0)\n throw l;\n X(1, 0);\n }\n }\n function Bd(a, b, c) {\n var d = Z();\n try {\n return yi(a, b, c);\n } catch (e) {\n Y(d);\n if (e !== e + 0)\n throw e;\n X(1, 0);\n return 0n;\n }\n }\n function nd(a, b, c, d) {\n var e = Z();\n try {\n return zi(a, b, c, d);\n } catch (f) {\n Y(e);\n if (f !== f + 0)\n throw f;\n X(1, 0);\n }\n }\n function Gd(a, b, c, d) {\n var e = Z();\n try {\n Bi(a, b, c, d);\n } catch (f) {\n Y(e);\n if (f !== f + 0)\n throw f;\n X(1, 0);\n }\n }\n function Cc(a, b, c, d) {\n var e = Z();\n try {\n return Ai(a, b, c, d);\n } catch (f) {\n Y(e);\n if (f !== f + 0)\n throw f;\n X(1, 0);\n }\n }\n function tf(a, b, c, d, e) {\n var f = Z();\n try {\n Ci(a, b, c, d, e);\n } catch (h) {\n Y(f);\n if (h !== h + 0)\n throw h;\n X(1, 0);\n }\n }\n function qc(a, b, c, d, e) {\n var f = Z();\n try {\n return Di(a, b, c, d, e);\n } catch (h) {\n Y(f);\n if (h !== h + 0)\n throw h;\n X(1, 0);\n }\n }\n function rc(a, b, c, d, e, f) {\n var h = Z();\n try {\n return Ei(a, b, c, d, e, f);\n } catch (k) {\n Y(h);\n if (k !== k + 0)\n throw k;\n X(1, 0);\n }\n }\n function Te(a, b, c, d, e, f, h, k, l, m, n, q) {\n var r = Z();\n try {\n Fi(a, b, c, d, e, f, h, k, l, m, n, q);\n } catch (p) {\n Y(r);\n if (p !== p + 0)\n throw p;\n X(1, 0);\n }\n }\n function bf(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n var p = Z();\n try {\n Gi(a, b, c, d, e, f, h, k, l, m, n, q, r);\n } catch (u) {\n Y(p);\n if (u !== u + 0)\n throw u;\n X(1, 0);\n }\n }\n function te(a, b, c, d, e, f, h, k, l, m, n, q) {\n var r = Z();\n try {\n Eg(a, b, c, d, e, f, h, k, l, m, n, q);\n } catch (p) {\n Y(r);\n if (p !== p + 0)\n throw p;\n X(1, 0);\n }\n }\n function $c(a, b, c, d, e) {\n var f = Z();\n try {\n return Hi(a, b, c, d, e);\n } catch (h) {\n Y(f);\n if (h !== h + 0)\n throw h;\n X(1, 0);\n }\n }\n function vd(a) {\n var b = Z();\n try {\n return eg(a);\n } catch (c) {\n Y(b);\n if (c !== c + 0)\n throw c;\n X(1, 0);\n return 0n;\n }\n }\n function Wc(a, b, c, d, e, f) {\n var h = Z();\n try {\n return dg(a, b, c, d, e, f);\n } catch (k) {\n Y(h);\n if (k !== k + 0)\n throw k;\n X(1, 0);\n }\n }\n function Gc(a, b, c, d, e, f) {\n var h = Z();\n try {\n return ci(a, b, c, d, e, f);\n } catch (k) {\n Y(h);\n if (k !== k + 0)\n throw k;\n X(1, 0);\n }\n }\n function oe(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) {\n var A = Z();\n try {\n $h(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y);\n } catch (B) {\n Y(A);\n if (B !== B + 0)\n throw B;\n X(1, 0);\n }\n }\n function uc(a, b, c) {\n var d = Z();\n try {\n return qg(a, b, c);\n } catch (e) {\n Y(d);\n if (e !== e + 0)\n throw e;\n X(1, 0);\n }\n }\n function oc(a, b, c) {\n var d = Z();\n try {\n return sg(a, b, c);\n } catch (e) {\n Y(d);\n if (e !== e + 0)\n throw e;\n X(1, 0);\n }\n }\n function Df() {\n var a = U;\n a = Object.assign({}, a);\n var b = (c) => (d) => c(d) >>> 0;\n a.Fd = b(a.Fd);\n a.he = b(a.he);\n a.ne = b(a.ne);\n a.oe = ((c) => () => c() >>> 0)(a.oe);\n return a;\n }\n g.stackSave = () => Z();\n g.stackRestore = (a) => Y(a);\n g.stackAlloc = (a) => Ef(a);\n g.UTF8ToString = J;\n g.stringToUTF8 = (a, b, c) => M(a, E, b, c);\n g.lengthBytesUTF8 = bb;\n var Oi;\n Fa = function Pi() {\n Oi || Ri();\n Oi || (Fa = Pi);\n };\n function Ri() {\n if (!(0 < Da)) {\n if (g.preRun)\n for ("function" == typeof g.preRun && (g.preRun = [g.preRun]); g.preRun.length; ) {\n var a = g.preRun.shift();\n Aa.unshift(a);\n }\n for (; 0 < Aa.length; )\n Aa.shift()(g);\n if (!(0 < Da || Oi || (Oi = true, g.calledRun = true, x))) {\n for (; 0 < Ba.length; )\n Ba.shift()(g);\n for (aa(g); 0 < Ca.length; )\n Ca.shift()(g);\n }\n }\n }\n Ri();\n return readyPromise;\n };\n })();\n if (typeof exports === "object" && typeof module === "object")\n module.exports = ortWasm;\n else if (typeof define === "function" && define["amd"])\n define([], () => ortWasm);\n }\n });\n\n // nodejs-ignore:worker_threads\n var require_worker_threads = __commonJS({\n "nodejs-ignore:worker_threads"() {\n }\n });\n\n // nodejs-ignore:perf_hooks\n var require_perf_hooks = __commonJS({\n "nodejs-ignore:perf_hooks"() {\n }\n });\n\n // nodejs-ignore:os\n var os_exports = {};\n __export(os_exports, {\n cpus: () => cpus\n });\n var cpus;\n var init_os = __esm({\n "nodejs-ignore:os"() {\n cpus = void 0;\n }\n });\n\n // web/lib/wasm/binding/ort-wasm-simd-threaded.jsep.js\n var require_ort_wasm_simd_threaded_jsep = __commonJS({\n "web/lib/wasm/binding/ort-wasm-simd-threaded.jsep.js"(exports, module) {\n "use strict";\n var ortWasmThreaded = (() => {\n var _scriptDir = typeof document !== "undefined" && document.currentScript ? document.currentScript.src : void 0;\n if (typeof __filename !== "undefined")\n _scriptDir = _scriptDir || __filename;\n return function(moduleArg = {}) {\n function d() {\n l.buffer != p.buffer && t();\n return p;\n }\n function v() {\n l.buffer != p.buffer && t();\n return aa;\n }\n function z() {\n l.buffer != p.buffer && t();\n return ba;\n }\n function A() {\n l.buffer != p.buffer && t();\n return ca;\n }\n function da() {\n l.buffer != p.buffer && t();\n return ea;\n }\n var B = moduleArg, fa, C;\n B.ready = new Promise((a, b) => {\n fa = a;\n C = b;\n });\n "use strict";\n B.jsepInit = (a, b, c, e, f, h, k, q) => {\n B.Qb = a;\n B.wb = b;\n B.yb = c;\n B.jb = e;\n B.xb = f;\n B.Ea = h;\n B.zb = k;\n B.Ab = q;\n b = (n, m, r) => (...w) => {\n const x = D, g = m?.();\n w = n(...w);\n const u = m?.();\n g !== u && (n = u, r(g), m = r = null);\n return D != x ? ha() : w;\n };\n c = (n) => async (...m) => {\n try {\n if (B.bb)\n throw Error("Session already started");\n const r = B.bb = { Fb: m[0], errors: [] }, w = await n(...m);\n if (B.bb !== r)\n throw Error("Session mismatch");\n a.flush();\n const x = r.errors;\n if (0 < x.length) {\n let g = await Promise.all(x);\n g = g.filter((u) => u);\n if (0 < g.length)\n throw Error(g.join("\\n"));\n }\n return w;\n } finally {\n B.bb = null;\n }\n };\n B._OrtRun = c(b(B._OrtRun, () => B._OrtRun, (n) => B._OrtRun = n));\n B._OrtRunWithBinding = c(b(B._OrtRunWithBinding, () => B._OrtRunWithBinding, (n) => B._OrtRunWithBinding = n));\n B._OrtBindInput = b(B._OrtBindInput, () => B._OrtBindInput, (n) => B._OrtBindInput = n);\n B.jsepRegisterBuffer = (n, m, r, w) => a.registerBuffer(n, m, r, w);\n B.jsepUnregisterBuffers = (n) => {\n a.unregisterBuffers(n);\n };\n B.jsepGetBuffer = (n) => a.getBuffer(n);\n B.jsepCreateDownloader = (n, m, r) => a.createDownloader(n, m, r);\n };\n var ia = Object.assign({}, B), ja = "./this.program", E = (a, b) => {\n throw b;\n }, ka = "object" == typeof window, F = "function" == typeof importScripts, G = "object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node, H = B.ENVIRONMENT_IS_PTHREAD || false, I = "";\n function la(a) {\n return B.locateFile ? B.locateFile(a, I) : I + a;\n }\n var ma, J, na;\n if (G) {\n var fs = (init_fs(), __toCommonJS(fs_exports)), oa = (init_path(), __toCommonJS(path_exports));\n I = F ? oa.dirname(I) + "/" : __dirname + "/";\n ma = (b, c) => {\n b = b.startsWith("file://") ? new URL(b) : oa.normalize(b);\n return fs.readFileSync(b, c ? void 0 : "utf8");\n };\n na = (b) => {\n b = ma(b, true);\n b.buffer || (b = new Uint8Array(b));\n return b;\n };\n J = (b, c, e, f = true) => {\n b = b.startsWith("file://") ? new URL(b) : oa.normalize(b);\n fs.readFile(b, f ? void 0 : "utf8", (h, k) => {\n h ? e(h) : c(f ? k.buffer : k);\n });\n };\n !B.thisProgram && 1 < process.argv.length && (ja = process.argv[1].replace(/\\\\/g, "/"));\n process.argv.slice(2);\n E = (b, c) => {\n process.exitCode = b;\n throw c;\n };\n B.inspect = () => "[Emscripten Module object]";\n let a;\n try {\n a = require_worker_threads();\n } catch (b) {\n throw console.error(\'The "worker_threads" module is not supported in this node.js build - perhaps a newer version is needed?\'), b;\n }\n global.Worker = a.Worker;\n } else if (ka || F)\n F ? I = self.location.href : "undefined" != typeof document && document.currentScript && (I = document.currentScript.src), typeof _scriptDir !== "undefined" && _scriptDir && (I = _scriptDir), 0 !== I.indexOf("blob:") ? I = I.substr(0, I.replace(/[?#].*/, "").lastIndexOf("/") + 1) : I = "", G || (ma = (a) => {\n var b = new XMLHttpRequest();\n b.open("GET", a, false);\n b.send(null);\n return b.responseText;\n }, F && (na = (a) => {\n var b = new XMLHttpRequest();\n b.open("GET", a, false);\n b.responseType = "arraybuffer";\n b.send(null);\n return new Uint8Array(b.response);\n }), J = (a, b, c) => {\n var e = new XMLHttpRequest();\n e.open("GET", a, true);\n e.responseType = "arraybuffer";\n e.onload = () => {\n 200 == e.status || 0 == e.status && e.response ? b(e.response) : c();\n };\n e.onerror = c;\n e.send(null);\n });\n G && "undefined" == typeof performance && (global.performance = require_perf_hooks().performance);\n var pa = console.log.bind(console), qa = console.error.bind(console);\n G && (pa = (...a) => fs.writeSync(1, a.join(" ") + "\\n"), qa = (...a) => fs.writeSync(2, a.join(" ") + "\\n"));\n var ra = B.print || pa, K = B.printErr || qa;\n Object.assign(B, ia);\n ia = null;\n B.thisProgram && (ja = B.thisProgram);\n B.quit && (E = B.quit);\n var L;\n B.wasmBinary && (L = B.wasmBinary);\n var noExitRuntime = B.noExitRuntime || true;\n "object" != typeof WebAssembly && M("no native wasm support detected");\n var l, N, sa, P = false, Q, p, aa, ba, ca, ea;\n function t() {\n var a = l.buffer;\n B.HEAP8 = p = new Int8Array(a);\n B.HEAP16 = new Int16Array(a);\n B.HEAP32 = ba = new Int32Array(a);\n B.HEAPU8 = aa = new Uint8Array(a);\n B.HEAPU16 = new Uint16Array(a);\n B.HEAPU32 = ca = new Uint32Array(a);\n B.HEAPF32 = new Float32Array(a);\n B.HEAPF64 = ea = new Float64Array(a);\n }\n var ta = B.INITIAL_MEMORY || 16777216;\n 5242880 <= ta || M("INITIAL_MEMORY should be larger than STACK_SIZE, was " + ta + "! (STACK_SIZE=5242880)");\n if (H)\n l = B.wasmMemory;\n else if (B.wasmMemory)\n l = B.wasmMemory;\n else if (l = new WebAssembly.Memory({ initial: ta / 65536, maximum: 65536, shared: true }), !(l.buffer instanceof SharedArrayBuffer))\n throw K("requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag"), G && K("(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and/or recent version)"), Error("bad memory");\n t();\n ta = l.buffer.byteLength;\n var ua = [], va = [], wa = [], xa = 0;\n function ya() {\n return noExitRuntime || 0 < xa;\n }\n var R = 0, za = null, S = null;\n function Aa() {\n R++;\n B.monitorRunDependencies && B.monitorRunDependencies(R);\n }\n function Ba() {\n R--;\n B.monitorRunDependencies && B.monitorRunDependencies(R);\n if (0 == R && (null !== za && (clearInterval(za), za = null), S)) {\n var a = S;\n S = null;\n a();\n }\n }\n function M(a) {\n if (B.onAbort)\n B.onAbort(a);\n a = "Aborted(" + a + ")";\n K(a);\n P = true;\n Q = 1;\n a = new WebAssembly.RuntimeError(a + ". Build with -sASSERTIONS for more info.");\n C(a);\n throw a;\n }\n function Ca(a) {\n return a.startsWith("data:application/octet-stream;base64,");\n }\n var T;\n T = "ort-wasm-simd-threaded.wasm";\n Ca(T) || (T = la(T));\n function Da(a) {\n if (a == T && L)\n return new Uint8Array(L);\n if (na)\n return na(a);\n throw "both async and sync fetching of the wasm failed";\n }\n function Ea(a) {\n if (!L && (ka || F)) {\n if ("function" == typeof fetch && !a.startsWith("file://"))\n return fetch(a, { credentials: "same-origin" }).then((b) => {\n if (!b.ok)\n throw "failed to load wasm binary file at \'" + a + "\'";\n return b.arrayBuffer();\n }).catch(() => Da(a));\n if (J)\n return new Promise((b, c) => {\n J(a, (e) => b(new Uint8Array(e)), c);\n });\n }\n return Promise.resolve().then(() => Da(a));\n }\n function Fa(a, b, c) {\n return Ea(a).then((e) => WebAssembly.instantiate(e, b)).then((e) => e).then(c, (e) => {\n K("failed to asynchronously prepare wasm: " + e);\n M(e);\n });\n }\n function Ga(a, b) {\n var c = T;\n return L || "function" != typeof WebAssembly.instantiateStreaming || Ca(c) || c.startsWith("file://") || G || "function" != typeof fetch ? Fa(c, a, b) : fetch(c, { credentials: "same-origin" }).then((e) => WebAssembly.instantiateStreaming(e, a).then(b, function(f) {\n K("wasm streaming compile failed: " + f);\n K("falling back to ArrayBuffer instantiation");\n return Fa(c, a, b);\n }));\n }\n var U, Ha = {\n 906828: (a) => {\n B.Ea("Abs", a, void 0);\n },\n 906879: (a) => {\n B.Ea("Neg", a, void 0);\n },\n 906930: (a) => {\n B.Ea("Floor", a, void 0);\n },\n 906983: (a) => {\n B.Ea("Ceil", a, void 0);\n },\n 907035: (a) => {\n B.Ea("Reciprocal", a, void 0);\n },\n 907093: (a) => {\n B.Ea("Sqrt", a, void 0);\n },\n 907145: (a) => {\n B.Ea("Exp", a, void 0);\n },\n 907196: (a) => {\n B.Ea("Erf", a, void 0);\n },\n 907247: (a) => {\n B.Ea("Sigmoid", a, void 0);\n },\n 907302: (a) => {\n B.Ea("Log", a, void 0);\n },\n 907353: (a) => {\n B.Ea("Sin", a, void 0);\n },\n 907404: (a) => {\n B.Ea("Cos", a, void 0);\n },\n 907455: (a) => {\n B.Ea("Tan", a, void 0);\n },\n 907506: (a) => {\n B.Ea("Asin", a, void 0);\n },\n 907558: (a) => {\n B.Ea(\n "Acos",\n a,\n void 0\n );\n },\n 907610: (a) => {\n B.Ea("Atan", a, void 0);\n },\n 907662: (a) => {\n B.Ea("Sinh", a, void 0);\n },\n 907714: (a) => {\n B.Ea("Cosh", a, void 0);\n },\n 907766: (a) => {\n B.Ea("Asinh", a, void 0);\n },\n 907819: (a) => {\n B.Ea("Acosh", a, void 0);\n },\n 907872: (a) => {\n B.Ea("Atanh", a, void 0);\n },\n 907925: (a) => {\n B.Ea("Tanh", a, void 0);\n },\n 907977: (a) => {\n B.Ea("Not", a, void 0);\n },\n 908028: (a, b, c) => {\n B.Ea("ClipV10", a, { min: b, max: c });\n },\n 908100: (a) => {\n B.Ea("Clip", a, void 0);\n },\n 908152: (a, b) => {\n B.Ea("Elu", a, { alpha: b });\n },\n 908210: (a) => {\n B.Ea("Relu", a, void 0);\n },\n 908262: (a, b) => {\n B.Ea("LeakyRelu", a, { alpha: b });\n },\n 908326: (a, b) => {\n B.Ea("ThresholdedRelu", a, { alpha: b });\n },\n 908396: (a, b) => {\n B.Ea("Cast", a, { to: b });\n },\n 908454: (a) => {\n B.Ea("Add", a, void 0);\n },\n 908505: (a) => {\n B.Ea("Sub", a, void 0);\n },\n 908556: (a) => {\n B.Ea("Mul", a, void 0);\n },\n 908607: (a) => {\n B.Ea("Div", a, void 0);\n },\n 908658: (a) => {\n B.Ea("Pow", a, void 0);\n },\n 908709: (a) => {\n B.Ea("Equal", a, void 0);\n },\n 908762: (a) => {\n B.Ea("Greater", a, void 0);\n },\n 908817: (a) => {\n B.Ea("GreaterOrEqual", a, void 0);\n },\n 908879: (a) => {\n B.Ea("Less", a, void 0);\n },\n 908931: (a) => {\n B.Ea("LessOrEqual", a, void 0);\n },\n 908990: (a, b, c, e, f) => {\n B.Ea("ReduceMean", a, {\n keepDims: !!b,\n noopWithEmptyAxes: !!c,\n axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : []\n });\n },\n 909154: (a, b, c, e, f) => {\n B.Ea("ReduceMax", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n },\n 909317: (a, b, c, e, f) => {\n B.Ea("ReduceMin", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n },\n 909480: (a, b, c, e, f) => {\n B.Ea("ReduceProd", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n },\n 909644: (a, b, c, e, f) => {\n B.Ea("ReduceSum", a, {\n keepDims: !!b,\n noopWithEmptyAxes: !!c,\n axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : []\n });\n },\n 909807: (a, b, c, e, f) => {\n B.Ea("ReduceL1", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n },\n 909969: (a, b, c, e, f) => {\n B.Ea("ReduceL2", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n },\n 910131: (a, b, c, e, f) => {\n B.Ea("ReduceLogSum", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n },\n 910297: (a, b, c, e, f) => {\n B.Ea("ReduceSumSquare", a, {\n keepDims: !!b,\n noopWithEmptyAxes: !!c,\n axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : []\n });\n },\n 910466: (a, b, c, e, f) => {\n B.Ea("ReduceLogSumExp", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n },\n 910635: (a) => {\n B.Ea("Where", a, void 0);\n },\n 910688: (a, b, c) => {\n B.Ea("Transpose", a, { perm: b ? Array.from(z().subarray(c >>> 0, c + b >>> 0)) : [] });\n },\n 910801: (a, b, c, e, f, h, k, q, n, m) => {\n B.Ea("Conv", a, { format: n ? "NHWC" : "NCHW", auto_pad: b, dilations: [c], group: e, kernel_shape: [f], pads: [h, k], strides: [q], w_is_const: () => !!d()[m >>> 0] });\n },\n 911029: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u) => {\n B.Ea("Conv", a, { format: g ? "NHWC" : "NCHW", auto_pad: b, dilations: [c, e], group: f, kernel_shape: [h, k], pads: [q, n, m, r], strides: [w, x], w_is_const: () => !!d()[u >>> 0] });\n },\n 911288: (a, b, c, e, f, h, k, q, n, m) => {\n B.Ea("Conv", a, { format: n ? "NHWC" : "NCHW", auto_pad: b, dilations: [c], group: e, kernel_shape: [f], pads: [h, k], strides: [q], w_is_const: () => !!d()[m >>> 0] });\n },\n 911516: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u) => {\n B.Ea("Conv", a, { format: g ? "NHWC" : "NCHW", auto_pad: b, dilations: [c, e], group: f, kernel_shape: [\n h,\n k\n ], pads: [q, n, m, r], strides: [w, x], w_is_const: () => !!d()[u >>> 0] });\n },\n 911775: (a, b, c, e, f, h, k, q, n, m, r, w, x, g) => {\n B.Ea("ConvTranspose", a, { format: n ? "NHWC" : "NCHW", autoPad: b, dilations: [c], group: e, kernel_shape: [f], pads: [h, k], strides: [q], wIsConst: () => !!d()[m >>> 0], outputPadding: r ? Array.from(z().subarray(w >>> 0, w + r >>> 0)) : [], outputShape: x ? Array.from(z().subarray(g >>> 0, g + x >>> 0)) : [] });\n },\n 912155: (a, b, c, e, f, h, k, q, n, m, r, w, x) => {\n B.Ea("ConvTranspose", a, { format: q ? "NHWC" : "NCHW", autoPad: b, dilations: Array.from(z().subarray(c >>> 0, c + 2 >>> 0)), group: e, kernelShape: Array.from(z().subarray(f >>> 0, f + 2 >>> 0)), pads: Array.from(z().subarray(h >>> 0, h + 4 >>> 0)), strides: Array.from(z().subarray(k >>> 0, k + 2 >>> 0)), wIsConst: () => !!d()[n >>> 0], outputPadding: 0 < m ? Array.from(z().subarray(r >>> 0, r + m >>> 0)) : [], outputShape: 0 < w ? Array.from(z().subarray(x >>> 0, x + w >>> 0)) : [] });\n },\n 912678: (a, b, c, e, f, h, k, q, n, m, r, w, x, g) => {\n B.Ea("ConvTranspose", a, { format: n ? "NHWC" : "NCHW", autoPad: b, dilations: [c], group: e, kernel_shape: [f], pads: [h, k], strides: [q], wIsConst: () => !!d()[m >>> 0], outputPadding: r ? Array.from(z().subarray(w >>> 0, w + r >>> 0)) : [], outputShape: x ? Array.from(z().subarray(g >>> 0, g + x >>> 0)) : [] });\n },\n 913058: (a, b, c, e, f, h, k, q, n, m, r, w, x) => {\n B.Ea("ConvTranspose", a, { format: q ? "NHWC" : "NCHW", autoPad: b, dilations: Array.from(z().subarray(c >>> 0, c + 2 >>> 0)), group: e, kernelShape: Array.from(z().subarray(f >>> 0, f + 2 >>> 0)), pads: Array.from(z().subarray(h >>> 0, h + 4 >>> 0)), strides: Array.from(z().subarray(k >>> 0, k + 2 >>> 0)), wIsConst: () => !!d()[n >>> 0], outputPadding: 0 < m ? Array.from(z().subarray(r >>> 0, r + m >>> 0)) : [], outputShape: 0 < w ? Array.from(z().subarray(x >>> 0, x + w >>> 0)) : [] });\n },\n 913581: (a, b) => {\n B.Ea("GlobalAveragePool", a, { format: b ? "NHWC" : "NCHW" });\n },\n 913672: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u, y) => {\n B.Ea("AveragePool", a, { format: y ? "NHWC" : "NCHW", auto_pad: b, ceil_mode: c, count_include_pad: e, storage_order: f, dilations: [h, k], kernel_shape: [q, n], pads: [m, r, w, x], strides: [g, u] });\n },\n 913956: (a, b) => {\n B.Ea("GlobalAveragePool", a, { format: b ? "NHWC" : "NCHW" });\n },\n 914047: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u, y) => {\n B.Ea("AveragePool", a, {\n format: y ? "NHWC" : "NCHW",\n auto_pad: b,\n ceil_mode: c,\n count_include_pad: e,\n storage_order: f,\n dilations: [h, k],\n kernel_shape: [q, n],\n pads: [m, r, w, x],\n strides: [g, u]\n });\n },\n 914331: (a, b) => {\n B.Ea("GlobalMaxPool", a, { format: b ? "NHWC" : "NCHW" });\n },\n 914418: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u, y) => {\n B.Ea("MaxPool", a, { format: y ? "NHWC" : "NCHW", auto_pad: b, ceil_mode: c, count_include_pad: e, storage_order: f, dilations: [h, k], kernel_shape: [q, n], pads: [m, r, w, x], strides: [g, u] });\n },\n 914698: (a, b) => {\n B.Ea("GlobalMaxPool", a, { format: b ? "NHWC" : "NCHW" });\n },\n 914785: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u, y) => {\n B.Ea(\n "MaxPool",\n a,\n { format: y ? "NHWC" : "NCHW", auto_pad: b, ceil_mode: c, count_include_pad: e, storage_order: f, dilations: [h, k], kernel_shape: [q, n], pads: [m, r, w, x], strides: [g, u] }\n );\n },\n 915065: (a, b, c, e, f) => {\n B.Ea("Gemm", a, { alpha: b, beta: c, transA: e, transB: f });\n },\n 915169: (a) => {\n B.Ea("MatMul", a, void 0);\n },\n 915223: (a, b, c, e) => {\n B.Ea("ArgMax", a, { keepDims: !!b, selectLastIndex: !!c, axis: e });\n },\n 915331: (a, b, c, e) => {\n B.Ea("ArgMin", a, { keepDims: !!b, selectLastIndex: !!c, axis: e });\n },\n 915439: (a, b) => {\n B.Ea("Softmax", a, { axis: b });\n },\n 915502: (a, b) => {\n B.Ea("Concat", a, { axis: b });\n },\n 915562: (a, b, c, e, f) => {\n B.Ea("Split", a, { axis: b, numOutputs: c, splitSizes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n },\n 915707: (a) => {\n B.Ea("Expand", a, void 0);\n },\n 915761: (a, b) => {\n B.Ea("Gather", a, { axis: Number(b) });\n },\n 915832: (a, b) => {\n B.Ea("GatherElements", a, { axis: Number(b) });\n },\n 915911: (a, b, c, e, f, h, k, q, n, m, r) => {\n B.Ea("Resize", a, { antialias: b, axes: c ? Array.from(z().subarray(e >>> 0, e + c >>> 0)) : [], coordinateTransformMode: V(f), cubicCoeffA: h, excludeOutside: k, extrapolationValue: q, keepAspectRatioPolicy: V(n), mode: V(m), nearestMode: V(r) });\n },\n 916262: (a, b, c, e, f, h, k) => {\n B.Ea("Slice", a, { starts: b ? Array.from(z().subarray(c >>> 0, c + b >>> 0)) : [], ends: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [], axes: h ? Array.from(z().subarray(k >>> 0, k + h >>> 0)) : [] });\n },\n 916493: (a) => {\n B.Ea("Tile", a, void 0);\n },\n 916545: (a, b, c) => {\n B.Ea("LayerNormalization", a, { axis: Number(b), epsilon: Number(c) });\n },\n 916652: (a, b, c) => {\n B.Ea("InstanceNormalization", a, { epsilon: b, format: c ? "NHWC" : "NCHW" });\n },\n 916766: (a, b, c) => {\n B.Ea("InstanceNormalization", a, { epsilon: b, format: c ? "NHWC" : "NCHW" });\n },\n 916880: (a) => {\n B.Ea(\n "Range",\n a,\n void 0\n );\n },\n 916933: (a, b) => {\n B.Ea("Einsum", a, { equation: V(b) });\n },\n 917014: (a, b, c, e, f) => {\n B.Ea("Pad", a, { mode: b, value: c, pads: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n },\n 917146: (a) => {\n B.Ea("Gelu", a, void 0);\n },\n 917198: (a) => {\n B.Ea("BiasAdd", a, void 0);\n },\n 917253: (a) => {\n B.Ea("BiasSplitGelu", a, void 0);\n },\n 917314: (a, b) => {\n B.Ea("SkipLayerNormalization", a, { epsilon: b });\n },\n 917395: (a) => {\n B.zb(a);\n },\n 917429: (a, b) => B.Ab(a, b, B.bb.Fb, B.bb.errors),\n 917541: (a) => B.wb(a),\n 917574: (a) => B.yb(a),\n 917606: (a, b, c) => {\n B.jb(a, b, c, true);\n },\n 917645: (a, b, c) => {\n B.jb(a, b, c);\n }\n };\n function Ia(a) {\n this.name = "ExitStatus";\n this.message = `Program terminated with exit(${a})`;\n this.status = a;\n }\n function Ja(a) {\n a.terminate();\n a.onmessage = () => {\n };\n }\n function Ka(a) {\n (a = W.Qa[a]) || M();\n W.Eb(a);\n }\n function La(a) {\n var b = W.tb();\n if (!b)\n return 6;\n W.Ya.push(b);\n W.Qa[a.Xa] = b;\n b.Xa = a.Xa;\n var c = { cmd: "run", start_routine: a.Gb, arg: a.rb, pthread_ptr: a.Xa };\n G && b.unref();\n b.postMessage(c, a.Mb);\n return 0;\n }\n var Ma = "undefined" != typeof TextDecoder ? new TextDecoder("utf8") : void 0, Na = (a, b, c) => {\n b >>>= 0;\n var e = b + c;\n for (c = b; a[c] && !(c >= e); )\n ++c;\n if (16 < c - b && a.buffer && Ma)\n return Ma.decode(a.buffer instanceof SharedArrayBuffer ? a.slice(b, c) : a.subarray(b, c));\n for (e = ""; b < c; ) {\n var f = a[b++];\n if (f & 128) {\n var h = a[b++] & 63;\n if (192 == (f & 224))\n e += String.fromCharCode((f & 31) << 6 | h);\n else {\n var k = a[b++] & 63;\n f = 224 == (f & 240) ? (f & 15) << 12 | h << 6 | k : (f & 7) << 18 | h << 12 | k << 6 | a[b++] & 63;\n 65536 > f ? e += String.fromCharCode(f) : (f -= 65536, e += String.fromCharCode(55296 | f >> 10, 56320 | f & 1023));\n }\n } else\n e += String.fromCharCode(f);\n }\n return e;\n }, V = (a, b) => (a >>>= 0) ? Na(v(), a, b) : "";\n function Oa(a) {\n if (H)\n return X(1, 1, a);\n Q = a;\n if (!ya()) {\n W.Hb();\n if (B.onExit)\n B.onExit(a);\n P = true;\n }\n E(a, new Ia(a));\n }\n var Qa = (a) => {\n Q = a;\n if (H)\n throw Pa(a), "unwind";\n Oa(a);\n }, W = {\n ab: [],\n Ya: [],\n mb: [],\n Qa: {},\n gb: function() {\n H ? W.vb() : W.ub();\n },\n ub: function() {\n ua.unshift(() => {\n Aa();\n W.Bb(() => Ba());\n });\n },\n vb: function() {\n W.receiveObjectTransfer = W.Db;\n W.threadInitTLS = W.lb;\n W.setExitStatus = W.kb;\n noExitRuntime = false;\n },\n kb: function(a) {\n Q = a;\n },\n Sb: ["$terminateWorker"],\n Hb: function() {\n for (var a of W.Ya)\n Ja(a);\n for (a of W.ab)\n Ja(a);\n W.ab = [];\n W.Ya = [];\n W.Qa = [];\n },\n Eb: function(a) {\n var b = a.Xa;\n delete W.Qa[b];\n W.ab.push(a);\n W.Ya.splice(W.Ya.indexOf(a), 1);\n a.Xa = 0;\n Ra(b);\n },\n Db: function() {\n },\n lb: function() {\n W.mb.forEach((a) => a());\n },\n Cb: (a) => new Promise((b) => {\n a.onmessage = (h) => {\n h = h.data;\n var k = h.cmd;\n if (h.targetThread && h.targetThread != Sa()) {\n var q = W.Qa[h.Rb];\n q ? q.postMessage(h, h.transferList) : K(\'Internal error! Worker sent a message "\' + k + \'" to target pthread \' + h.targetThread + ", but that thread no longer exists!");\n } else if ("checkMailbox" === k)\n Ta();\n else if ("spawnThread" === k)\n La(h);\n else if ("cleanupThread" === k)\n Ka(h.thread);\n else if ("killThread" === k)\n h = h.thread, k = W.Qa[h], delete W.Qa[h], Ja(k), Ra(h), W.Ya.splice(\n W.Ya.indexOf(k),\n 1\n ), k.Xa = 0;\n else if ("cancelThread" === k)\n W.Qa[h.thread].postMessage({ cmd: "cancel" });\n else if ("loaded" === k)\n a.loaded = true, b(a);\n else if ("alert" === k)\n alert("Thread " + h.threadId + ": " + h.text);\n else if ("setimmediate" === h.target)\n a.postMessage(h);\n else if ("callHandler" === k)\n B[h.handler](...h.args);\n else\n k && K("worker sent an unknown command " + k);\n };\n a.onerror = (h) => {\n K("worker sent an error! " + h.filename + ":" + h.lineno + ": " + h.message);\n throw h;\n };\n G && (a.on("message", function(h) {\n a.onmessage({ data: h });\n }), a.on("error", function(h) {\n a.onerror(h);\n }));\n var c = [], e = ["onExit", "onAbort", "print", "printErr"], f;\n for (f of e)\n B.hasOwnProperty(f) && c.push(f);\n a.postMessage({ cmd: "load", handlers: c, urlOrBlob: B.mainScriptUrlOrBlob || _scriptDir, wasmMemory: l, wasmModule: sa });\n }),\n Bb: function(a) {\n a();\n },\n qb: function() {\n var a = la("ort-wasm-simd-threaded.worker.js");\n a = new Worker(a);\n W.ab.push(a);\n },\n tb: function() {\n 0 == W.ab.length && (W.qb(), W.Cb(W.ab[0]));\n return W.ab.pop();\n }\n };\n B.PThread = W;\n var Ua = (a) => {\n for (; 0 < a.length; )\n a.shift()(B);\n };\n B.establishStackSpace = function() {\n var a = Sa(), b = z()[a + 52 >> 2 >>> 0];\n a = z()[a + 56 >> 2 >>> 0];\n Va(b, b - a);\n Wa(b);\n };\n function Pa(a) {\n if (H)\n return X(2, 0, a);\n Qa(a);\n }\n B.invokeEntryPoint = function(a, b) {\n a = Xa.apply(null, [a, b]);\n ya() ? W.kb(a) : Ya(a);\n };\n function Za(a) {\n this.fb = a - 24;\n this.pb = function(b) {\n A()[this.fb + 4 >> 2 >>> 0] = b;\n };\n this.ob = function(b) {\n A()[this.fb + 8 >> 2 >>> 0] = b;\n };\n this.gb = function(b, c) {\n this.nb();\n this.pb(b);\n this.ob(c);\n };\n this.nb = function() {\n A()[this.fb + 16 >> 2 >>> 0] = 0;\n };\n }\n var $a = 0, ab = 0;\n function bb(a, b, c, e) {\n return H ? X(3, 1, a, b, c, e) : cb(a, b, c, e);\n }\n function cb(a, b, c, e) {\n a >>>= 0;\n b >>>= 0;\n c >>>= 0;\n e >>>= 0;\n if ("undefined" == typeof SharedArrayBuffer)\n return K("Current environment does not support SharedArrayBuffer, pthreads are not available!"), 6;\n var f = [];\n if (H && 0 === f.length)\n return bb(a, b, c, e);\n a = { Gb: c, Xa: a, rb: e, Mb: f };\n return H ? (a.Ob = "spawnThread", postMessage(a, f), 0) : La(a);\n }\n function db(a, b, c) {\n return H ? X(4, 1, a, b, c) : 0;\n }\n function eb(a, b) {\n if (H)\n return X(5, 1, a, b);\n }\n var fb = (a) => {\n for (var b = 0, c = 0; c < a.length; ++c) {\n var e = a.charCodeAt(c);\n 127 >= e ? b++ : 2047 >= e ? b += 2 : 55296 <= e && 57343 >= e ? (b += 4, ++c) : b += 3;\n }\n return b;\n }, gb = (a, b, c, e) => {\n c >>>= 0;\n if (!(0 < e))\n return 0;\n var f = c;\n e = c + e - 1;\n for (var h = 0; h < a.length; ++h) {\n var k = a.charCodeAt(h);\n if (55296 <= k && 57343 >= k) {\n var q = a.charCodeAt(++h);\n k = 65536 + ((k & 1023) << 10) | q & 1023;\n }\n if (127 >= k) {\n if (c >= e)\n break;\n b[c++ >>> 0] = k;\n } else {\n if (2047 >= k) {\n if (c + 1 >= e)\n break;\n b[c++ >>> 0] = 192 | k >> 6;\n } else {\n if (65535 >= k) {\n if (c + 2 >= e)\n break;\n b[c++ >>> 0] = 224 | k >> 12;\n } else {\n if (c + 3 >= e)\n break;\n b[c++ >>> 0] = 240 | k >> 18;\n b[c++ >>> 0] = 128 | k >> 12 & 63;\n }\n b[c++ >>> 0] = 128 | k >> 6 & 63;\n }\n b[c++ >>> 0] = 128 | k & 63;\n }\n }\n b[c >>> 0] = 0;\n return c - f;\n }, hb = (a, b, c) => gb(a, v(), b, c);\n function ib(a, b) {\n if (H)\n return X(6, 1, a, b);\n }\n function jb(a, b, c) {\n if (H)\n return X(7, 1, a, b, c);\n }\n function kb(a, b, c) {\n return H ? X(8, 1, a, b, c) : 0;\n }\n function lb(a, b) {\n if (H)\n return X(9, 1, a, b);\n }\n function mb(a, b, c) {\n if (H)\n return X(10, 1, a, b, c);\n }\n function nb(a, b, c, e) {\n if (H)\n return X(11, 1, a, b, c, e);\n }\n function ob(a, b, c, e) {\n if (H)\n return X(12, 1, a, b, c, e);\n }\n function pb(a, b, c, e) {\n if (H)\n return X(13, 1, a, b, c, e);\n }\n function qb(a) {\n if (H)\n return X(14, 1, a);\n }\n function rb(a, b) {\n if (H)\n return X(15, 1, a, b);\n }\n function sb(a, b, c) {\n if (H)\n return X(16, 1, a, b, c);\n }\n var tb = (a) => {\n if (!P)\n try {\n if (a(), !ya())\n try {\n H ? Ya(Q) : Qa(Q);\n } catch (b) {\n b instanceof Ia || "unwind" == b || E(1, b);\n }\n } catch (b) {\n b instanceof Ia || "unwind" == b || E(1, b);\n }\n };\n function ub(a) {\n a >>>= 0;\n "function" === typeof Atomics.Nb && (Atomics.Nb(z(), a >> 2, a).value.then(Ta), a += 128, Atomics.store(z(), a >> 2, 1));\n }\n B.__emscripten_thread_mailbox_await = ub;\n function Ta() {\n var a = Sa();\n a && (ub(a), tb(() => vb()));\n }\n B.checkMailbox = Ta;\n var Y = (a) => 0 === a % 4 && (0 !== a % 100 || 0 === a % 400), wb = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335], xb = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];\n function yb(a, b, c, e, f, h, k, q) {\n return H ? X(17, 1, a, b, c, e, f, h, k, q) : -52;\n }\n function zb(a, b, c, e, f, h, k) {\n if (H)\n return X(18, 1, a, b, c, e, f, h, k);\n }\n var Bb = (a) => {\n var b = fb(a) + 1, c = Ab(b);\n c && hb(a, c, b);\n return c;\n }, Cb = [], Db = (a, b) => {\n Cb.length = 0;\n var c;\n for (b >>= 2; c = v()[a++ >>> 0]; )\n b += 105 != c & b, Cb.push(105 == c ? z()[b >>> 0] : da()[b++ >>> 1]), ++b;\n return Cb;\n }, Fb = (a) => {\n var b = Eb();\n a = a();\n Wa(b);\n return a;\n };\n function X(a, b) {\n var c = arguments.length - 2, e = arguments;\n return Fb(() => {\n for (var f = Gb(8 * c), h = f >> 3, k = 0; k < c; k++) {\n var q = e[2 + k];\n da()[h + k >>> 0] = q;\n }\n return Hb(a, c, f, b);\n });\n }\n var Ib = [], Jb = {}, Lb = () => {\n if (!Kb) {\n var a = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: ("object" == typeof navigator && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8", _: ja || "./this.program" }, b;\n for (b in Jb)\n void 0 === Jb[b] ? delete a[b] : a[b] = Jb[b];\n var c = [];\n for (b in a)\n c.push(`${b}=${a[b]}`);\n Kb = c;\n }\n return Kb;\n }, Kb;\n function Mb(a, b) {\n if (H)\n return X(19, 1, a, b);\n a >>>= 0;\n b >>>= 0;\n var c = 0;\n Lb().forEach(function(e, f) {\n var h = b + c;\n f = A()[a + 4 * f >> 2 >>> 0] = h;\n for (h = 0; h < e.length; ++h)\n d()[f++ >> 0 >>> 0] = e.charCodeAt(h);\n d()[f >> 0 >>> 0] = 0;\n c += e.length + 1;\n });\n return 0;\n }\n function Nb(a, b) {\n if (H)\n return X(20, 1, a, b);\n a >>>= 0;\n b >>>= 0;\n var c = Lb();\n A()[a >> 2 >>> 0] = c.length;\n var e = 0;\n c.forEach(function(f) {\n e += f.length + 1;\n });\n A()[b >> 2 >>> 0] = e;\n return 0;\n }\n function Ob(a) {\n return H ? X(21, 1, a) : 52;\n }\n function Pb(a, b, c, e) {\n return H ? X(22, 1, a, b, c, e) : 52;\n }\n function Qb(a, b, c, e, f) {\n return H ? X(23, 1, a, b, c, e, f) : 70;\n }\n var Rb = [null, [], []];\n function Tb(a, b, c, e) {\n if (H)\n return X(24, 1, a, b, c, e);\n b >>>= 0;\n c >>>= 0;\n e >>>= 0;\n for (var f = 0, h = 0; h < c; h++) {\n var k = A()[b >> 2 >>> 0], q = A()[b + 4 >> 2 >>> 0];\n b += 8;\n for (var n = 0; n < q; n++) {\n var m = v()[k + n >>> 0], r = Rb[a];\n 0 === m || 10 === m ? ((1 === a ? ra : K)(Na(r, 0)), r.length = 0) : r.push(m);\n }\n f += q;\n }\n A()[e >> 2 >>> 0] = f;\n return 0;\n }\n var Ub = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], Vb = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];\n function Wb(a) {\n var b = Array(fb(a) + 1);\n gb(a, b, 0, b.length);\n return b;\n }\n var Xb = (a, b) => {\n d().set(a, b >>> 0);\n };\n function Yb(a, b, c, e) {\n function f(g, u, y) {\n for (g = "number" == typeof g ? g.toString() : g || ""; g.length < u; )\n g = y[0] + g;\n return g;\n }\n function h(g, u) {\n return f(g, u, "0");\n }\n function k(g, u) {\n function y(Sb) {\n return 0 > Sb ? -1 : 0 < Sb ? 1 : 0;\n }\n var O;\n 0 === (O = y(g.getFullYear() - u.getFullYear())) && 0 === (O = y(g.getMonth() - u.getMonth())) && (O = y(g.getDate() - u.getDate()));\n return O;\n }\n function q(g) {\n switch (g.getDay()) {\n case 0:\n return new Date(g.getFullYear() - 1, 11, 29);\n case 1:\n return g;\n case 2:\n return new Date(g.getFullYear(), 0, 3);\n case 3:\n return new Date(\n g.getFullYear(),\n 0,\n 2\n );\n case 4:\n return new Date(g.getFullYear(), 0, 1);\n case 5:\n return new Date(g.getFullYear() - 1, 11, 31);\n case 6:\n return new Date(g.getFullYear() - 1, 11, 30);\n }\n }\n function n(g) {\n var u = g.Za;\n for (g = new Date(new Date(g.$a + 1900, 0, 1).getTime()); 0 < u; ) {\n var y = g.getMonth(), O = (Y(g.getFullYear()) ? Ub : Vb)[y];\n if (u > O - g.getDate())\n u -= O - g.getDate() + 1, g.setDate(1), 11 > y ? g.setMonth(y + 1) : (g.setMonth(0), g.setFullYear(g.getFullYear() + 1));\n else {\n g.setDate(g.getDate() + u);\n break;\n }\n }\n y = new Date(g.getFullYear() + 1, 0, 4);\n u = q(new Date(\n g.getFullYear(),\n 0,\n 4\n ));\n y = q(y);\n return 0 >= k(u, g) ? 0 >= k(y, g) ? g.getFullYear() + 1 : g.getFullYear() : g.getFullYear() - 1;\n }\n a >>>= 0;\n b >>>= 0;\n c >>>= 0;\n e >>>= 0;\n var m = z()[e + 40 >> 2 >>> 0];\n e = { Kb: z()[e >> 2 >>> 0], Jb: z()[e + 4 >> 2 >>> 0], cb: z()[e + 8 >> 2 >>> 0], ib: z()[e + 12 >> 2 >>> 0], eb: z()[e + 16 >> 2 >>> 0], $a: z()[e + 20 >> 2 >>> 0], Wa: z()[e + 24 >> 2 >>> 0], Za: z()[e + 28 >> 2 >>> 0], Tb: z()[e + 32 >> 2 >>> 0], Ib: z()[e + 36 >> 2 >>> 0], Lb: m ? V(m) : "" };\n c = V(c);\n m = {\n "%c": "%a %b %d %H:%M:%S %Y",\n "%D": "%m/%d/%y",\n "%F": "%Y-%m-%d",\n "%h": "%b",\n "%r": "%I:%M:%S %p",\n "%R": "%H:%M",\n "%T": "%H:%M:%S",\n "%x": "%m/%d/%y",\n "%X": "%H:%M:%S",\n "%Ec": "%c",\n "%EC": "%C",\n "%Ex": "%m/%d/%y",\n "%EX": "%H:%M:%S",\n "%Ey": "%y",\n "%EY": "%Y",\n "%Od": "%d",\n "%Oe": "%e",\n "%OH": "%H",\n "%OI": "%I",\n "%Om": "%m",\n "%OM": "%M",\n "%OS": "%S",\n "%Ou": "%u",\n "%OU": "%U",\n "%OV": "%V",\n "%Ow": "%w",\n "%OW": "%W",\n "%Oy": "%y"\n };\n for (var r in m)\n c = c.replace(new RegExp(r, "g"), m[r]);\n var w = "Sunday Monday Tuesday Wednesday Thursday Friday Saturday".split(" "), x = "January February March April May June July August September October November December".split(" ");\n m = { "%a": (g) => w[g.Wa].substring(0, 3), "%A": (g) => w[g.Wa], "%b": (g) => x[g.eb].substring(0, 3), "%B": (g) => x[g.eb], "%C": (g) => h((g.$a + 1900) / 100 | 0, 2), "%d": (g) => h(g.ib, 2), "%e": (g) => f(g.ib, 2, " "), "%g": (g) => n(g).toString().substring(2), "%G": (g) => n(g), "%H": (g) => h(g.cb, 2), "%I": (g) => {\n g = g.cb;\n 0 == g ? g = 12 : 12 < g && (g -= 12);\n return h(g, 2);\n }, "%j": (g) => {\n for (var u = 0, y = 0; y <= g.eb - 1; u += (Y(g.$a + 1900) ? Ub : Vb)[y++])\n ;\n return h(g.ib + u, 3);\n }, "%m": (g) => h(g.eb + 1, 2), "%M": (g) => h(g.Jb, 2), "%n": () => "\\n", "%p": (g) => 0 <= g.cb && 12 > g.cb ? "AM" : "PM", "%S": (g) => h(g.Kb, 2), "%t": () => " ", "%u": (g) => g.Wa || 7, "%U": (g) => h(Math.floor((g.Za + 7 - g.Wa) / 7), 2), "%V": (g) => {\n var u = Math.floor((g.Za + 7 - (g.Wa + 6) % 7) / 7);\n 2 >= (g.Wa + 371 - g.Za - 2) % 7 && u++;\n if (u)\n 53 == u && (y = (g.Wa + 371 - g.Za) % 7, 4 == y || 3 == y && Y(g.$a) || (u = 1));\n else {\n u = 52;\n var y = (g.Wa + 7 - g.Za - 1) % 7;\n (4 == y || 5 == y && Y(g.$a % 400 - 1)) && u++;\n }\n return h(u, 2);\n }, "%w": (g) => g.Wa, "%W": (g) => h(Math.floor((g.Za + 7 - (g.Wa + 6) % 7) / 7), 2), "%y": (g) => (g.$a + 1900).toString().substring(2), "%Y": (g) => g.$a + 1900, "%z": (g) => {\n g = g.Ib;\n var u = 0 <= g;\n g = Math.abs(g) / 60;\n return (u ? "+" : "-") + String("0000" + (g / 60 * 100 + g % 60)).slice(-4);\n }, "%Z": (g) => g.Lb, "%%": () => "%" };\n c = c.replace(/%%/g, "\\0\\0");\n for (r in m)\n c.includes(r) && (c = c.replace(new RegExp(r, "g"), m[r](e)));\n c = c.replace(/\\0\\0/g, "%");\n r = Wb(c);\n if (r.length > b)\n return 0;\n Xb(r, a);\n return r.length - 1;\n }\n function Zb(a) {\n try {\n a();\n } catch (b) {\n M(b);\n }\n }\n function $b(a) {\n var b = {}, c;\n for (c in a)\n (function(e) {\n var f = a[e];\n b[e] = "function" == typeof f ? function() {\n ac.push(e);\n try {\n return f.apply(null, arguments);\n } finally {\n P || (ac.pop() === e || M(), D && 1 === Z && 0 === ac.length && (Z = 0, xa += 1, Zb(bc), "undefined" != typeof Fibers && Fibers.Ub()));\n }\n } : f;\n })(c);\n return b;\n }\n var Z = 0, D = null, cc = 0, ac = [], dc = {}, ec = {}, fc = 0, gc = null, hc = [];\n function ha() {\n return new Promise((a, b) => {\n gc = { resolve: a, reject: b };\n });\n }\n function ic() {\n var a = Ab(65548), b = a + 12;\n A()[a >> 2 >>> 0] = b;\n A()[a + 4 >> 2 >>> 0] = b + 65536;\n b = ac[0];\n var c = dc[b];\n void 0 === c && (c = fc++, dc[b] = c, ec[c] = b);\n b = c;\n z()[a + 8 >> 2 >>> 0] = b;\n return a;\n }\n function jc() {\n var a = z()[D + 8 >> 2 >>> 0];\n a = N[ec[a]];\n --xa;\n return a();\n }\n function kc(a) {\n if (!P) {\n if (0 === Z) {\n var b = false, c = false;\n a((e = 0) => {\n if (!P && (cc = e, b = true, c)) {\n Z = 2;\n Zb(() => lc(D));\n "undefined" != typeof Browser && Browser.hb.sb && Browser.hb.resume();\n e = false;\n try {\n var f = jc();\n } catch (q) {\n f = q, e = true;\n }\n var h = false;\n if (!D) {\n var k = gc;\n k && (gc = null, (e ? k.reject : k.resolve)(f), h = true);\n }\n if (e && !h)\n throw f;\n }\n });\n c = true;\n b || (Z = 1, D = ic(), "undefined" != typeof Browser && Browser.hb.sb && Browser.hb.pause(), Zb(() => mc(D)));\n } else\n 2 === Z ? (Z = 0, Zb(nc), oc(D), D = null, hc.forEach((e) => tb(e))) : M(`invalid state: ${Z}`);\n return cc;\n }\n }\n function pc(a) {\n return kc((b) => {\n a().then(b);\n });\n }\n W.gb();\n var qc = [null, Oa, Pa, bb, db, eb, ib, jb, kb, lb, mb, nb, ob, pb, qb, rb, sb, yb, zb, Mb, Nb, Ob, Pb, Qb, Tb], tc = {\n r: function(a, b, c) {\n return pc(async () => {\n await B.xb(a, b, c);\n });\n },\n b: function(a, b, c) {\n a >>>= 0;\n new Za(a).gb(b >>> 0, c >>> 0);\n $a = a;\n ab++;\n throw $a;\n },\n O: function(a) {\n rc(a >>> 0, !F, 1, !ka, 131072, false);\n W.lb();\n },\n l: function(a) {\n a >>>= 0;\n H ? postMessage({ cmd: "cleanupThread", thread: a }) : Ka(a);\n },\n I: cb,\n i: db,\n U: eb,\n E: ib,\n G: jb,\n V: kb,\n S: lb,\n K: mb,\n R: nb,\n p: ob,\n F: pb,\n C: qb,\n T: rb,\n D: sb,\n q: () => true,\n A: function(a, b) {\n a >>>= 0;\n a == b >>> 0 ? setTimeout(() => Ta()) : H ? postMessage({\n targetThread: a,\n cmd: "checkMailbox"\n }) : (a = W.Qa[a]) && a.postMessage({ cmd: "checkMailbox" });\n },\n M: function() {\n return -1;\n },\n N: ub,\n X: function(a) {\n G && W.Qa[a >>> 0].ref();\n },\n u: function(a, b, c) {\n a = b + 2097152 >>> 0 < 4194305 - !!a ? (a >>> 0) + 4294967296 * b : NaN;\n c >>>= 0;\n a = new Date(1e3 * a);\n z()[c >> 2 >>> 0] = a.getUTCSeconds();\n z()[c + 4 >> 2 >>> 0] = a.getUTCMinutes();\n z()[c + 8 >> 2 >>> 0] = a.getUTCHours();\n z()[c + 12 >> 2 >>> 0] = a.getUTCDate();\n z()[c + 16 >> 2 >>> 0] = a.getUTCMonth();\n z()[c + 20 >> 2 >>> 0] = a.getUTCFullYear() - 1900;\n z()[c + 24 >> 2 >>> 0] = a.getUTCDay();\n a = (a.getTime() - Date.UTC(\n a.getUTCFullYear(),\n 0,\n 1,\n 0,\n 0,\n 0,\n 0\n )) / 864e5 | 0;\n z()[c + 28 >> 2 >>> 0] = a;\n },\n v: function(a, b, c) {\n a = b + 2097152 >>> 0 < 4194305 - !!a ? (a >>> 0) + 4294967296 * b : NaN;\n c >>>= 0;\n a = new Date(1e3 * a);\n z()[c >> 2 >>> 0] = a.getSeconds();\n z()[c + 4 >> 2 >>> 0] = a.getMinutes();\n z()[c + 8 >> 2 >>> 0] = a.getHours();\n z()[c + 12 >> 2 >>> 0] = a.getDate();\n z()[c + 16 >> 2 >>> 0] = a.getMonth();\n z()[c + 20 >> 2 >>> 0] = a.getFullYear() - 1900;\n z()[c + 24 >> 2 >>> 0] = a.getDay();\n b = (Y(a.getFullYear()) ? wb : xb)[a.getMonth()] + a.getDate() - 1 | 0;\n z()[c + 28 >> 2 >>> 0] = b;\n z()[c + 36 >> 2 >>> 0] = -(60 * a.getTimezoneOffset());\n b = new Date(\n a.getFullYear(),\n 6,\n 1\n ).getTimezoneOffset();\n var e = new Date(a.getFullYear(), 0, 1).getTimezoneOffset();\n a = (b != e && a.getTimezoneOffset() == Math.min(e, b)) | 0;\n z()[c + 32 >> 2 >>> 0] = a;\n },\n w: function(a) {\n a >>>= 0;\n var b = new Date(z()[a + 20 >> 2 >>> 0] + 1900, z()[a + 16 >> 2 >>> 0], z()[a + 12 >> 2 >>> 0], z()[a + 8 >> 2 >>> 0], z()[a + 4 >> 2 >>> 0], z()[a >> 2 >>> 0], 0), c = z()[a + 32 >> 2 >>> 0], e = b.getTimezoneOffset(), f = new Date(b.getFullYear(), 6, 1).getTimezoneOffset(), h = new Date(b.getFullYear(), 0, 1).getTimezoneOffset(), k = Math.min(h, f);\n 0 > c ? z()[a + 32 >> 2 >>> 0] = Number(f != h && k == e) : 0 < c != (k == e) && (f = Math.max(h, f), b.setTime(b.getTime() + 6e4 * ((0 < c ? k : f) - e)));\n z()[a + 24 >> 2 >>> 0] = b.getDay();\n c = (Y(b.getFullYear()) ? wb : xb)[b.getMonth()] + b.getDate() - 1 | 0;\n z()[a + 28 >> 2 >>> 0] = c;\n z()[a >> 2 >>> 0] = b.getSeconds();\n z()[a + 4 >> 2 >>> 0] = b.getMinutes();\n z()[a + 8 >> 2 >>> 0] = b.getHours();\n z()[a + 12 >> 2 >>> 0] = b.getDate();\n z()[a + 16 >> 2 >>> 0] = b.getMonth();\n z()[a + 20 >> 2 >>> 0] = b.getYear();\n a = b.getTime() / 1e3;\n return sc((U = a, 1 <= +Math.abs(U) ? 0 < U ? +Math.floor(U / 4294967296) >>> 0 : ~~+Math.ceil((U - +(~~U >>> 0)) / 4294967296) >>> 0 : 0)), a >>> 0;\n },\n s: yb,\n t: zb,\n z: function(a, b, c) {\n function e(m) {\n return (m = m.toTimeString().match(/\\(([A-Za-z ]+)\\)$/)) ? m[1] : "GMT";\n }\n a >>>= 0;\n b >>>= 0;\n c >>>= 0;\n var f = (/* @__PURE__ */ new Date()).getFullYear(), h = new Date(f, 0, 1), k = new Date(f, 6, 1);\n f = h.getTimezoneOffset();\n var q = k.getTimezoneOffset(), n = Math.max(f, q);\n A()[a >> 2 >>> 0] = 60 * n;\n z()[b >> 2 >>> 0] = Number(f != q);\n a = e(h);\n b = e(k);\n a = Bb(a);\n b = Bb(b);\n q < f ? (A()[c >> 2 >>> 0] = a, A()[c + 4 >> 2 >>> 0] = b) : (A()[c >> 2 >>> 0] = b, A()[c + 4 >> 2 >>> 0] = a);\n },\n d: () => {\n M("");\n },\n c: function(a, b, c) {\n a >>>= 0;\n b = Db(b >>> 0, c >>> 0);\n return Ha[a].apply(null, b);\n },\n k: function(a, b, c) {\n a >>>= 0;\n b = Db(b >>> 0, c >>> 0);\n return Ha[a].apply(null, b);\n },\n m: function() {\n },\n j: function() {\n return Date.now();\n },\n W: () => {\n xa += 1;\n throw "unwind";\n },\n B: function() {\n return 4294901760;\n },\n f: () => performance.timeOrigin + performance.now(),\n g: function() {\n return G ? (init_os(), __toCommonJS(os_exports)).cpus().length : navigator.hardwareConcurrency;\n },\n L: function(a, b, c, e) {\n W.Pb = b >>> 0;\n Ib.length = c;\n b = e >>> 0 >> 3;\n for (e = 0; e < c; e++)\n Ib[e] = da()[b + e >>> 0];\n return (0 > a ? Ha[-a - 1] : qc[a]).apply(null, Ib);\n },\n y: function(a) {\n a >>>= 0;\n var b = v().length;\n if (a <= b || 4294901760 < a)\n return false;\n for (var c = 1; 4 >= c; c *= 2) {\n var e = b * (1 + 0.2 / c);\n e = Math.min(e, a + 100663296);\n var f = Math;\n e = Math.max(a, e);\n a: {\n f = f.min.call(f, 4294901760, e + (65536 - e % 65536) % 65536) - l.buffer.byteLength + 65535 >>> 16;\n try {\n l.grow(f);\n t();\n var h = 1;\n break a;\n } catch (k) {\n }\n h = void 0;\n }\n if (h)\n return true;\n }\n return false;\n },\n P: Mb,\n Q: Nb,\n H: Qa,\n h: Ob,\n o: Pb,\n x: Qb,\n n: Tb,\n a: l || B.wasmMemory,\n J: Yb,\n e: function(a, b, c, e) {\n return Yb(a >>> 0, b >>> 0, c >>> 0, e >>> 0);\n }\n };\n (function() {\n function a(c, e) {\n c = c.exports;\n c = $b(c);\n N = c = uc(c);\n W.mb.push(N.Da);\n va.unshift(N.Y);\n sa = e;\n Ba();\n return c;\n }\n var b = { a: tc };\n Aa();\n if (B.instantiateWasm)\n try {\n return B.instantiateWasm(b, a);\n } catch (c) {\n K("Module.instantiateWasm callback failed with error: " + c), C(c);\n }\n Ga(b, function(c) {\n a(c.instance, c.module);\n }).catch(C);\n return {};\n })();\n B._OrtInit = (a, b) => (B._OrtInit = N.Z)(a, b);\n B._OrtGetLastError = (a, b) => (B._OrtGetLastError = N._)(a, b);\n B._OrtCreateSessionOptions = (a, b, c, e, f, h, k, q, n, m) => (B._OrtCreateSessionOptions = N.$)(a, b, c, e, f, h, k, q, n, m);\n B._OrtAppendExecutionProvider = (a, b) => (B._OrtAppendExecutionProvider = N.aa)(a, b);\n B._OrtAddFreeDimensionOverride = (a, b, c) => (B._OrtAddFreeDimensionOverride = N.ba)(a, b, c);\n B._OrtAddSessionConfigEntry = (a, b, c) => (B._OrtAddSessionConfigEntry = N.ca)(a, b, c);\n B._OrtReleaseSessionOptions = (a) => (B._OrtReleaseSessionOptions = N.da)(a);\n B._OrtCreateSession = (a, b, c) => (B._OrtCreateSession = N.ea)(a, b, c);\n B._OrtReleaseSession = (a) => (B._OrtReleaseSession = N.fa)(a);\n B._OrtGetInputOutputCount = (a, b, c) => (B._OrtGetInputOutputCount = N.ga)(a, b, c);\n B._OrtGetInputName = (a, b) => (B._OrtGetInputName = N.ha)(a, b);\n B._OrtGetOutputName = (a, b) => (B._OrtGetOutputName = N.ia)(a, b);\n B._OrtFree = (a) => (B._OrtFree = N.ja)(a);\n B._OrtCreateTensor = (a, b, c, e, f, h) => (B._OrtCreateTensor = N.ka)(a, b, c, e, f, h);\n B._OrtGetTensorData = (a, b, c, e, f) => (B._OrtGetTensorData = N.la)(a, b, c, e, f);\n B._OrtReleaseTensor = (a) => (B._OrtReleaseTensor = N.ma)(a);\n B._OrtCreateRunOptions = (a, b, c, e) => (B._OrtCreateRunOptions = N.na)(a, b, c, e);\n B._OrtAddRunConfigEntry = (a, b, c) => (B._OrtAddRunConfigEntry = N.oa)(a, b, c);\n B._OrtReleaseRunOptions = (a) => (B._OrtReleaseRunOptions = N.pa)(a);\n B._OrtCreateBinding = (a) => (B._OrtCreateBinding = N.qa)(a);\n B._OrtBindInput = (a, b, c) => (B._OrtBindInput = N.ra)(a, b, c);\n B._OrtBindOutput = (a, b, c, e) => (B._OrtBindOutput = N.sa)(a, b, c, e);\n B._OrtClearBoundOutputs = (a) => (B._OrtClearBoundOutputs = N.ta)(a);\n B._OrtReleaseBinding = (a) => (B._OrtReleaseBinding = N.ua)(a);\n B._OrtRunWithBinding = (a, b, c, e, f) => (B._OrtRunWithBinding = N.va)(a, b, c, e, f);\n B._OrtRun = (a, b, c, e, f, h, k, q) => (B._OrtRun = N.wa)(a, b, c, e, f, h, k, q);\n B._OrtEndProfiling = (a) => (B._OrtEndProfiling = N.xa)(a);\n B._JsepOutput = (a, b, c) => (B._JsepOutput = N.ya)(a, b, c);\n B._JsepGetNodeName = (a) => (B._JsepGetNodeName = N.za)(a);\n var Sa = B._pthread_self = () => (Sa = B._pthread_self = N.Aa)(), Ab = B._malloc = (a) => (Ab = B._malloc = N.Ba)(a), oc = B._free = (a) => (oc = B._free = N.Ca)(a);\n B.__emscripten_tls_init = () => (B.__emscripten_tls_init = N.Da)();\n var rc = B.__emscripten_thread_init = (a, b, c, e, f, h) => (rc = B.__emscripten_thread_init = N.Fa)(a, b, c, e, f, h);\n B.__emscripten_thread_crashed = () => (B.__emscripten_thread_crashed = N.Ga)();\n var Hb = (a, b, c, e) => (Hb = N.Ha)(a, b, c, e), Ra = (a) => (Ra = N.Ia)(a), Ya = B.__emscripten_thread_exit = (a) => (Ya = B.__emscripten_thread_exit = N.Ja)(a), vb = B.__emscripten_check_mailbox = () => (vb = B.__emscripten_check_mailbox = N.Ka)(), sc = (a) => (sc = N.La)(a), Va = (a, b) => (Va = N.Ma)(a, b), Eb = () => (Eb = N.Na)(), Wa = (a) => (Wa = N.Oa)(a), Gb = (a) => (Gb = N.Pa)(a), Xa = B.dynCall_ii = (a, b) => (Xa = B.dynCall_ii = N.Ra)(a, b), mc = (a) => (mc = N.Sa)(a), bc = () => (bc = N.Ta)(), lc = (a) => (lc = N.Ua)(a), nc = () => (nc = N.Va)();\n B.___start_em_js = 917678;\n B.___stop_em_js = 917839;\n function uc(a) {\n a = Object.assign({}, a);\n var b = (e) => () => e() >>> 0, c = (e) => (f) => e(f) >>> 0;\n a.__errno_location = b(a.__errno_location);\n a.pthread_self = b(a.pthread_self);\n a.malloc = c(a.malloc);\n a.stackSave = b(a.stackSave);\n a.stackAlloc = c(a.stackAlloc);\n return a;\n }\n B.keepRuntimeAlive = ya;\n B.wasmMemory = l;\n B.stackAlloc = Gb;\n B.stackSave = Eb;\n B.stackRestore = Wa;\n B.UTF8ToString = V;\n B.stringToUTF8 = hb;\n B.lengthBytesUTF8 = fb;\n B.ExitStatus = Ia;\n B.PThread = W;\n var vc;\n S = function wc() {\n vc || xc();\n vc || (S = wc);\n };\n function xc() {\n function a() {\n if (!vc && (vc = true, B.calledRun = true, !P)) {\n H || Ua(va);\n fa(B);\n if (B.onRuntimeInitialized)\n B.onRuntimeInitialized();\n if (!H) {\n if (B.postRun)\n for ("function" == typeof B.postRun && (B.postRun = [B.postRun]); B.postRun.length; ) {\n var b = B.postRun.shift();\n wa.unshift(b);\n }\n Ua(wa);\n }\n }\n }\n if (!(0 < R))\n if (H)\n fa(B), H || Ua(va), startWorker(B);\n else {\n if (B.preRun)\n for ("function" == typeof B.preRun && (B.preRun = [B.preRun]); B.preRun.length; )\n ua.unshift(B.preRun.shift());\n Ua(ua);\n 0 < R || (B.setStatus ? (B.setStatus("Running..."), setTimeout(function() {\n setTimeout(\n function() {\n B.setStatus("");\n },\n 1\n );\n a();\n }, 1)) : a());\n }\n }\n if (B.preInit)\n for ("function" == typeof B.preInit && (B.preInit = [B.preInit]); 0 < B.preInit.length; )\n B.preInit.pop()();\n xc();\n return moduleArg.ready;\n };\n })();\n if (typeof exports === "object" && typeof module === "object")\n module.exports = ortWasmThreaded;\n else if (typeof define === "function" && define["amd"])\n define([], () => ortWasmThreaded);\n }\n });\n\n // web/lib/wasm/binding/ort-wasm-threaded.worker.js\n var require_ort_wasm_threaded_worker = __commonJS({\n "web/lib/wasm/binding/ort-wasm-threaded.worker.js"(exports, module) {\n module.exports = \'"use strict";var Module={};var ENVIRONMENT_IS_NODE=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string";if(ENVIRONMENT_IS_NODE){var nodeWorkerThreads=require("worker_threads");var parentPort=nodeWorkerThreads.parentPort;parentPort.on("message",data=>onmessage({data:data}));var fs=require("fs");Object.assign(global,{self:global,require:require,Module:Module,location:{href:__filename},Worker:nodeWorkerThreads.Worker,importScripts:f=>(0,eval)(fs.readFileSync(f,"utf8")+"//# sourceURL="+f),postMessage:msg=>parentPort.postMessage(msg),performance:global.performance||{now:Date.now}})}var initializedJS=false;function threadPrintErr(){var text=Array.prototype.slice.call(arguments).join(" ");if(ENVIRONMENT_IS_NODE){fs.writeSync(2,text+"\\\\n");return}console.error(text)}function threadAlert(){var text=Array.prototype.slice.call(arguments).join(" ");postMessage({cmd:"alert",text:text,threadId:Module["_pthread_self"]()})}var err=threadPrintErr;self.alert=threadAlert;Module["instantiateWasm"]=(info,receiveInstance)=>{var module=Module["wasmModule"];Module["wasmModule"]=null;var instance=new WebAssembly.Instance(module,info);return receiveInstance(instance)};self.onunhandledrejection=e=>{throw e.reason??e};function handleMessage(e){try{if(e.data.cmd==="load"){let messageQueue=[];self.onmessage=e=>messageQueue.push(e);self.startWorker=instance=>{Module=instance;postMessage({"cmd":"loaded"});for(let msg of messageQueue){handleMessage(msg)}self.onmessage=handleMessage};Module["wasmModule"]=e.data.wasmModule;for(const handler of e.data.handlers){Module[handler]=(...args)=>{postMessage({cmd:"callHandler",handler:handler,args:args})}}Module["wasmMemory"]=e.data.wasmMemory;Module["buffer"]=Module["wasmMemory"].buffer;Module["ENVIRONMENT_IS_PTHREAD"]=true;if(typeof e.data.urlOrBlob=="string"){importScripts(e.data.urlOrBlob)}else{var objectUrl=URL.createObjectURL(e.data.urlOrBlob);importScripts(objectUrl);URL.revokeObjectURL(objectUrl)}ortWasmThreaded(Module)}else if(e.data.cmd==="run"){Module["__emscripten_thread_init"](e.data.pthread_ptr,/*isMainBrowserThread=*/0,/*isMainRuntimeThread=*/0,/*canBlock=*/1);Module["__emscripten_thread_mailbox_await"](e.data.pthread_ptr);Module["establishStackSpace"]();Module["PThread"].receiveObjectTransfer(e.data);Module["PThread"].threadInitTLS();if(!initializedJS){initializedJS=true}try{Module["invokeEntryPoint"](e.data.start_routine,e.data.arg)}catch(ex){if(ex!="unwind"){throw ex}}}else if(e.data.cmd==="cancel"){if(Module["_pthread_self"]()){Module["__emscripten_thread_exit"](-1)}}else if(e.data.target==="setimmediate"){}else if(e.data.cmd==="checkMailbox"){if(initializedJS){Module["checkMailbox"]()}}else if(e.data.cmd){err("worker.js received unknown command "+e.data.cmd);err(e.data)}}catch(ex){if(Module["__emscripten_thread_crashed"]){Module["__emscripten_thread_crashed"]()}throw ex}}self.onmessage=handleMessage;\\n\';\n }\n });\n\n // web/lib/wasm/wasm-common.ts\n var tensorDataTypeStringToEnum, tensorDataTypeEnumToString, getTensorElementSize, tensorTypeToTypedArrayConstructor, logLevelStringToEnum, isGpuBufferSupportedType, dataLocationStringToEnum;\n var init_wasm_common = __esm({\n "web/lib/wasm/wasm-common.ts"() {\n "use strict";\n tensorDataTypeStringToEnum = (type) => {\n switch (type) {\n case "int8":\n return 3 /* int8 */;\n case "uint8":\n return 2 /* uint8 */;\n case "bool":\n return 9 /* bool */;\n case "int16":\n return 5 /* int16 */;\n case "uint16":\n return 4 /* uint16 */;\n case "int32":\n return 6 /* int32 */;\n case "uint32":\n return 12 /* uint32 */;\n case "float16":\n return 10 /* float16 */;\n case "float32":\n return 1 /* float */;\n case "float64":\n return 11 /* double */;\n case "string":\n return 8 /* string */;\n case "int64":\n return 7 /* int64 */;\n case "uint64":\n return 13 /* uint64 */;\n default:\n throw new Error(`unsupported data type: ${type}`);\n }\n };\n tensorDataTypeEnumToString = (typeProto) => {\n switch (typeProto) {\n case 3 /* int8 */:\n return "int8";\n case 2 /* uint8 */:\n return "uint8";\n case 9 /* bool */:\n return "bool";\n case 5 /* int16 */:\n return "int16";\n case 4 /* uint16 */:\n return "uint16";\n case 6 /* int32 */:\n return "int32";\n case 12 /* uint32 */:\n return "uint32";\n case 10 /* float16 */:\n return "float16";\n case 1 /* float */:\n return "float32";\n case 11 /* double */:\n return "float64";\n case 8 /* string */:\n return "string";\n case 7 /* int64 */:\n return "int64";\n case 13 /* uint64 */:\n return "uint64";\n default:\n throw new Error(`unsupported data type: ${typeProto}`);\n }\n };\n getTensorElementSize = (dateType) => [void 0, 4, 1, 1, 2, 2, 4, 8, void 0, 1, 2, 8, 4, 8, void 0, void 0, void 0][dateType];\n tensorTypeToTypedArrayConstructor = (type) => {\n switch (type) {\n case "float16":\n return typeof Float16Array !== "undefined" && Float16Array.from ? Float16Array : Uint16Array;\n case "float32":\n return Float32Array;\n case "uint8":\n return Uint8Array;\n case "int8":\n return Int8Array;\n case "uint16":\n return Uint16Array;\n case "int16":\n return Int16Array;\n case "int32":\n return Int32Array;\n case "bool":\n return Uint8Array;\n case "float64":\n return Float64Array;\n case "uint32":\n return Uint32Array;\n case "int64":\n return BigInt64Array;\n case "uint64":\n return BigUint64Array;\n default:\n throw new Error(`unsupported type: ${type}`);\n }\n };\n logLevelStringToEnum = (logLevel) => {\n switch (logLevel) {\n case "verbose":\n return 0;\n case "info":\n return 1;\n case "warning":\n return 2;\n case "error":\n return 3;\n case "fatal":\n return 4;\n default:\n throw new Error(`unsupported logging level: ${logLevel}`);\n }\n };\n isGpuBufferSupportedType = (type) => type === "float32" || type === "float16" || type === "int32" || type === "int64" || type === "uint32" || type === "uint8" || type === "bool";\n dataLocationStringToEnum = (location) => {\n switch (location) {\n case "none":\n return 0;\n case "cpu":\n return 1;\n case "cpu-pinned":\n return 2;\n case "texture":\n return 3;\n case "gpu-buffer":\n return 4;\n default:\n throw new Error(`unsupported data location: ${location}`);\n }\n };\n }\n });\n\n // common/dist/esm/backend-impl.js\n var init_backend_impl = __esm({\n "common/dist/esm/backend-impl.js"() {\n "use strict";\n }\n });\n\n // common/dist/esm/backend.js\n var init_backend = __esm({\n "common/dist/esm/backend.js"() {\n "use strict";\n init_backend_impl();\n }\n });\n\n // common/dist/esm/version.js\n var version;\n var init_version = __esm({\n "common/dist/esm/version.js"() {\n "use strict";\n version = "1.18.0";\n }\n });\n\n // common/dist/esm/env-impl.js\n var logLevelValue, env;\n var init_env_impl = __esm({\n "common/dist/esm/env-impl.js"() {\n "use strict";\n init_version();\n logLevelValue = "warning";\n env = {\n wasm: {},\n webgl: {},\n webgpu: {},\n versions: { common: version },\n set logLevel(value) {\n if (value === void 0) {\n return;\n }\n if (typeof value !== "string" || ["verbose", "info", "warning", "error", "fatal"].indexOf(value) === -1) {\n throw new Error(`Unsupported logging level: ${value}`);\n }\n logLevelValue = value;\n },\n get logLevel() {\n return logLevelValue;\n }\n };\n Object.defineProperty(env, "logLevel", { enumerable: true });\n }\n });\n\n // common/dist/esm/env.js\n var env2;\n var init_env = __esm({\n "common/dist/esm/env.js"() {\n "use strict";\n init_env_impl();\n env2 = env;\n }\n });\n\n // common/dist/esm/tensor-conversion-impl.js\n var init_tensor_conversion_impl = __esm({\n "common/dist/esm/tensor-conversion-impl.js"() {\n "use strict";\n }\n });\n\n // common/dist/esm/tensor-factory-impl.js\n var init_tensor_factory_impl = __esm({\n "common/dist/esm/tensor-factory-impl.js"() {\n "use strict";\n init_tensor_impl();\n }\n });\n\n // common/dist/esm/tensor-impl-type-mapping.js\n var init_tensor_impl_type_mapping = __esm({\n "common/dist/esm/tensor-impl-type-mapping.js"() {\n "use strict";\n }\n });\n\n // common/dist/esm/tensor-utils-impl.js\n var init_tensor_utils_impl = __esm({\n "common/dist/esm/tensor-utils-impl.js"() {\n "use strict";\n init_tensor_impl();\n }\n });\n\n // common/dist/esm/tensor-impl.js\n var init_tensor_impl = __esm({\n "common/dist/esm/tensor-impl.js"() {\n "use strict";\n init_tensor_conversion_impl();\n init_tensor_factory_impl();\n init_tensor_impl_type_mapping();\n init_tensor_utils_impl();\n }\n });\n\n // common/dist/esm/tensor.js\n var init_tensor = __esm({\n "common/dist/esm/tensor.js"() {\n "use strict";\n init_tensor_impl();\n }\n });\n\n // common/dist/esm/trace.js\n var TRACE, TRACE_FUNC, TRACE_FUNC_BEGIN, TRACE_FUNC_END;\n var init_trace = __esm({\n "common/dist/esm/trace.js"() {\n "use strict";\n init_env_impl();\n TRACE = (deviceType, label) => {\n if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) {\n return;\n }\n console.timeStamp(`${deviceType}::ORT::${label}`);\n };\n TRACE_FUNC = (msg, extraMsg) => {\n const stack = new Error().stack?.split(/\\r\\n|\\r|\\n/g) || [];\n let hasTraceFunc = false;\n for (let i = 0; i < stack.length; i++) {\n if (hasTraceFunc && !stack[i].includes("TRACE_FUNC")) {\n let label = `FUNC_${msg}::${stack[i].trim().split(" ")[1]}`;\n if (extraMsg) {\n label += `::${extraMsg}`;\n }\n TRACE("CPU", label);\n return;\n }\n if (stack[i].includes("TRACE_FUNC")) {\n hasTraceFunc = true;\n }\n }\n };\n TRACE_FUNC_BEGIN = (extraMsg) => {\n if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) {\n return;\n }\n TRACE_FUNC("BEGIN", extraMsg);\n };\n TRACE_FUNC_END = (extraMsg) => {\n if (typeof env.trace === "undefined" ? !env.wasm.trace : !env.trace) {\n return;\n }\n TRACE_FUNC("END", extraMsg);\n };\n }\n });\n\n // common/dist/esm/inference-session-impl.js\n var init_inference_session_impl = __esm({\n "common/dist/esm/inference-session-impl.js"() {\n "use strict";\n init_backend_impl();\n init_tensor();\n init_trace();\n }\n });\n\n // common/dist/esm/inference-session.js\n var init_inference_session = __esm({\n "common/dist/esm/inference-session.js"() {\n "use strict";\n init_inference_session_impl();\n }\n });\n\n // common/dist/esm/tensor-conversion.js\n var init_tensor_conversion = __esm({\n "common/dist/esm/tensor-conversion.js"() {\n "use strict";\n }\n });\n\n // common/dist/esm/tensor-factory.js\n var init_tensor_factory = __esm({\n "common/dist/esm/tensor-factory.js"() {\n "use strict";\n }\n });\n\n // common/dist/esm/onnx-model.js\n var init_onnx_model = __esm({\n "common/dist/esm/onnx-model.js"() {\n "use strict";\n }\n });\n\n // common/dist/esm/onnx-value.js\n var init_onnx_value = __esm({\n "common/dist/esm/onnx-value.js"() {\n "use strict";\n }\n });\n\n // common/dist/esm/training-session-impl.js\n var init_training_session_impl = __esm({\n "common/dist/esm/training-session-impl.js"() {\n "use strict";\n init_backend_impl();\n init_tensor();\n }\n });\n\n // common/dist/esm/training-session.js\n var init_training_session = __esm({\n "common/dist/esm/training-session.js"() {\n "use strict";\n init_training_session_impl();\n }\n });\n\n // common/dist/esm/index.js\n var init_esm = __esm({\n "common/dist/esm/index.js"() {\n "use strict";\n init_backend();\n init_env();\n init_inference_session();\n init_tensor();\n init_tensor_conversion();\n init_tensor_factory();\n init_trace();\n init_onnx_model();\n init_onnx_value();\n init_training_session();\n }\n });\n\n // web/lib/wasm/jsep/log.ts\n var logLevelPrefix, doLog, configLogLevel, debug, configureLogger, LOG, LOG_DEBUG;\n var init_log = __esm({\n "web/lib/wasm/jsep/log.ts"() {\n "use strict";\n init_wasm_common();\n logLevelPrefix = ["V", "I", "W", "E", "F"];\n doLog = (level, message) => {\n console.log(`[${logLevelPrefix[level]},${(/* @__PURE__ */ new Date()).toISOString()}]${message}`);\n };\n configureLogger = ($configLogLevel, $debug) => {\n configLogLevel = $configLogLevel;\n debug = $debug;\n };\n LOG = (logLevel, msg) => {\n const messageLevel = logLevelStringToEnum(logLevel);\n const configLevel = logLevelStringToEnum(configLogLevel);\n if (messageLevel >= configLevel) {\n doLog(messageLevel, typeof msg === "function" ? msg() : msg);\n }\n };\n LOG_DEBUG = (...args) => {\n if (debug) {\n LOG(...args);\n }\n };\n }\n });\n\n // web/lib/wasm/jsep/tensor-view.ts\n var createView;\n var init_tensor_view = __esm({\n "web/lib/wasm/jsep/tensor-view.ts"() {\n "use strict";\n init_wasm_common();\n createView = (dataBuffer, type) => new (tensorTypeToTypedArrayConstructor(type))(dataBuffer);\n }\n });\n\n // web/lib/wasm/jsep/webgpu/types.ts\n var init_types = __esm({\n "web/lib/wasm/jsep/webgpu/types.ts"() {\n "use strict";\n }\n });\n\n // web/lib/wasm/jsep/webgpu/gpu-data-manager.ts\n var bucketFreelist, bucketArr, calcNormalizedBufferSize, calcBucketBufferSize, guid, createNewGpuDataId, downloadGpuData, GpuDataManagerImpl, createGpuDataManager;\n var init_gpu_data_manager = __esm({\n "web/lib/wasm/jsep/webgpu/gpu-data-manager.ts"() {\n "use strict";\n init_log();\n init_types();\n bucketFreelist = /* @__PURE__ */ new Map([\n [64, 250],\n [128, 200],\n [256, 200],\n [512, 200],\n [2048, 230],\n [4096, 200],\n [8192, 50],\n [16384, 50],\n [32768, 50],\n [65536, 50],\n [131072, 50],\n [262144, 50],\n [524288, 50],\n [1048576, 50],\n [2097152, 30],\n [4194304, 20],\n [8388608, 10],\n [12582912, 10],\n [16777216, 10],\n [26214400, 15],\n [33554432, 22],\n [44236800, 2],\n [58982400, 6],\n // we don\'t want to cache the bucket sizes below but not caching them\n // results in some major performance hits for models like sd-turbo.\n [67108864, 6],\n [134217728, 6],\n [167772160, 6]\n ]);\n bucketArr = [];\n calcNormalizedBufferSize = (size) => Math.ceil(size / 16) * 16;\n calcBucketBufferSize = (size) => {\n for (let idx = 0; idx < bucketArr.length; idx++) {\n const sizeForBucket = bucketArr[idx];\n if (size <= sizeForBucket) {\n return sizeForBucket;\n }\n }\n return Math.ceil(size / 16) * 16;\n };\n guid = 1;\n createNewGpuDataId = () => guid++;\n downloadGpuData = async (backend, gpuBuffer, originalSize, getTargetBuffer) => {\n const bufferSize = calcNormalizedBufferSize(originalSize);\n const gpuReadBuffer = backend.device.createBuffer(\n // eslint-disable-next-line no-bitwise\n { size: bufferSize, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ }\n );\n try {\n const commandEncoder = backend.getCommandEncoder();\n backend.endComputePass();\n commandEncoder.copyBufferToBuffer(\n gpuBuffer,\n 0,\n gpuReadBuffer,\n 0,\n bufferSize\n /* size */\n );\n backend.flush();\n await gpuReadBuffer.mapAsync(GPUMapMode.READ);\n const arrayBuffer = gpuReadBuffer.getMappedRange();\n if (getTargetBuffer) {\n const targetBuffer = getTargetBuffer();\n targetBuffer.set(new Uint8Array(arrayBuffer, 0, originalSize));\n return targetBuffer;\n } else {\n return new Uint8Array(arrayBuffer.slice(0, originalSize));\n }\n } finally {\n gpuReadBuffer.destroy();\n }\n };\n GpuDataManagerImpl = class {\n constructor(backend) {\n this.backend = backend;\n this.storageCache = /* @__PURE__ */ new Map();\n this.freeBuffers = /* @__PURE__ */ new Map();\n this.freeUniformBuffers = /* @__PURE__ */ new Map();\n this.buffersForUploadingPending = [];\n this.buffersPending = [];\n this.externalBuffers = /* @__PURE__ */ new Map();\n this.capturedPendingBuffers = /* @__PURE__ */ new Map();\n for (const [key] of bucketFreelist) {\n bucketArr.push(key);\n this.freeBuffers.set(key, []);\n this.freeUniformBuffers.set(key, []);\n }\n }\n upload(id, data) {\n const srcArrayBuffer = data.buffer;\n const srcOffset = data.byteOffset;\n const srcLength = data.byteLength;\n const size = calcNormalizedBufferSize(srcLength);\n const gpuDataCache = this.storageCache.get(id);\n if (!gpuDataCache) {\n throw new Error("gpu data for uploading does not exist");\n }\n if (gpuDataCache.originalSize !== srcLength) {\n throw new Error(`inconsistent data size. gpu data size=${gpuDataCache.originalSize}, data size=${srcLength}`);\n }\n const gpuBufferForUploading = this.backend.device.createBuffer(\n // eslint-disable-next-line no-bitwise\n { mappedAtCreation: true, size, usage: GPUBufferUsage.MAP_WRITE | GPUBufferUsage.COPY_SRC }\n );\n const arrayBuffer = gpuBufferForUploading.getMappedRange();\n new Uint8Array(arrayBuffer).set(new Uint8Array(srcArrayBuffer, srcOffset, srcLength));\n gpuBufferForUploading.unmap();\n const commandEncoder = this.backend.getCommandEncoder();\n this.backend.endComputePass();\n commandEncoder.copyBufferToBuffer(gpuBufferForUploading, 0, gpuDataCache.gpuData.buffer, 0, size);\n LOG_DEBUG("verbose", () => `[WebGPU] GpuDataManager.upload(id=${id})`);\n this.buffersForUploadingPending.push(gpuBufferForUploading);\n }\n memcpy(sourceId, destinationId) {\n const sourceGpuDataCache = this.storageCache.get(sourceId);\n if (!sourceGpuDataCache) {\n throw new Error("source gpu data for memcpy does not exist");\n }\n const destinationGpuDataCache = this.storageCache.get(destinationId);\n if (!destinationGpuDataCache) {\n throw new Error("destination gpu data for memcpy does not exist");\n }\n if (sourceGpuDataCache.originalSize !== destinationGpuDataCache.originalSize) {\n throw new Error("inconsistent source and destination gpu data size");\n }\n const size = calcNormalizedBufferSize(sourceGpuDataCache.originalSize);\n const commandEncoder = this.backend.getCommandEncoder();\n this.backend.endComputePass();\n commandEncoder.copyBufferToBuffer(\n sourceGpuDataCache.gpuData.buffer,\n 0,\n destinationGpuDataCache.gpuData.buffer,\n 0,\n size\n );\n }\n registerExternalBuffer(buffer, originalSize, previousBuffer) {\n let id;\n if (previousBuffer) {\n id = this.externalBuffers.get(previousBuffer);\n if (id === void 0) {\n throw new Error("previous buffer is not registered");\n }\n if (buffer === previousBuffer) {\n LOG_DEBUG(\n "verbose",\n () => `[WebGPU] GpuDataManager.registerExternalBuffer(size=${originalSize}) => id=${id}, buffer is the same, skip.`\n );\n return id;\n } else if (this.backend.capturedCommandList.has(this.backend.currentSessionId)) {\n throw new Error(`Registering a different external buffer under graph capture mode is not supported yet.\n Please use the previous external buffer!`);\n }\n this.externalBuffers.delete(previousBuffer);\n } else {\n id = createNewGpuDataId();\n }\n this.storageCache.set(id, { gpuData: { id, type: 0 /* default */, buffer }, originalSize });\n this.externalBuffers.set(buffer, id);\n LOG_DEBUG(\n "verbose",\n () => `[WebGPU] GpuDataManager.registerExternalBuffer(size=${originalSize}) => id=${id}, registered.`\n );\n return id;\n }\n unregisterExternalBuffer(buffer) {\n const id = this.externalBuffers.get(buffer);\n if (id !== void 0) {\n this.storageCache.delete(id);\n this.externalBuffers.delete(buffer);\n LOG_DEBUG("verbose", () => `[WebGPU] GpuDataManager.unregisterExternalBuffer() => id=${id}`);\n }\n }\n // eslint-disable-next-line no-bitwise\n create(size, usage = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST) {\n const bufferSize = calcBucketBufferSize(size);\n let gpuBuffer;\n const isStorage = (usage & GPUBufferUsage.STORAGE) === GPUBufferUsage.STORAGE;\n const isUniform = (usage & GPUBufferUsage.UNIFORM) === GPUBufferUsage.UNIFORM;\n if (isStorage || isUniform) {\n const freeBuffers = isStorage ? this.freeBuffers : this.freeUniformBuffers;\n const buffers = freeBuffers.get(bufferSize);\n if (!buffers) {\n gpuBuffer = this.backend.device.createBuffer({ size: bufferSize, usage });\n } else {\n if (buffers.length > 0) {\n gpuBuffer = buffers.pop();\n } else {\n gpuBuffer = this.backend.device.createBuffer({ size: bufferSize, usage });\n }\n }\n } else {\n gpuBuffer = this.backend.device.createBuffer({ size: bufferSize, usage });\n }\n const gpuData = { id: createNewGpuDataId(), type: 0 /* default */, buffer: gpuBuffer };\n this.storageCache.set(gpuData.id, { gpuData, originalSize: size });\n LOG_DEBUG("verbose", () => `[WebGPU] GpuDataManager.create(size=${size}) => id=${gpuData.id}`);\n return gpuData;\n }\n get(id) {\n return this.storageCache.get(id)?.gpuData;\n }\n release(id) {\n const cachedData = this.storageCache.get(id);\n if (!cachedData) {\n throw new Error("releasing data does not exist");\n }\n LOG_DEBUG("verbose", () => `[WebGPU] GpuDataManager.release(id=${id}), gpuDataId=${cachedData.gpuData.id}`);\n this.storageCache.delete(id);\n this.buffersPending.push(cachedData.gpuData.buffer);\n return cachedData.originalSize;\n }\n async download(id, getTargetBuffer) {\n const cachedData = this.storageCache.get(id);\n if (!cachedData) {\n throw new Error("data does not exist");\n }\n await downloadGpuData(this.backend, cachedData.gpuData.buffer, cachedData.originalSize, getTargetBuffer);\n }\n refreshPendingBuffers() {\n for (const buffer of this.buffersForUploadingPending) {\n buffer.destroy();\n }\n this.buffersForUploadingPending = [];\n if (this.buffersPending.length === 0) {\n return;\n }\n if (this.backend.sessionStatus === "default") {\n for (const buffer of this.buffersPending) {\n const maxInFreeList = bucketFreelist.get(buffer.size);\n if ((buffer.usage & GPUBufferUsage.STORAGE) === GPUBufferUsage.STORAGE) {\n const freelist = this.freeBuffers.get(buffer.size) || [];\n if (maxInFreeList === void 0 || freelist.length >= maxInFreeList) {\n buffer.destroy();\n } else {\n freelist.push(buffer);\n }\n } else if ((buffer.usage & GPUBufferUsage.UNIFORM) === GPUBufferUsage.UNIFORM) {\n const freelist = this.freeUniformBuffers.get(buffer.size) || [];\n if (maxInFreeList === void 0 || freelist.length >= maxInFreeList) {\n buffer.destroy();\n } else {\n freelist.push(buffer);\n }\n } else {\n buffer.destroy();\n }\n }\n this.buffersPending = [];\n } else {\n let capturedBuffers = this.capturedPendingBuffers.get(this.backend.currentSessionId);\n if (!capturedBuffers) {\n capturedBuffers = [];\n this.capturedPendingBuffers.set(this.backend.currentSessionId, capturedBuffers);\n }\n for (const buffer of this.buffersPending) {\n capturedBuffers.push(buffer);\n }\n this.buffersPending = [];\n }\n }\n dispose() {\n this.freeBuffers.forEach((buffers) => {\n buffers.forEach((buffer) => {\n buffer.destroy();\n });\n });\n this.freeUniformBuffers.forEach((buffers) => {\n buffers.forEach((buffer) => {\n buffer.destroy();\n });\n });\n this.storageCache.forEach((storage) => {\n storage.gpuData.buffer.destroy();\n });\n this.capturedPendingBuffers.forEach((buffers) => {\n buffers.forEach((buffer) => {\n buffer.destroy();\n });\n });\n this.storageCache = /* @__PURE__ */ new Map();\n this.freeBuffers = /* @__PURE__ */ new Map();\n this.freeUniformBuffers = /* @__PURE__ */ new Map();\n this.capturedPendingBuffers = /* @__PURE__ */ new Map();\n }\n onReleaseSession(sessionId) {\n const pendingBuffers = this.capturedPendingBuffers.get(sessionId);\n if (pendingBuffers) {\n pendingBuffers.forEach((buffer) => {\n buffer.destroy();\n });\n this.capturedPendingBuffers.delete(sessionId);\n }\n }\n };\n createGpuDataManager = (...args) => new GpuDataManagerImpl(...args);\n }\n });\n\n // web/lib/wasm/jsep/webgpu/attribute-with-cache-key.ts\n var AttributeWithCacheKeyImpl, createAttributeWithCacheKey;\n var init_attribute_with_cache_key = __esm({\n "web/lib/wasm/jsep/webgpu/attribute-with-cache-key.ts"() {\n "use strict";\n AttributeWithCacheKeyImpl = class {\n constructor(attribute) {\n Object.assign(this, attribute);\n }\n get cacheKey() {\n if (!this.key) {\n this.key = Object.getOwnPropertyNames(this).sort().map((name) => `${this[name]}`).join(";");\n }\n return this.key;\n }\n };\n createAttributeWithCacheKey = (attribute) => new AttributeWithCacheKeyImpl(attribute);\n }\n });\n\n // web/lib/wasm/jsep/util.ts\n var MatMulUtil, BroadcastUtil, ShapeUtil, PoolConvUtil, GemmUtil, MIN_CLIP, MAX_CLIP;\n var init_util = __esm({\n "web/lib/wasm/jsep/util.ts"() {\n "use strict";\n MatMulUtil = class {\n /**\n * Calculate the expected shape when matrix multiplication\n * @param a The shape of tensor A. Should be a tuple of 2 positive integers\n * @param b The shape of tensor B. Should be a tuple of 2 positive integers\n * @returns The expected shape of the result, or undefined if N/A\n */\n static calcMatMulShape(a, b) {\n return a[1] !== b[0] ? void 0 : [a[0], b[1]];\n }\n };\n BroadcastUtil = class {\n /**\n * Calculate the expected shape when broadcasting 2 tensors\n * @param a The shape of tensor A. Should be an array of positive integers\n * @param b The shape of tensor B. Should be an array of positive integers\n * @param isMatMul Whether the operation is MatMul\n * @returns The expected shape of the result, or undefined if N/A\n */\n static calcShape(adims, bdims, isMatMul = false) {\n const arank = adims.length;\n const brank = bdims.length;\n if (arank === 0) {\n return bdims;\n }\n if (brank === 0) {\n return adims;\n }\n const crank = Math.max(adims.length, bdims.length);\n const cdims = new Array(crank);\n if (isMatMul) {\n if (arank < 2 || brank < 2) {\n return void 0;\n }\n const cShapeMatMul = MatMulUtil.calcMatMulShape([adims[arank - 2], adims[arank - 1]], [bdims[brank - 2], bdims[brank - 1]]);\n if (cShapeMatMul === void 0) {\n return void 0;\n }\n [cdims[crank - 2], cdims[crank - 1]] = cShapeMatMul;\n }\n for (let i = isMatMul ? 3 : 1; i <= crank; i++) {\n const aLen = arank - i < 0 ? 1 : adims[arank - i];\n const bLen = brank - i < 0 ? 1 : bdims[brank - i];\n if (aLen !== bLen && aLen > 1 && bLen > 1) {\n return void 0;\n }\n const max = Math.max(aLen, bLen);\n if (aLen && bLen) {\n cdims[crank - i] = Math.max(aLen, bLen);\n } else {\n if (max > 1) {\n return void 0;\n }\n cdims[crank - i] = 0;\n }\n }\n return cdims;\n }\n /**\n * Determine if a shape is unidirectional broadcastable to another shape\n * @param shape The input shape\n * @param finalShape The desired shape after broadcasting\n */\n static isValidBroadcast(shape, finalShape) {\n const inputRank = shape.length;\n const finalRank = finalShape.length;\n if (inputRank > finalRank) {\n return false;\n }\n for (let i = 1; i <= inputRank; i++) {\n if (shape[inputRank - i] !== 1 && shape[inputRank - i] !== finalShape[finalRank - i]) {\n return false;\n }\n }\n return true;\n }\n };\n ShapeUtil = class _ShapeUtil {\n /**\n * calculate the size (number of elements)\n */\n static size(dims) {\n return _ShapeUtil.getSizeFromDimensionRange(dims, 0, dims.length);\n }\n /**\n * convert dims corresponding to type change to pack. ex. uint8 data to uint32\n */\n static convertShape(dims, size = 4) {\n const rank = dims.length;\n if (rank === 0) {\n return [];\n }\n const newDims = new Array(rank);\n let i = rank - 1;\n while (i >= 0) {\n if (dims[i] % size === 0) {\n newDims[i] = dims[i] / size;\n break;\n }\n if (size % dims[i] !== 0) {\n throw new Error("cannot convert shape");\n }\n newDims[i] = 1;\n size /= dims[i];\n i--;\n }\n for (i--; i >= 0; i--) {\n newDims[i] = dims[i];\n }\n return newDims;\n }\n /**\n * calculate the size (number of elements) from the given axis (inclusive)\n */\n static sizeFromDimension(dims, axis) {\n if (axis < 0 || axis > dims.length) {\n throw new Error(`invalid dimension of ${axis} for sizeFromDimension as Tensor has ${dims.length} dimensions.`);\n }\n return _ShapeUtil.getSizeFromDimensionRange(dims, axis, dims.length);\n }\n /**\n * calculate the size (number of elements) to the given axis (exclusive)\n */\n static sizeToDimension(dims, axis) {\n if (axis < 0 || axis > dims.length) {\n throw new Error(`invalid dimension of ${axis} for sizeToDimension as Tensor has ${dims.length} dimensions.`);\n }\n return _ShapeUtil.getSizeFromDimensionRange(dims, 0, axis);\n }\n /**\n * calculate the size (number of elements) from and to the given axis [start, end)\n */\n static getSizeFromDimensionRange(dims, start, end) {\n let size = 1;\n for (let i = start; i < end; i++) {\n if (dims[i] < 0) {\n throw new Error(\n // eslint-disable-next-line max-len\n "cannot get valid size from specified dimension range. Most likely the range contains negative values in them."\n );\n }\n size *= dims[i];\n }\n return size;\n }\n static computeStrides(dims) {\n const rank = dims.length;\n if (rank === 0) {\n return [];\n } else if (rank === 1) {\n return [1];\n }\n const strides = new Array(rank);\n strides[rank - 1] = 1;\n strides[rank - 2] = dims[rank - 1];\n for (let i = rank - 3; i >= 0; --i) {\n strides[i] = strides[i + 1] * dims[i + 1];\n }\n return strides;\n }\n /**\n * normailze axis of range [-r, r) into [0, r).\n */\n static normalizeAxis(axis, tensorRank) {\n if (axis < -tensorRank && axis >= tensorRank) {\n throw new Error("unsupported axis for this operation.");\n }\n return axis < 0 ? axis + tensorRank : axis;\n }\n static normalizeAxes(axes, tensorRank) {\n return axes.map((x) => this.normalizeAxis(x, tensorRank ?? axes.length));\n }\n /**\n * Sorts a given array based on the indices in the Perm array\n * Used in Transpose\n * @param a Array to be sorted such as dims or strides\n * @param perm Perm given; if null a will be reversed\n */\n static sortBasedOnPerm(a, perm) {\n if (perm) {\n return perm.map((v) => a[v]);\n } else {\n return a.slice().reverse();\n }\n }\n /**\n * Pads a given shape according to the padding values\n * @param dims shape of the Tensor to be padded\n * @param pad pad values\n */\n static padShape(dims, pad2) {\n const rank = dims.length;\n return dims.map((v, i) => v + pad2[i] + pad2[i + rank]);\n }\n /**\n * Determines if the two shapes are identical\n * @param shape1\n * @param shape2\n */\n static areEqual(shape1, shape2) {\n if (shape1.length !== shape2.length) {\n return false;\n }\n return shape1.every((v, i) => v === shape2[i]);\n }\n };\n PoolConvUtil = class _PoolConvUtil {\n /**\n * Adjust the kernel, strides, pads to correct rank. Set to default value if not present\n * @param isGlobalOperator If true, perform global pooling.\n * @param inputDims The input tensor dimension.\n * @param kernelShape The size of the kernel along each axis.\n * @param strides Stride along each axis.\n * @param dilations Dilation along each axis.\n * @param pads Padding for the beginning and ending along each axis.\n */\n static adjustPoolAttributes(isGlobalOperator, inputDims, kernelShape, strides, dilations, pads) {\n if (!isGlobalOperator && kernelShape.length !== inputDims.length - 2) {\n throw new Error("length of specified kernel shapes should be 2 less than length of input dimensions");\n }\n if (isGlobalOperator) {\n for (let dim = 0; dim < inputDims.length - 2; dim++) {\n if (dim >= kernelShape.length) {\n kernelShape.push(inputDims[dim + 2]);\n } else {\n kernelShape[dim] = inputDims[dim + 2];\n }\n }\n }\n for (let dim = 0; dim < kernelShape.length; dim++) {\n if (dim < strides.length) {\n if (strides[dim] < 0) {\n throw new Error("strides should be greater than or equal to 1");\n }\n } else {\n strides.push(1);\n }\n }\n for (let dim = 0; dim < kernelShape.length; dim++) {\n if (dim < dilations.length) {\n if (dilations[dim] < 0) {\n throw new Error("dilations should be greater than or equal to 1");\n }\n } else {\n dilations.push(1);\n }\n }\n for (let dim = 0; dim < kernelShape.length * 2; dim++) {\n if (dim < pads.length) {\n if (pads[dim] < 0) {\n throw new Error("pad should be greater than or equal to 1");\n }\n } else {\n pads.push(0);\n }\n }\n for (let dim = 0; dim < kernelShape.length; dim++) {\n if (kernelShape[dim] <= 0) {\n throw new Error("kernel shapes need to be greater than 0");\n }\n if (pads[dim] >= kernelShape[dim] || pads[dim + kernelShape.length] >= kernelShape[dim]) {\n throw new Error("pads should be smaller than kernel");\n }\n }\n }\n // adjust pad values based on \'autoPad\' attribute\n static adjustPadsBasedOnAutoPad(inputDims, strides, dilations, kernelShape, pads, isChannelLast, autoPad) {\n if (!autoPad) {\n return;\n }\n if (pads.length !== 2 * (inputDims.length - 2)) {\n throw new Error("length of pads should be twice the length of data dimensions");\n }\n if (strides.length !== inputDims.length - 2) {\n throw new Error("length of strides should be the length of data dimensions");\n }\n if (kernelShape.length !== inputDims.length - 2) {\n throw new Error("length of kernel shapes should be the length of data dimensions");\n }\n for (let dim = 0; dim < inputDims.length - 2; dim++) {\n _PoolConvUtil.adjustPadAndReturnShape(\n inputDims[dim + (isChannelLast ? 1 : 2)],\n strides[dim],\n dilations[dim],\n kernelShape[dim],\n pads,\n dim,\n dim + inputDims.length - 2,\n autoPad\n );\n }\n }\n /**\n * Calculate the output shape for Pool ops based on input attributes. (Should be used only for Pool ops)\n * @param isGlobalOperator If true, perform global pooling.\n * @param inputDims The input tensor dimension. (inputs[0].dims)\n * @param strides Stride along each axis.\n * @param dilations Dilation along each axis.\n * @param kernelShape The size of the kernel along each axis.\n * @param pads Padding for the beginning and ending along each axis.\n * @param autoPad DEPRECATED attribute supported for legacy models. Specifies how to implicitly calculate pads in each\n * dimension. Can take values NOTSET, SAME_UPPER, SAME_LOWER, or VALID.\n */\n static computePoolOutputShape(isGlobalOperator, inputDims, strides, dilations, kernelShape, pads, autoPad) {\n if (inputDims.length <= 0) {\n throw new Error("input shape must be of size greater than 0");\n }\n const outputDims = [inputDims[0], inputDims[1]];\n _PoolConvUtil.computeShapeHelper(\n isGlobalOperator,\n inputDims,\n outputDims,\n strides,\n dilations,\n kernelShape,\n pads,\n autoPad\n );\n return outputDims;\n }\n /**\n * Calculate the output shape for Conv op based on input attributes. (Should be used only for Conv op)\n * @param inputDims The input tensor dimension. (inputs[0].dims)\n * @param filterDims The filter tensor dimension. (inputs[1].dims)\n * @param strides Stride along each axis.\n * @param kernelShape The size of the kernel along each axis.\n * @param pads Padding for the beginning and ending along each axis.\n * @param autoPad DEPRECATED attribute supported for legacy models. Specifies how to implicitly calculate pads in each\n * dimension. Can take values NOTSET, SAME_UPPER, SAME_LOWER, or VALID.\n */\n static computeConvOutputShape(inputDims, filterDims, strides, dilations, kernelShape, pads, autoPad) {\n if (inputDims.length <= 0 || filterDims.length <= 0) {\n throw new Error("invalid input tensor dims or invalid filter tensor dims");\n }\n const outputDims = [inputDims[0], filterDims[0]];\n _PoolConvUtil.computeShapeHelper(false, inputDims, outputDims, strides, dilations, kernelShape, pads, autoPad);\n return outputDims;\n }\n // will compute output shapes for data dimensions ONLY (i.e.) no batch size and channels\n // called by computePoolOutputShape() and computeConvOutputShape()\n // adjust pads based on \'autoPad\' attribute prior to shape computation\n static computeShapeHelper(isGlobalOperator, inputDims, outputDims, strides, dilations, kernelShape, pads, autoPad) {\n if (isGlobalOperator) {\n for (let dim = 0; dim < inputDims.length - 2; dim++) {\n outputDims.push(1);\n }\n } else {\n for (let dim = 0; dim < inputDims.length - 2; dim++) {\n outputDims.push(_PoolConvUtil.adjustPadAndReturnShape(\n inputDims[dim + 2],\n strides[dim],\n dilations[dim],\n kernelShape[dim],\n pads,\n dim,\n dim + inputDims.length - 2,\n autoPad\n ));\n }\n }\n }\n // helper for computeShapeHelper() and adjustPadsBasedOnAutoPad()\n // adjusts pad value for given \'autoPad\' string and computes output shape along a particular dimension\n static adjustPadAndReturnShape(inSize, stride, dilation, kernel, pads, padHeadIndex, padTailIndex, autoPad) {\n const dkernel = dilation * (kernel - 1) + 1;\n if (autoPad && autoPad !== "NOTSET") {\n switch (autoPad) {\n case "VALID":\n pads[padHeadIndex] = 0;\n pads[padTailIndex] = 0;\n return Math.floor((inSize - dkernel) / stride + 1);\n case "SAME_LOWER":\n case "SAME_UPPER":\n if (dilation !== 1) {\n throw new Error("Dilation not supported for SAME_UPPER or SAME_LOWER");\n } else {\n const legacyTargetSize = (inSize + stride - 1) / stride;\n const padNeeded = (legacyTargetSize - 1) * stride + kernel - inSize;\n pads[padHeadIndex] = autoPad === "SAME_LOWER" ? Math.floor((padNeeded + 1) / 2) : Math.floor(padNeeded / 2);\n pads[padTailIndex] = padNeeded - pads[padHeadIndex];\n return Math.floor((inSize + padNeeded - kernel) / stride + 1);\n }\n default:\n throw new Error("Unsupported AutoPad type");\n }\n } else {\n return Math.floor((inSize + pads[padHeadIndex] + pads[padTailIndex] - dkernel) / stride + 1);\n }\n }\n };\n GemmUtil = class {\n // will make sure input shapes are compatible for this op\n // and return back the shape of the output in the form of a tuple\n // will throw exception if the input shapes are not compatible\n static getShapeOfGemmResult(leftShape, transLeft, rightShape, transRight, biasShape) {\n if (leftShape.length !== 2 || rightShape.length !== 2) {\n throw new Error("shape need to be of size 2");\n }\n let M;\n let K;\n let N;\n if (transLeft) {\n M = leftShape[1];\n K = leftShape[0];\n } else {\n M = leftShape[0];\n K = leftShape[1];\n }\n let kDim = -1;\n if (transRight) {\n N = rightShape[0];\n kDim = 1;\n } else {\n N = rightShape[1];\n kDim = 0;\n }\n if (rightShape[kDim] !== K) {\n throw new Error("dimension mismatch");\n }\n if (M <= 0 || N <= 0 || K <= 0) {\n throw new Error("invalid shape specified");\n }\n if (biasShape && !BroadcastUtil.isValidBroadcast(biasShape, [M, N])) {\n throw new Error("gemm: invalid bias shape for broadcast");\n }\n return [M, N, K];\n }\n };\n MIN_CLIP = -34028234663852886e22;\n MAX_CLIP = 34028234663852886e22;\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/common.ts\n var WORKGROUP_SIZE, getWgslMappedType, tensorTypeToWsglStorageType, tensorTypeToWsglValueType, createTensorShapeVariables, getMaxComponents, fillVector, castToF32, sumVector, getElementAt, createIndicesHelper, inputVariable, outputVariable, internalVariable, ShaderHelperImpl, createShaderHelper, getBroadcastDims;\n var init_common = __esm({\n "web/lib/wasm/jsep/webgpu/ops/common.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n WORKGROUP_SIZE = 64;\n getWgslMappedType = (type, components) => {\n if (components === 3) {\n throw new Error("vec3 has same alignment as vec4, use vec4 instead");\n }\n switch (type) {\n case 10 /* float16 */:\n return components > 1 ? `vec${components}` : "f16";\n case 1 /* float */:\n return components > 1 ? `vec${components}` : "f32";\n case 6 /* int32 */:\n return components > 1 ? `vec${components}` : "i32";\n case 12 /* uint32 */:\n return components > 1 ? `vec${components}` : "u32";\n case 7 /* int64 */:\n if (components > 1) {\n throw new Error("currently not supported vecX of uint64 yet");\n }\n return ["vec2", "i32"];\n case 13 /* uint64 */:\n if (components > 1) {\n throw new Error("currently not supported vecX of uint64 yet");\n }\n return ["vec2", "u32"];\n case 9 /* bool */:\n if (components !== 4) {\n throw new Error("bool must be vec4");\n }\n return ["u32", "vec4"];\n default:\n throw new Error(`Unknown data type: ${type}`);\n }\n };\n tensorTypeToWsglStorageType = (type, components = 1) => {\n const mappedType = getWgslMappedType(type, components);\n return typeof mappedType === "string" ? mappedType : mappedType[0];\n };\n tensorTypeToWsglValueType = (type, components = 1) => {\n const mappedType = getWgslMappedType(type, components);\n return typeof mappedType === "string" ? mappedType : mappedType[1];\n };\n createTensorShapeVariables = (...dims) => {\n const programUniforms = [];\n dims.forEach((dim) => {\n if (dim.length !== 0) {\n programUniforms.push(\n { type: 12 /* uint32 */, data: dim },\n { type: 12 /* uint32 */, data: ShapeUtil.computeStrides(dim) }\n );\n }\n });\n return programUniforms;\n };\n getMaxComponents = (size) => {\n if (size % 4 === 0) {\n return 4;\n } else if (size % 2 === 0) {\n return 2;\n }\n return 1;\n };\n fillVector = (dataType = "f32", components, value = "0") => {\n if (!components || components === 1) {\n return `${dataType}(${value})`;\n }\n return `vec${components}<${dataType}>(${value})`;\n };\n castToF32 = (dataType, components, value) => {\n if (dataType === "f32") {\n return value;\n }\n if (components === 1) {\n return `f32(${value})`;\n }\n return `vec${components}(${value})`;\n };\n sumVector = (name, components) => {\n if (components === 4) {\n return `(${name}.x + ${name}.y + ${name}.z + ${name}.w)`;\n } else if (components === 2) {\n return `(${name}.x + ${name}.y)`;\n } else if (components === 3) {\n return `(${name}.x + ${name}.y + ${name}.z)`;\n }\n return name;\n };\n getElementAt = (name, index, length, type) => {\n if (name.startsWith("uniforms.") && length > 4) {\n if (typeof index === "string") {\n if (type === "f16") {\n return `${name}[(${index}) / 8][(${index}) % 8 / 4][(${index}) % 8 % 4]`;\n } else {\n return `${name}[(${index}) / 4][(${index}) % 4]`;\n }\n } else {\n if (type === "f16") {\n return `${name}[${Math.floor(index / 8)}][${Math.floor(index % 8 / 4)}][${index % 8 % 4}]`;\n } else {\n return `${name}[${Math.floor(index / 4)}][${index % 4}]`;\n }\n }\n } else {\n return length > 1 ? `${name}[${index}]` : name;\n }\n };\n createIndicesHelper = (name, tensorType, shapeOrRank, usage, components) => {\n const useUniform = typeof shapeOrRank === "number";\n const rank = useUniform ? shapeOrRank : shapeOrRank.length;\n const rankIdentity = [...new Array(rank).keys()];\n const indicesType = rank < 2 ? "u32" : rank <= 4 ? `vec${rank}` : `array`;\n const mappedType = getWgslMappedType(tensorType, components);\n const valueType = typeof mappedType === "string" ? mappedType : mappedType[1];\n const storageType = typeof mappedType === "string" ? mappedType : mappedType[0];\n const type = { indices: indicesType, value: valueType, storage: storageType, tensor: tensorType };\n const normalizeDim = (dim) => typeof dim === "string" ? dim : `${dim}u`;\n const implementationUsed = {\n offsetToIndices: false,\n indicesToOffset: false,\n broadcastedIndicesToOffset: false,\n set: false,\n setByIndices: false,\n get: false,\n getByIndices: false\n };\n const uniformPrefix = useUniform ? "uniforms." : "";\n const shape = `${uniformPrefix}${name}_shape`;\n const strides = `${uniformPrefix}${name}_strides`;\n let o2iSnippet = "";\n for (let i = 0; i < rank - 1; i++) {\n o2iSnippet += `\n let dim${i} = current / ${getElementAt(strides, i, rank)};\n let rest${i} = current % ${getElementAt(strides, i, rank)};\n indices[${i}] = dim${i};\n current = rest${i};\n `;\n }\n o2iSnippet += `indices[${rank - 1}] = current;`;\n const offsetToIndicesImplementation = rank < 2 ? "" : `\n fn o2i_${name}(offset: u32) -> ${type.indices} {\n var indices: ${type.indices};\n var current = offset;\n ${o2iSnippet}\n return indices;\n }`;\n const offsetToIndices = (varOffset) => {\n implementationUsed.offsetToIndices = true;\n return rank < 2 ? varOffset : `o2i_${name}(${varOffset})`;\n };\n const offsets = [];\n if (rank >= 2) {\n for (let i = rank - 1; i >= 0; i--) {\n offsets.push(`${getElementAt(strides, i, rank)} * (indices[${i}])`);\n }\n }\n const indicesToOffsetImplementation = rank < 2 ? "" : `\n fn i2o_${name}(indices: ${type.indices}) -> u32 {\n return ${offsets.join("+")};\n }`;\n const indicesToOffset = (varIndices) => {\n implementationUsed.indicesToOffset = true;\n return rank < 2 ? varIndices : `i2o_${name}(${varIndices})`;\n };\n const indices = (...init2) => rank === 0 ? "0u" : `${type.indices}(${init2.map(normalizeDim).join(",")})`;\n const indicesGet = (varIndices, idx) => {\n if (rank < 2) {\n return `${varIndices}`;\n } else {\n return `${getElementAt(varIndices, idx, rank)}`;\n }\n };\n const indicesSet = (varIndices, idx, value) => {\n if (rank < 2) {\n return `${varIndices}=${value};`;\n } else {\n return `${getElementAt(varIndices, idx, rank)}=${value};`;\n }\n };\n const broadcastedIndicesToOffsetImplementation = {};\n const broadcastedIndicesToOffset = (varIndices, output) => {\n implementationUsed.broadcastedIndicesToOffset = true;\n const implKey = `${output.name}broadcastedIndicesTo${name}Offset`;\n if (implKey in broadcastedIndicesToOffsetImplementation) {\n return `${implKey}(${varIndices})`;\n }\n const offsets2 = [];\n for (let i = rank - 1; i >= 0; i--) {\n const idx = output.indicesGet("outputIndices", i + output.rank - rank);\n offsets2.push(`${indicesGet(strides, i)} * (${idx} % ${indicesGet(shape, i)})`);\n }\n broadcastedIndicesToOffsetImplementation[implKey] = `fn ${implKey}(outputIndices: ${output.type.indices}) -> u32 {\n return ${offsets2.length > 0 ? offsets2.join("+") : "0u"};\n }`;\n return `${implKey}(${varIndices})`;\n };\n const setByOffset = (offset, value) => (() => {\n if (type.storage === type.value) {\n return `${name}[${offset}]=${value};`;\n } else if (type.storage === "vec2" && type.value === "i32") {\n return `${name}[${offset}]=vec2(u32(${value}), select(0u, 0xFFFFFFFFu, ${value} < 0));`;\n } else if (type.storage === "vec2" && type.value === "u32") {\n return `${name}[${offset}]=vec2(u32(${value}), 0u);`;\n } else if (type.storage === "u32" && type.value === "vec4") {\n return `${name}[${offset}]=dot(vec4(0x1, 0x100, 0x10000, 0x1000000), vec4(${value}));`;\n } else {\n throw new Error(`not supported combination of storage type ${type.storage} and value type ${type.value} yet`);\n }\n })();\n const getByOffset = (offset) => (() => {\n if (type.storage === type.value) {\n return `${name}[${offset}]`;\n } else if (type.storage === "vec2" && type.value === "i32") {\n return `i32(${name}[${offset}].x)`;\n } else if (type.storage === "vec2" && type.value === "u32") {\n return `u32(${name}[${offset}].x)`;\n } else if (type.storage === "u32" && type.value === "vec4") {\n return `vec4(bool(${name}[${offset}] & 0xFFu), bool(${name}[${offset}] & 0xFF00u), bool(${name}[${offset}] & 0xFF0000u), bool(${name}[${offset}] & 0xFF000000u))`;\n } else {\n throw new Error(`not supported combination of storage type ${type.storage} and value type ${type.value} yet`);\n }\n })();\n const getByIndicesImplementation = rank < 2 ? "" : `\n fn get_${name}ByIndices(indices: ${type.indices}) -> ${valueType} {\n return ${getByOffset(`i2o_${name}(indices)`)};\n }`;\n const getImplementation = rank < 2 ? "" : (() => {\n const functionParams = rankIdentity.map((i) => `d${i}: u32`).join(", ");\n const dimsParams = rankIdentity.map((i) => `d${i}`).join(", ");\n return `\n fn get_${name}(${functionParams}) -> ${valueType} {\n return get_${name}ByIndices(${indices(dimsParams)});\n }`;\n })();\n const get = (...indices2) => {\n if (indices2.length !== rank) {\n throw new Error(`indices length must be ${rank}`);\n }\n const normalizedIndices = indices2.map(normalizeDim).join(",");\n if (rank === 0) {\n return getByOffset("0u");\n } else if (rank === 1) {\n return getByOffset(normalizedIndices[0]);\n } else {\n implementationUsed.get = true;\n implementationUsed.getByIndices = true;\n implementationUsed.indicesToOffset = true;\n return `get_${name}(${normalizedIndices})`;\n }\n };\n const getByIndices = (varIndices) => {\n if (rank < 2) {\n return getByOffset(varIndices);\n } else {\n implementationUsed.getByIndices = true;\n implementationUsed.indicesToOffset = true;\n return `get_${name}ByIndices(${varIndices})`;\n }\n };\n const setByIndicesImplementation = rank < 2 ? "" : `\n fn set_${name}ByIndices(indices: ${type.indices}, value: ${valueType}) {\n ${setByOffset(`i2o_${name}(indices)`, "value")}\n }`;\n const setImplementation = rank < 2 ? "" : (() => {\n const functionParams = rankIdentity.map((i) => `d${i}: u32`).join(", ");\n const dimsParams = rankIdentity.map((i) => `d${i}`).join(", ");\n return `\n fn set_${name}(${functionParams}, value: ${valueType}) {\n set_${name}ByIndices(${indices(dimsParams)}, value);\n }`;\n })();\n const set = (...indicesAndValue) => {\n if (indicesAndValue.length !== rank + 1) {\n throw new Error(`indices length must be ${rank}`);\n }\n const value = indicesAndValue[rank];\n if (typeof value !== "string") {\n throw new Error("value must be string");\n }\n const normalizedIndices = indicesAndValue.slice(0, rank).map(normalizeDim).join(",");\n if (rank === 0) {\n return setByOffset("0u", value);\n } else if (rank === 1) {\n return setByOffset(normalizedIndices[0], value);\n } else {\n implementationUsed.set = true;\n implementationUsed.setByIndices = true;\n implementationUsed.indicesToOffset = true;\n return `set_${name}(${normalizedIndices}, ${value})`;\n }\n };\n const setByIndices = (varIndices, value) => {\n if (rank < 2) {\n return setByOffset(varIndices, value);\n } else {\n implementationUsed.setByIndices = true;\n implementationUsed.indicesToOffset = true;\n return `set_${name}ByIndices(${varIndices}, ${value});`;\n }\n };\n const impl = () => {\n const impls = [];\n let needShapeStrides = false;\n if (implementationUsed.offsetToIndices) {\n impls.push(offsetToIndicesImplementation);\n needShapeStrides = true;\n }\n if (implementationUsed.indicesToOffset) {\n impls.push(indicesToOffsetImplementation);\n needShapeStrides = true;\n }\n if (implementationUsed.broadcastedIndicesToOffset) {\n Object.values(broadcastedIndicesToOffsetImplementation).forEach((impl2) => impls.push(impl2));\n needShapeStrides = true;\n }\n if (implementationUsed.set) {\n impls.push(setImplementation);\n needShapeStrides = true;\n }\n if (implementationUsed.setByIndices) {\n impls.push(setByIndicesImplementation);\n needShapeStrides = true;\n }\n if (implementationUsed.get) {\n impls.push(getImplementation);\n needShapeStrides = true;\n }\n if (implementationUsed.getByIndices) {\n impls.push(getByIndicesImplementation);\n needShapeStrides = true;\n }\n if (!useUniform && needShapeStrides) {\n impls.unshift(\n `const ${shape} = ${type.indices}(${shapeOrRank.join(",")});`,\n `const ${strides} = ${type.indices}(${ShapeUtil.computeStrides(shapeOrRank).join(",")});`\n );\n }\n return impls.join("\\n");\n };\n return {\n impl,\n type,\n offsetToIndices,\n indicesToOffset,\n broadcastedIndicesToOffset,\n indices,\n indicesGet,\n indicesSet,\n set,\n setByOffset,\n setByIndices,\n get,\n getByOffset,\n getByIndices,\n // isVec4,\n usage,\n name,\n strides,\n shape,\n rank\n };\n };\n inputVariable = (name, type, shapeOrRank, components = 1) => createIndicesHelper(name, type, shapeOrRank, "input", components);\n outputVariable = (name, type, shapeOrRank, components = 1) => createIndicesHelper(name, type, shapeOrRank, "output", components);\n internalVariable = (name, type, shapeOrRank, components = 1) => createIndicesHelper(name, type, shapeOrRank, "internal", components);\n ShaderHelperImpl = class {\n constructor(normalizedDispatchGroup, limits) {\n this.normalizedDispatchGroup = normalizedDispatchGroup;\n this.limits = limits;\n this.internalVariables = [];\n this.variables = [];\n this.uniforms = [];\n this.variableIndex = 0;\n }\n guardAgainstOutOfBoundsWorkgroupSizes(size) {\n const sizeInCode = typeof size === "number" ? `${size}u` : size;\n return `if (global_idx >= ${sizeInCode}) { return; }`;\n }\n mainStart(workgroupSize = WORKGROUP_SIZE) {\n const workgroupSizeX = typeof workgroupSize === "number" ? workgroupSize : workgroupSize[0];\n const workgroupSizeY = typeof workgroupSize === "number" ? 1 : workgroupSize[1];\n const workgroupSizeZ = typeof workgroupSize === "number" ? 1 : workgroupSize[2];\n if (workgroupSizeX > this.limits.maxComputeWorkgroupSizeX || workgroupSizeY > this.limits.maxComputeWorkgroupSizeY || workgroupSizeZ > this.limits.maxComputeWorkgroupSizeZ) {\n throw new Error(`workgroup size [${workgroupSizeX}, ${workgroupSizeY}, ${workgroupSizeZ}] exceeds the maximum workgroup size [${this.limits.maxComputeWorkgroupSizeX}, ${this.limits.maxComputeWorkgroupSizeY}, ${this.limits.maxComputeWorkgroupSizeZ}].`);\n }\n if (workgroupSizeX * workgroupSizeY * workgroupSizeZ > this.limits.maxComputeInvocationsPerWorkgroup) {\n throw new Error(`workgroup size [${workgroupSizeX}, ${workgroupSizeY}, ${workgroupSizeZ}] exceeds the maximum workgroup invocations ${this.limits.maxComputeInvocationsPerWorkgroup}.`);\n }\n const is1DimensionDispatch = this.normalizedDispatchGroup[1] === 1 && this.normalizedDispatchGroup[2] === 1;\n const paramList = is1DimensionDispatch ? `@builtin(global_invocation_id) global_id : vec3,\n @builtin(workgroup_id) workgroup_id : vec3,\n @builtin(local_invocation_id) local_id : vec3` : `@builtin(global_invocation_id) global_id : vec3,\n @builtin(local_invocation_id) local_id : vec3,\n @builtin(local_invocation_index) local_idx : u32,\n @builtin(workgroup_id) workgroup_id : vec3,\n @builtin(num_workgroups) num_workgroups : vec3`;\n const globalIdxDefinition = is1DimensionDispatch ? "let global_idx = global_id.x; let local_idx = local_id.x;" : `let global_idx = (workgroup_id.z * num_workgroups[0] * num_workgroups[1] +\n workgroup_id.y * num_workgroups[0] + workgroup_id.x) * ${workgroupSizeX * workgroupSizeY * workgroupSizeZ}u + local_idx;`;\n return `@compute @workgroup_size(${workgroupSizeX}, ${workgroupSizeY}, ${workgroupSizeZ})\n fn main(${paramList}) {\n ${globalIdxDefinition}\n `;\n }\n appendVariableUniforms(variable) {\n if (variable.rank !== 0) {\n if (variable.shape.startsWith("uniforms.")) {\n this.uniforms.push({ name: variable.shape.replace("uniforms.", ""), type: "u32", length: variable.rank });\n }\n if (variable.strides.startsWith("uniforms.")) {\n this.uniforms.push({ name: variable.strides.replace("uniforms.", ""), type: "u32", length: variable.rank });\n }\n }\n }\n declareVariable(variable, bindingIndex) {\n if (variable.usage === "internal") {\n throw new Error("cannot use internal variable with declareVariable(). use registerInternalVariables() instead.");\n }\n this.variables.push(variable);\n this.appendVariableUniforms(variable);\n const access = variable.usage === "input" ? "read" : "read_write";\n const storageType = variable.type.storage;\n return `@group(0) @binding(${bindingIndex}) var ${variable.name}: array<${storageType}>;`;\n }\n declareVariables(...variables) {\n return variables.map((v) => this.declareVariable(v, this.variableIndex++)).join("\\n");\n }\n registerInternalVariable(variable) {\n if (variable.usage !== "internal") {\n throw new Error(\n "cannot use input or output variable with registerInternalVariable(). use declareVariables() instead."\n );\n }\n this.internalVariables.push(variable);\n this.appendVariableUniforms(variable);\n }\n registerInternalVariables(...variables) {\n variables.forEach((v) => this.registerInternalVariable(v));\n return this;\n }\n registerUniform(name, type, length = 1) {\n this.uniforms.push({ name, type, length });\n return this;\n }\n registerUniforms(additionalUniforms) {\n this.uniforms = this.uniforms.concat(additionalUniforms);\n return this;\n }\n uniformDeclaration() {\n if (this.uniforms.length === 0) {\n return "";\n }\n const uniformSnippets = [];\n for (const { name, type, length } of this.uniforms) {\n if (length && length > 4) {\n if (type === "f16") {\n uniformSnippets.push(`@align(16) ${name}:array, ${Math.ceil(length / 8)}>`);\n } else {\n uniformSnippets.push(`${name}:array, ${Math.ceil(length / 4)}>`);\n }\n } else {\n const typeTemp = length == null || length === 1 ? type : `vec${length}<${type}>`;\n uniformSnippets.push(`${name}:${typeTemp}`);\n }\n }\n return `\n struct Uniforms { ${uniformSnippets.join(", ")} };\n @group(0) @binding(${this.variableIndex}) var uniforms: Uniforms;`;\n }\n /**\n * Get additional implementation that needs to be added to the shader source.\n */\n get additionalImplementations() {\n return this.uniformDeclaration() + this.variables.map((i) => i.impl()).join("\\n") + this.internalVariables.map((i) => i.impl()).join("\\n");\n }\n /**\n * Get the variable info of the shader program.\n */\n get variablesInfo() {\n if (this.uniforms.length === 0) {\n return void 0;\n }\n const uniformWgslTypeToDataType = (type) => [\n 12 /* uint32 */,\n 10 /* float16 */,\n 1 /* float */,\n 6 /* int32 */\n ][["u32", "f16", "f32", "i32"].indexOf(type)];\n return this.uniforms.map((u) => [uniformWgslTypeToDataType(u.type), u.length ?? 1]);\n }\n };\n createShaderHelper = (dispatchGroup, limits) => new ShaderHelperImpl(dispatchGroup, limits);\n getBroadcastDims = (inShape, outShape) => {\n const inRank = inShape.length;\n const dims = [];\n for (let i = 0; i < inRank; i++) {\n const dim = inRank - 1 - i;\n const a = inShape[dim] || 1;\n const b = outShape[outShape.length - 1 - i] || 1;\n if (b > 1 && a === 1) {\n dims.unshift(dim);\n }\n }\n return dims;\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/transpose.ts\n var validateInputs, getAdjustedPerm, getOutputShape, permFunctionBody, createTransposeProgramInfo, transpose, parseTransposeAttributes;\n var init_transpose = __esm({\n "web/lib/wasm/jsep/webgpu/ops/transpose.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_attribute_with_cache_key();\n init_common();\n validateInputs = (inputs) => {\n if (!inputs || inputs.length !== 1) {\n throw new Error("Transpose requires 1 input.");\n }\n };\n getAdjustedPerm = (inputRank, perm) => perm && perm.length !== inputRank ? [...new Array(inputRank).keys()].reverse() : perm;\n getOutputShape = (inputShape, perm) => ShapeUtil.sortBasedOnPerm(inputShape, getAdjustedPerm(inputShape.length, perm));\n permFunctionBody = (perm, rank, input, output) => {\n const reverseFunc = [];\n reverseFunc.push(`fn perm(i: ${output.type.indices}) -> ${input.type.indices} {\n var a: ${input.type.indices};`);\n for (let i = 0; i < rank; ++i) {\n reverseFunc.push(input.indicesSet("a", perm[i], `i[${i}]`));\n }\n reverseFunc.push("return a;}");\n return reverseFunc.join("\\n");\n };\n createTransposeProgramInfo = (inputTensor, permAttr) => {\n const inputDataType = inputTensor.dataType;\n const inputRank = inputTensor.dims.length;\n const perm = getAdjustedPerm(inputRank, permAttr);\n const outputShape = getOutputShape(inputTensor.dims, perm);\n const output = outputVariable("output", inputDataType, outputShape.length);\n const input = inputVariable("a", inputDataType, inputRank);\n const getShaderSource = (shaderHelper) => `\n ${shaderHelper.registerUniform("output_size", "u32").declareVariables(input, output)}\n\n ${permFunctionBody(perm, inputRank, input, output)}\n\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}\n\n let indices = ${output.offsetToIndices("global_idx")};\n let aIndices = perm(indices);\n\n ${output.setByOffset("global_idx", input.getByIndices("aIndices"))}\n }`;\n return {\n name: "Transpose",\n shaderCache: { hint: `${permAttr}`, inputDependencies: ["rank"] },\n getRunData: (inputs) => {\n const outputSize = ShapeUtil.size(outputShape);\n return {\n outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms: [{ type: 12 /* uint32 */, data: outputSize }, ...createTensorShapeVariables(inputs[0].dims, outputShape)]\n };\n },\n getShaderSource\n };\n };\n transpose = (context, attributes) => {\n validateInputs(context.inputs);\n context.compute(createTransposeProgramInfo(context.inputs[0], attributes.perm));\n };\n parseTransposeAttributes = (attributes) => createAttributeWithCacheKey({ perm: attributes.perm });\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/reduce-shared.ts\n var reduceOps, reduceSharedOps, reduceInitValues, reduceOutputValues, getInnerMostAxes, computeOutAndReduceShapes, expandShapeToKeepDim, areAxesInnerMostDims, getAxesPermutation, createReduceSharedProgramInfo, reduceCommon, reduceMeanShared, reduceL1Shared, reduceL2Shared, reduceLogSumExpShared, reduceMaxShared, reduceMinShared, reduceProdShared, reduceSumShared, reduceSumSquareShared, reduceLogSumShared;\n var init_reduce_shared = __esm({\n "web/lib/wasm/jsep/webgpu/ops/reduce-shared.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_common();\n init_reduce();\n init_transpose();\n reduceOps = {\n max: "select(bestValue, candidate, candidate > bestValue)",\n min: "select(bestValue, candidate, candidate < bestValue)",\n mean: "bestValue + candidate",\n sum: "bestValue + candidate",\n prod: "bestValue * candidate",\n sumSquare: "bestValue + candidate * candidate",\n logSumExp: "bestValue + exp(candidate)",\n l1: "bestValue + abs(candidate)",\n l2: "bestValue + candidate * candidate",\n logSum: "bestValue + candidate"\n };\n reduceSharedOps = {\n max: "select(bestValue, candidate, candidate > bestValue)",\n min: "select(bestValue, candidate, candidate < bestValue)",\n mean: "bestValue + candidate",\n sum: "bestValue + candidate",\n prod: "bestValue * candidate",\n sumSquare: "bestValue + candidate",\n logSumExp: "bestValue + candidate",\n l1: "bestValue + candidate",\n l2: "bestValue + candidate",\n logSum: "bestValue + candidate"\n };\n reduceInitValues = {\n max: "_A[offset]",\n min: "_A[offset]",\n mean: "0",\n sum: "0",\n prod: "1",\n sumSquare: "0",\n logSumExp: "0",\n l1: "0",\n l2: "0",\n logSum: "0"\n };\n reduceOutputValues = {\n max: "bestValue",\n min: "bestValue",\n sum: "bestValue",\n prod: "bestValue",\n sumSquare: "bestValue",\n logSumExp: "log(bestValue)",\n l1: "bestValue",\n l2: "sqrt(bestValue)",\n logSum: "log(bestValue)"\n };\n getInnerMostAxes = (numInnerAxes, rank) => {\n const res = [];\n for (let i = rank - numInnerAxes; i < rank; ++i) {\n res.push(i);\n }\n return res;\n };\n computeOutAndReduceShapes = (shape, axes) => {\n const outputShape = [];\n const rank = shape.length;\n for (let dim = 0; dim < rank; dim++) {\n if (axes.indexOf(dim) === -1) {\n outputShape.push(shape[dim]);\n }\n }\n const reduceShape = axes.map((dim) => shape[dim]);\n return [outputShape, reduceShape];\n };\n expandShapeToKeepDim = (shape, axes) => {\n const rank = shape.length + axes.length;\n const expandShape = [];\n let shapeIdx = 0;\n for (let dim = 0; dim < rank; dim++) {\n if (axes.indexOf(dim) === -1) {\n expandShape.push(shape[shapeIdx++]);\n } else {\n expandShape.push(1);\n }\n }\n return expandShape;\n };\n areAxesInnerMostDims = (axes, rank) => {\n for (let i = 0; i < axes.length; ++i) {\n if (axes[axes.length - i - 1] !== rank - 1 - i) {\n return false;\n }\n }\n return true;\n };\n getAxesPermutation = (axes, rank) => {\n const res = [];\n if (!areAxesInnerMostDims(axes, rank)) {\n for (let i = 0; i < rank; ++i) {\n if (axes.indexOf(i) === -1) {\n res.push(i);\n }\n }\n axes.forEach((axis) => res.push(axis));\n }\n return res;\n };\n createReduceSharedProgramInfo = (name, shaderCache, inputs, reduceType, outputDataType, outputShape, reduceShape) => {\n const inputShape = inputs[0].dims;\n const outputSize = ShapeUtil.size(outputShape);\n const reduceSize = ShapeUtil.size(reduceShape);\n const input = inputVariable("_A", inputs[0].dataType, inputShape);\n const output = outputVariable("output", outputDataType, outputShape);\n const workgroupSize = 32;\n const sharedMemorySnippet = `\n var aBestValues : array;\n `;\n const getShaderSource = (shaderHelper) => `\n ${shaderHelper.registerUniform("reduceSize", "u32").declareVariables(input, output)}\n ${sharedMemorySnippet}\n fn DIV_CEIL(a : u32, b : u32) -> u32 {\n return ((a - 1u) / b + 1u);\n }\n ${shaderHelper.mainStart(workgroupSize)}\n\n let outputIndex = global_idx / ${workgroupSize};\n let offset = outputIndex * uniforms.reduceSize;\n\n var bestValue = f32(${reduceInitValues[reduceType]});\n let Length = uniforms.reduceSize;\n for (var k = local_idx; k < Length; k = k + ${workgroupSize}) {\n let candidate = f32(${input.getByOffset("offset + k")});\n bestValue = ${reduceOps[reduceType]};\n }\n aBestValues[local_idx] = bestValue;\n workgroupBarrier();\n\n var reduceSize = min(Length, ${workgroupSize}u);\n for (var currentSize = reduceSize / 2u; reduceSize > 1u;\n currentSize = reduceSize / 2u) {\n let interval = DIV_CEIL(reduceSize, 2u);\n if (local_idx < currentSize) {\n let candidate = aBestValues[local_idx + interval];\n bestValue = ${reduceSharedOps[reduceType]};\n aBestValues[local_idx] = bestValue;\n }\n reduceSize = interval;\n workgroupBarrier();\n }\n\n if (local_idx == 0u) {\n ${output.setByOffset(\n "outputIndex",\n `${reduceType === "mean" ? `${output.type.storage}(bestValue / f32(uniforms.reduceSize))` : `${output.type.storage}(${reduceOutputValues[reduceType]})`}`\n )};\n }\n }`;\n return {\n name,\n shaderCache,\n getShaderSource,\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: outputDataType }],\n dispatchGroup: { x: outputSize },\n programUniforms: [{ type: 12 /* uint32 */, data: reduceSize }]\n })\n };\n };\n reduceCommon = (context, name, attributes, reduceType) => {\n const updatedAttributes = context.inputs.length === 1 ? attributes : createReduceAttributesFromInputs(context.inputs, attributes);\n let updatedAxes = updatedAttributes.axes;\n if (updatedAxes.length === 0 && !updatedAttributes.noopWithEmptyAxes) {\n updatedAxes = context.inputs[0].dims.map((_dim, i) => i);\n }\n const normalizeAxes = ShapeUtil.normalizeAxes(updatedAxes, context.inputs[0].dims.length);\n let axes = normalizeAxes;\n let input = context.inputs[0];\n const permutedAxes = getAxesPermutation(axes, context.inputs[0].dims.length);\n if (permutedAxes.length > 0) {\n input = context.compute(\n createTransposeProgramInfo(context.inputs[0], permutedAxes),\n { inputs: [0], outputs: [-1] }\n )[0];\n axes = getInnerMostAxes(axes.length, input.dims.length);\n }\n const [outputShape, reduceShape] = computeOutAndReduceShapes(input.dims, axes);\n let finalOutputShape = outputShape;\n if (updatedAttributes.keepDims) {\n finalOutputShape = expandShapeToKeepDim(outputShape, normalizeAxes);\n }\n context.compute(\n createReduceSharedProgramInfo(\n name,\n { hint: updatedAttributes.cacheKey, inputDependencies: ["type"] },\n [input],\n reduceType,\n context.inputs[0].dataType,\n finalOutputShape,\n reduceShape\n ),\n { inputs: [input] }\n );\n };\n reduceMeanShared = (context, attributes) => {\n reduceCommon(context, "ReduceMeanShared", attributes, "mean");\n };\n reduceL1Shared = (context, attributes) => {\n reduceCommon(context, "ReduceL1Shared", attributes, "l1");\n };\n reduceL2Shared = (context, attributes) => {\n reduceCommon(context, "ReduceL2Shared", attributes, "l2");\n };\n reduceLogSumExpShared = (context, attributes) => {\n reduceCommon(context, "ReduceLogSumExpShared", attributes, "logSumExp");\n };\n reduceMaxShared = (context, attributes) => {\n reduceCommon(context, "ReduceMaxShared", attributes, "max");\n };\n reduceMinShared = (context, attributes) => {\n reduceCommon(context, "ReduceMinShared", attributes, "min");\n };\n reduceProdShared = (context, attributes) => {\n reduceCommon(context, "ReduceProdShared", attributes, "prod");\n };\n reduceSumShared = (context, attributes) => {\n reduceCommon(context, "ReduceSumShared", attributes, "sum");\n };\n reduceSumSquareShared = (context, attributes) => {\n reduceCommon(context, "ReduceSumSquareShared", attributes, "sumSquare");\n };\n reduceLogSumShared = (context, attributes) => {\n reduceCommon(context, "ReduceLogSumShared", attributes, "logSum");\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/reduce.ts\n var validateInputs2, noOp, createReduceProgramInfo, createReduceAttributesFromInputs, runReduceProgram, reduceLogSumNaive, reduceL1Naive, reduceL2Naive, reduceLogSumExpNaive, reduceMaxNaive, reduceMeanNaive, reduceMinNaive, reduceProdNaive, reduceSumNaive, reduceSumSquareNaive, useNaiveReduceMethod, reduceMean, reduceL1, reduceL2, reduceLogSumExp, reduceMax, reduceMin, reduceProd, reduceSum, reduceSumSquare, reduceLogSum;\n var init_reduce = __esm({\n "web/lib/wasm/jsep/webgpu/ops/reduce.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_attribute_with_cache_key();\n init_common();\n init_reduce_shared();\n validateInputs2 = (inputs) => {\n if (!inputs || inputs.length === 0 || inputs.length > 2) {\n throw new Error("Reduce op requires 1 or 2 inputs.");\n }\n if (inputs.length === 2 && inputs[1].dims.length !== 1) {\n throw new Error("Invalid axes input dims.");\n }\n };\n noOp = (input) => ["", "", `var value = ${input.getByIndices("input_indices")};`, ""];\n createReduceProgramInfo = (name, shaderCache, inputs, reduceOp, axesInput, outputDataType, keepDims = false, noopWithEmptyAxes = false) => {\n const outputShape = [];\n const inputShape = inputs[0].dims;\n const inputRank = inputShape.length;\n const axes = ShapeUtil.normalizeAxes(axesInput, inputRank);\n const reduceOnAllAxes = !noopWithEmptyAxes && axes.length === 0;\n inputShape.forEach((d, i) => {\n if (reduceOnAllAxes || axes.indexOf(i) >= 0) {\n if (keepDims) {\n outputShape.push(1);\n }\n } else {\n outputShape.push(d);\n }\n });\n const outputRank = outputShape.length;\n const outputSize = ShapeUtil.size(outputShape);\n const getShaderSource = (shaderHelper) => {\n const idxCopy = [];\n const input = inputVariable("_A", inputs[0].dataType, inputRank);\n const output = outputVariable("output", outputDataType, outputRank);\n const ops = reduceOp(input, output, axes);\n let reduceOps2 = ops[2];\n for (let k = 0, l = 0; k < inputRank; k++) {\n if (reduceOnAllAxes || axes.indexOf(k) >= 0) {\n if (keepDims) {\n l++;\n }\n reduceOps2 = `for(var j${k}: u32 = 0; j${k} < ${inputShape[k]}; j${k}++) {\n ${ops[2].includes("last_index") ? `let last_index = j${k};` : ""}\n ${input.indicesSet("input_indices", k, `j${k}`)}\n ${reduceOps2}\n }`;\n } else {\n idxCopy.push(`${input.indicesSet("input_indices", k, output.indicesGet("output_indices", l))};`);\n l++;\n }\n }\n return `\n\n ${shaderHelper.registerUniform("output_size", "u32").declareVariables(input, output)}\n\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}\n var input_indices: ${input.type.indices};\n let output_indices = ${output.offsetToIndices("global_idx")};\n\n ${idxCopy.join("\\n")}\n ${ops[0]} // init ops for reduce max/min\n ${ops[1]}\n ${reduceOps2}\n ${ops[3]}\n ${ops.length === 4 ? output.setByOffset("global_idx", "value") : ops.slice(4).join("\\n")}\n }`;\n };\n return {\n name,\n shaderCache,\n getShaderSource,\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: outputDataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms: [{ type: 12 /* uint32 */, data: outputSize }, ...createTensorShapeVariables(inputShape, outputShape)]\n })\n };\n };\n createReduceAttributesFromInputs = (inputs, attributes) => {\n const axes = [];\n if (inputs[1].dims[0] > 0) {\n inputs[1].getBigInt64Array().forEach((v) => axes.push(Number(v)));\n }\n return createAttributeWithCacheKey(\n { axes, keepDims: attributes.keepDims, noopWithEmptyAxes: attributes.noopWithEmptyAxes }\n );\n };\n runReduceProgram = (context, name, attributes, reduceOp) => {\n const inputs = context.inputs;\n const updatedAttributes = inputs.length === 1 ? attributes : createReduceAttributesFromInputs(inputs, attributes);\n context.compute(\n createReduceProgramInfo(\n name,\n { hint: updatedAttributes.cacheKey, inputDependencies: ["rank"] },\n [inputs[0]],\n updatedAttributes.noopWithEmptyAxes && updatedAttributes.axes.length === 0 ? noOp : reduceOp,\n updatedAttributes.axes,\n inputs[0].dataType,\n updatedAttributes.keepDims,\n updatedAttributes.noopWithEmptyAxes\n ),\n { inputs: [0] }\n );\n };\n reduceLogSumNaive = (context, attributes) => {\n validateInputs2(context.inputs);\n const reduceOp = (input, output) => [\n `var value = ${output.type.storage}(0);`,\n "",\n `value += ${input.getByIndices("input_indices")};`,\n "value = log(value);"\n ];\n runReduceProgram(context, "ReduceLogSum", attributes, reduceOp);\n };\n reduceL1Naive = (context, attributes) => {\n validateInputs2(context.inputs);\n const reduceOp = (input, output) => [\n `var value = ${output.type.storage}(0);`,\n "",\n `value += abs(${input.getByIndices("input_indices")});`,\n ""\n ];\n runReduceProgram(context, "ReduceL1", attributes, reduceOp);\n };\n reduceL2Naive = (context, attributes) => {\n validateInputs2(context.inputs);\n const reduceOp = (input, output) => [\n `var t = ${output.type.value}(0); var value = ${output.type.value}(0);`,\n "",\n `t = ${input.getByIndices("input_indices")}; value += (t * t);`,\n "value = sqrt(value);"\n ];\n runReduceProgram(context, "ReduceL2", attributes, reduceOp);\n };\n reduceLogSumExpNaive = (context, attributes) => {\n validateInputs2(context.inputs);\n const reduceOp = (input, output) => [\n `var value = ${output.type.storage}(0);`,\n "",\n `value += exp(${input.getByIndices("input_indices")});`,\n "value = log(value);"\n ];\n runReduceProgram(context, "ReduceLogSumExp", attributes, reduceOp);\n };\n reduceMaxNaive = (context, attributes) => {\n validateInputs2(context.inputs);\n const reduceOp = (input, _output, axes) => {\n const idxZero = [];\n for (let k = 0; k < input.rank; k++) {\n if (axes.indexOf(k) >= 0 || axes.length === 0) {\n idxZero.push(input.indicesSet("input_indices", k, 0));\n }\n }\n return [\n `${idxZero.join("\\n")}`,\n `var value = ${input.getByIndices("input_indices")};`,\n `value = max(value, ${input.getByIndices("input_indices")});`,\n ""\n ];\n };\n runReduceProgram(context, "ReduceMax", attributes, reduceOp);\n };\n reduceMeanNaive = (context, attributes) => {\n validateInputs2(context.inputs);\n const reduceOp = (input, output, axes) => {\n let size = 1;\n for (let k = 0; k < input.rank; k++) {\n if (axes.indexOf(k) >= 0 || axes.length === 0) {\n size *= context.inputs[0].dims[k];\n }\n }\n return [\n "var sum = f32(0);",\n "",\n `sum += f32(${input.getByIndices("input_indices")});`,\n `let value = ${output.type.value}(sum / ${size});`\n ];\n };\n runReduceProgram(context, "ReduceMean", attributes, reduceOp);\n };\n reduceMinNaive = (context, attributes) => {\n validateInputs2(context.inputs);\n const reduceOp = (input, _output, axes) => {\n const idxZero = [];\n for (let k = 0; k < input.rank; k++) {\n if (axes.indexOf(k) >= 0 || axes.length === 0) {\n idxZero.push(`input_indices[${k}] = 0;`);\n }\n }\n return [\n `${idxZero.join("\\n")}`,\n `var value = ${input.getByIndices("input_indices")};`,\n `value = min(value, ${input.getByIndices("input_indices")});`,\n ""\n ];\n };\n runReduceProgram(context, "ReduceMin", attributes, reduceOp);\n };\n reduceProdNaive = (context, attributes) => {\n validateInputs2(context.inputs);\n const reduceOp = (input, output) => [\n `var value = ${output.type.storage}(1);`,\n "",\n `value *= ${input.getByIndices("input_indices")};`,\n ""\n ];\n runReduceProgram(context, "ReduceProd", attributes, reduceOp);\n };\n reduceSumNaive = (context, attributes) => {\n validateInputs2(context.inputs);\n const reduceOp = (input, output) => [\n `var value = ${output.type.storage}(0);`,\n "",\n `value += ${input.getByIndices("input_indices")};`,\n ""\n ];\n runReduceProgram(context, "ReduceSum", attributes, reduceOp);\n };\n reduceSumSquareNaive = (context, attributes) => {\n validateInputs2(context.inputs);\n const reduceOp = (input, output) => [\n `var t = ${output.type.value}(0); var value = ${output.type.value}(0);`,\n "",\n `t = ${input.getByIndices("input_indices")}; value += t * t;`,\n ""\n ];\n runReduceProgram(context, "ReduceSumSquare", attributes, reduceOp);\n };\n useNaiveReduceMethod = (shape, axes, noopWithEmptyAxes) => {\n if (axes.length === 0) {\n return noopWithEmptyAxes;\n }\n let outputSize = 1;\n let reduceSize = 1;\n for (let dim = 0; dim < axes.length; dim++) {\n if (axes.indexOf(dim) === -1) {\n outputSize *= shape[dim];\n } else {\n reduceSize *= shape[dim];\n }\n }\n return reduceSize < 32 && outputSize > 1024;\n };\n reduceMean = (context, attributes) => {\n if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n reduceMeanNaive(context, attributes);\n } else {\n reduceMeanShared(context, attributes);\n }\n };\n reduceL1 = (context, attributes) => {\n if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n reduceL1Naive(context, attributes);\n } else {\n reduceL1Shared(context, attributes);\n }\n };\n reduceL2 = (context, attributes) => {\n if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n reduceL2Naive(context, attributes);\n } else {\n reduceL2Shared(context, attributes);\n }\n };\n reduceLogSumExp = (context, attributes) => {\n if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n reduceLogSumExpNaive(context, attributes);\n } else {\n reduceLogSumExpShared(context, attributes);\n }\n };\n reduceMax = (context, attributes) => {\n if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n reduceMaxNaive(context, attributes);\n } else {\n reduceMaxShared(context, attributes);\n }\n };\n reduceMin = (context, attributes) => {\n if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n reduceMinNaive(context, attributes);\n } else {\n reduceMinShared(context, attributes);\n }\n };\n reduceProd = (context, attributes) => {\n if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n reduceProdNaive(context, attributes);\n } else {\n reduceProdShared(context, attributes);\n }\n };\n reduceSum = (context, attributes) => {\n if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n reduceSumNaive(context, attributes);\n } else {\n reduceSumShared(context, attributes);\n }\n };\n reduceSumSquare = (context, attributes) => {\n if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n reduceSumSquareNaive(context, attributes);\n } else {\n reduceSumSquareShared(context, attributes);\n }\n };\n reduceLogSum = (context, attributes) => {\n if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n reduceLogSumNaive(context, attributes);\n } else {\n reduceLogSumShared(context, attributes);\n }\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/argminmax.ts\n var validateInputs3, argMin, argMax, parseArgMinMaxAttributes;\n var init_argminmax = __esm({\n "web/lib/wasm/jsep/webgpu/ops/argminmax.ts"() {\n "use strict";\n init_wasm_common();\n init_attribute_with_cache_key();\n init_reduce();\n validateInputs3 = (inputs) => {\n if (!inputs || inputs.length === 0 || inputs.length > 2) {\n throw new Error("ArgMinMaxOp op requires 1 or 2 inputs.");\n }\n if (inputs[0].dataType !== 1 /* float */) {\n throw new Error("Invalid input type.");\n }\n };\n argMin = (context, attributes) => {\n validateInputs3(context.inputs);\n const argMinMaxOp = (input, output, axes) => {\n const idxZero = [];\n for (let k = 0; k < input.rank; k++) {\n if (axes.indexOf(k) >= 0 || axes.length === 0) {\n idxZero.push(`input_indices[${k}] = 0;`);\n }\n }\n return [\n `${idxZero.join("\\n")}`,\n `var value = ${input.getByIndices("input_indices")};\nvar best_index : i32 = 0;`,\n `if (${input.getByIndices("input_indices")} ${attributes.selectLastIndex > 0 ? "<=" : "<"} value) {\n value = ${input.getByIndices("input_indices")};\n best_index = i32(last_index);\n }`,\n "",\n output.setByOffset("global_idx", "best_index")\n ];\n };\n context.compute(\n createReduceProgramInfo(\n "ArgMin",\n { hint: attributes.cacheKey, inputDependencies: ["rank"] },\n [context.inputs[0]],\n argMinMaxOp,\n [attributes.axis],\n 7 /* int64 */,\n attributes.keepDims\n ),\n { inputs: [0] }\n );\n };\n argMax = (context, attributes) => {\n validateInputs3(context.inputs);\n const argMinMaxOp = (input, output, axes) => {\n const idxZero = [];\n for (let k = 0; k < input.rank; k++) {\n if (axes.indexOf(k) >= 0 || axes.length === 0) {\n idxZero.push(`input_indices[${k}] = 0;`);\n }\n }\n return [\n `${idxZero.join("\\n")}`,\n `var value = ${input.getByIndices("input_indices")};\nvar best_index : i32 = 0;`,\n `if (${input.getByIndices("input_indices")} ${attributes.selectLastIndex > 0 ? ">=" : ">"} value) {\n value = ${input.getByIndices("input_indices")};\n best_index = i32(last_index);\n }`,\n "",\n output.setByOffset("global_idx", "best_index")\n ];\n };\n context.compute(\n createReduceProgramInfo(\n "argMax",\n { hint: attributes.cacheKey, inputDependencies: ["rank"] },\n [context.inputs[0]],\n argMinMaxOp,\n [attributes.axis],\n 7 /* int64 */,\n attributes.keepDims\n ),\n { inputs: [0] }\n );\n };\n parseArgMinMaxAttributes = (attributes) => createAttributeWithCacheKey(attributes);\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/concat.ts\n var validateInputs4, calculateInputIndexImpl, assignOutputData, createConcatProgramInfo, concat, parseConcatAttributes;\n var init_concat = __esm({\n "web/lib/wasm/jsep/webgpu/ops/concat.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_attribute_with_cache_key();\n init_common();\n validateInputs4 = (inputs, axis) => {\n if (!inputs || inputs.length < 1) {\n throw new Error("too few inputs");\n }\n const referenceIndex = 0;\n const referenceInput = inputs[referenceIndex];\n const inputType = referenceInput.dataType;\n const inputRank = referenceInput.dims.length;\n inputs.forEach((input, i) => {\n if (i === referenceIndex) {\n return;\n }\n if (input.dataType !== inputType) {\n throw new Error("input tensors should be one type");\n }\n if (input.dims.length !== inputRank) {\n throw new Error("input tensors should have the same shape");\n }\n input.dims.forEach((dim, i2) => {\n if (i2 !== axis && dim !== referenceInput.dims[i2]) {\n throw new Error("non concat dimensions must match");\n }\n });\n });\n };\n calculateInputIndexImpl = (numberOfTensors, sizeInConcatAxisStr) => `\n fn calculateInputIndex(index: u32) -> u32 {\n let sizeInConcatAxis = array(${sizeInConcatAxisStr});\n for (var i: u32 = 0u; i < ${numberOfTensors}; i += 1u ) {\n if (index < sizeInConcatAxis[i]) {\n return i;\n }\n }\n return ${numberOfTensors}u;\n }`;\n assignOutputData = (inputs, output) => {\n const numberOfTensors = inputs.length;\n const codeLines = [];\n for (let i = 0; i < numberOfTensors; ++i) {\n const returnSnippet = output.setByOffset("global_idx", inputs[i].getByIndices("indices"));\n if (numberOfTensors === 1) {\n codeLines.push(returnSnippet);\n } else if (i === 0) {\n codeLines.push(`if (inputIndex == ${i}u) { ${returnSnippet} }`);\n } else if (i === numberOfTensors - 1) {\n codeLines.push(`else { ${returnSnippet} }`);\n } else {\n codeLines.push(`else if (inputIndex == ${i}) { ${returnSnippet} }`);\n }\n }\n return codeLines.join("\\n");\n };\n createConcatProgramInfo = (inputs, adjustedAxis, outputShape, dataType) => {\n const outputSize = ShapeUtil.size(outputShape);\n const sizeInConcatAxis = new Array(inputs.length);\n const inputVars = new Array(inputs.length);\n let previousSum = 0;\n const inputDependencies = [];\n const inputRanks = [];\n const programUniforms = [{ type: 12 /* uint32 */, data: outputSize }];\n for (let i = 0; i < inputs.length; ++i) {\n previousSum += inputs[i].dims[adjustedAxis];\n sizeInConcatAxis[i] = previousSum;\n inputRanks.push(inputs[i].dims.length);\n inputVars[i] = inputVariable(`input${i}`, dataType, inputRanks[i]);\n inputDependencies.push("rank");\n programUniforms.push({ type: 12 /* uint32 */, data: sizeInConcatAxis[i] });\n }\n for (let i = 0; i < inputs.length; ++i) {\n programUniforms.push(...createTensorShapeVariables(inputs[i].dims));\n }\n programUniforms.push(...createTensorShapeVariables(outputShape));\n const output = outputVariable("output", dataType, outputShape.length);\n const indicesAxis = output.indicesGet("indices", adjustedAxis);\n const sizeInConcatAxisStr = Array.from(Array(sizeInConcatAxis.length).keys()).map((i) => `uniforms.sizeInConcatAxis${i}`).join(",");\n const getShaderSource = (shaderHelper) => `\n\n ${(() => {\n shaderHelper.registerUniform("outputSize", "u32");\n for (let i = 0; i < inputs.length; i++) {\n shaderHelper.registerUniform(`sizeInConcatAxis${i}`, "u32");\n }\n return shaderHelper.declareVariables(...inputVars, output);\n })()}\n\n ${calculateInputIndexImpl(sizeInConcatAxis.length, sizeInConcatAxisStr)}\n\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}\n\n var indices = ${output.offsetToIndices("global_idx")};\n\n let inputIndex = calculateInputIndex(${indicesAxis});\n if (inputIndex != 0u) {\n let sizeInConcatAxis = array(${sizeInConcatAxisStr});\n ${indicesAxis} -= sizeInConcatAxis[inputIndex - 1u];\n }\n\n ${assignOutputData(inputVars, output)}\n }`;\n return {\n name: "Concat",\n shaderCache: { hint: `${adjustedAxis}`, inputDependencies },\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms\n }),\n getShaderSource\n };\n };\n concat = (context, attributes) => {\n const inputs = context.inputs;\n const inputShape = inputs[0].dims;\n const adjustedAxis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);\n validateInputs4(inputs, adjustedAxis);\n const outputShape = inputShape.slice();\n outputShape[adjustedAxis] = inputs.reduce((sum, input) => sum + (input.dims.length > adjustedAxis ? input.dims[adjustedAxis] : 0), 0);\n const nonEmptyInputs = inputs.filter((input) => ShapeUtil.size(input.dims) > 0);\n context.compute(\n createConcatProgramInfo(nonEmptyInputs, adjustedAxis, outputShape, inputs[0].dataType),\n { inputs: nonEmptyInputs }\n );\n };\n parseConcatAttributes = (attributes) => createAttributeWithCacheKey({ axis: attributes.axis });\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/attention.ts\n var validateAttentionInputs, createInPlaceSoftmaxProgramInfo, createAttentionProbsProgramInfo, createVxAttentionScoreProgramInfo, applyAttention, prepare, attention;\n var init_attention = __esm({\n "web/lib/wasm/jsep/webgpu/ops/attention.ts"() {\n "use strict";\n init_wasm_common();\n init_types();\n init_common();\n init_concat();\n validateAttentionInputs = (inputs, attributes) => {\n const input = inputs[0];\n const weights = inputs[1];\n const bias = inputs[2];\n const maskIndex = inputs[3];\n const past = inputs[4];\n const relativePositionBias = inputs[5];\n if (past && relativePositionBias) {\n throw new Error("Attention cannot have both past and relative_position_bias");\n }\n if (input.dims.length !== 3) {\n throw new Error(\'Input "input" must have 3 dimensions\');\n }\n const batchSize = input.dims[0];\n const sequenceLength = input.dims[1];\n const inputHiddenSize = input.dims[2];\n if (bias.dims.length !== 1) {\n throw new Error(\'Input "bias" is expected to have 1 dimensions\');\n }\n if (weights.dims.length !== 2) {\n throw new Error(\'Input "weights" is expected to have 2 dimensions\');\n }\n if (weights.dims[0] !== inputHiddenSize) {\n throw new Error("Input 1 dimension 0 should have same length as dimension 2 of input 0");\n }\n if (bias.dims[0] !== weights.dims[1]) {\n throw new Error(\'Input "bias" dimension 0 should have same length as dimension 1 of input "weights"\');\n }\n let qHiddenSize = bias.dims[0] / 3;\n let kHiddenSize = qHiddenSize;\n let vHiddenSize = kHiddenSize;\n if (attributes.qkvHiddenSizes.length > 0) {\n if (attributes.qkvHiddenSizes.length !== 3) {\n throw new Error("qkv_hidden_sizes attribute should have 3 elements");\n }\n for (const sz of attributes.qkvHiddenSizes) {\n if (sz % attributes.numHeads !== 0) {\n throw new Error("qkv_hidden_sizes should be divisible by num_heads");\n }\n }\n qHiddenSize = attributes.qkvHiddenSizes[0];\n kHiddenSize = attributes.qkvHiddenSizes[1];\n vHiddenSize = attributes.qkvHiddenSizes[2];\n }\n const kvSequenceLength = sequenceLength;\n if (qHiddenSize !== kHiddenSize) {\n throw new Error("qkv_hidden_sizes first element should be same as the second");\n }\n if (bias.dims[0] !== qHiddenSize + kHiddenSize + vHiddenSize) {\n throw new Error(\'Input "bias" dimension 0 should have same length as sum of Q/K/V hidden sizes\');\n }\n let pastSequenceLength = 0;\n if (past) {\n if (kHiddenSize !== vHiddenSize) {\n throw new Error(\'Input "past" expect k_hidden_size == v_hidden_size\');\n }\n if (past.dims.length !== 5) {\n throw new Error(\'Input "past" must have 5 dimensions\');\n }\n if (past.dims[0] !== 2) {\n throw new Error(\'Input "past" first dimension must be 2\');\n }\n if (past.dims[1] !== batchSize) {\n throw new Error(\'Input "past" second dimension must be batch_size\');\n }\n if (past.dims[2] !== attributes.numHeads) {\n throw new Error(\'Input "past" third dimension must be num_heads\');\n }\n if (past.dims[4] !== kHiddenSize / attributes.numHeads) {\n throw new Error(\'Input "past" fifth dimension must be k_hidden_size / num_heads\');\n }\n if (!attributes.pastPresentShareBuffer) {\n pastSequenceLength = past.dims[3];\n }\n }\n const totalSequenceLength = kvSequenceLength + pastSequenceLength;\n const maxSequenceLength = -1;\n const maskType = 0 /* none */;\n if (maskIndex) {\n throw new Error("Mask not supported");\n }\n if (past) {\n throw new Error("past is not supported");\n }\n return {\n batchSize,\n sequenceLength,\n pastSequenceLength,\n kvSequenceLength,\n totalSequenceLength,\n maxSequenceLength,\n inputHiddenSize,\n hiddenSize: qHiddenSize,\n vHiddenSize,\n headSize: Math.floor(qHiddenSize / attributes.numHeads),\n vHeadSize: Math.floor(vHiddenSize / attributes.numHeads),\n numHeads: attributes.numHeads,\n isUnidirectional: false,\n pastPresentShareBuffer: false,\n maskFilterValue: attributes.maskFilterValue,\n maskType,\n scale: attributes.scale,\n broadcastResPosBias: false,\n passPastInKv: false,\n qkvFormat: 1 /* qkvBNSH */\n };\n };\n createInPlaceSoftmaxProgramInfo = (_context, input, n, d) => {\n const components = getMaxComponents(d);\n let WG = 64;\n const dComp = d / components;\n if (dComp < WG) {\n WG = 1;\n } else if (dComp / 8 < 64) {\n WG = Math.ceil(dComp / 8);\n }\n const elementsPerThread = Math.ceil(d / components / WG);\n const programUniforms = [\n { type: input.dataType, data: 1 / d },\n { type: 12 /* uint32 */, data: dComp },\n { type: 12 /* uint32 */, data: elementsPerThread }\n ];\n const dataType = tensorTypeToWsglStorageType(input.dataType, components);\n const f32Type = tensorTypeToWsglValueType(1 /* float */, components);\n const getShaderSource = (shaderHelper) => {\n const inputHelper = outputVariable("x", input.dataType, input.dims, components);\n const elemValueType = tensorTypeToWsglValueType(input.dataType);\n const uniforms = [\n { name: "d_inv", type: elemValueType },\n { name: "d_comp", type: "u32" },\n { name: "elements_per_thread", type: "u32" }\n ];\n return `\n var thread_max: array;\n var thread_sum: array;\n ${shaderHelper.registerUniforms(uniforms).declareVariables(inputHelper)}\n ${shaderHelper.mainStart([\n WG,\n 1,\n 1\n ])}\n let local_offset = local_idx * uniforms.elements_per_thread;\n let offset = workgroup_id.x * uniforms.d_comp + local_offset;\n\n var thread_max_vector = ${f32Type}(-3.402823e+38f);\n for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n thread_max_vector = max(${f32Type}(x[offset + i]), thread_max_vector);\n }\n thread_max[local_idx] = ${(() => {\n switch (components) {\n case 1:\n return "thread_max_vector";\n case 2:\n return "max(thread_max_vector.x, thread_max_vector.y)";\n case 4:\n return "max(max(thread_max_vector.x, thread_max_vector.y), max(thread_max_vector.z, thread_max_vector.w))";\n default:\n throw new Error(`Unsupported components: ${components}`);\n }\n })()};\n workgroupBarrier();\n\n var max_value = f32(-3.402823e+38f);\n for (var i = 0u; i < ${WG}; i++) {\n max_value = max(thread_max[i], max_value);\n }\n\n var sum_vector = ${f32Type}(0);\n for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n sum_vector += exp(${f32Type}(x[offset + i]) - max_value);\n }\n thread_sum[local_idx] = ${(() => {\n switch (components) {\n case 1:\n return "sum_vector";\n case 2:\n return "sum_vector.x + sum_vector.y";\n case 4:\n return "sum_vector.x + sum_vector.y + sum_vector.z + sum_vector.w";\n default:\n throw new Error(`Unsupported components: ${components}`);\n }\n })()};\n workgroupBarrier();\n\n var sum: f32 = 0;\n for (var i = 0u; i < ${WG}; i++) {\n sum += thread_sum[i];\n }\n\n if (sum == 0) {\n for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n x[offset + i] = ${inputHelper.type.value}(uniforms.d_inv);\n }\n } else {\n for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n var f32input = ${f32Type}(x[offset + i]);\n x[offset + i] = ${inputHelper.type.value}(exp(f32input - max_value) / sum);\n }\n }\n }`;\n };\n return {\n name: "AttentionProbsSoftmax",\n shaderCache: { hint: `${WG};${dataType};${components}` },\n getShaderSource,\n getRunData: () => ({ outputs: [], dispatchGroup: { x: n }, programUniforms })\n };\n };\n createAttentionProbsProgramInfo = (_context, q, key, relativePositionBias, parameters, attributes, pastSequenceLength) => {\n const totalSequenceLength = pastSequenceLength + parameters.kvSequenceLength;\n const probsShape = [parameters.batchSize, parameters.numHeads, parameters.sequenceLength, totalSequenceLength];\n const alpha = attributes.scale === 0 ? 1 / Math.sqrt(parameters.headSize) : attributes.scale;\n const components = getMaxComponents(parameters.headSize);\n const vectorizedHeadSize = parameters.headSize / components;\n const TILE_SIZE = 12;\n const dispatch = {\n x: Math.ceil(totalSequenceLength / TILE_SIZE),\n y: Math.ceil(parameters.sequenceLength / TILE_SIZE),\n z: parameters.batchSize * parameters.numHeads\n };\n const programUniforms = [\n { type: 12 /* uint32 */, data: parameters.sequenceLength },\n { type: 12 /* uint32 */, data: vectorizedHeadSize },\n { type: 12 /* uint32 */, data: totalSequenceLength },\n { type: 12 /* uint32 */, data: parameters.numHeads },\n { type: 1 /* float */, data: alpha }\n ];\n const inputDependencies = ["type", "type"];\n if (relativePositionBias) {\n inputDependencies.push("rank");\n programUniforms.push(...createTensorShapeVariables(relativePositionBias.dims));\n }\n const getShaderSource = (shaderHelper) => {\n const qInput = inputVariable("q", q.dataType, q.dims, components);\n const kInput = inputVariable("key", key.dataType, key.dims, components);\n const inputVars = [qInput, kInput];\n const relativePositionBiasInput = relativePositionBias ? inputVariable("relative_position_bias", relativePositionBias.dataType, relativePositionBias.dims.length) : void 0;\n if (relativePositionBiasInput) {\n inputVars.push(relativePositionBiasInput);\n }\n const output = outputVariable("output", q.dataType, probsShape);\n const f32Type = tensorTypeToWsglValueType(1 /* float */, components);\n const uniforms = [\n { name: "M", type: "u32" },\n { name: "K", type: "u32" },\n { name: "N", type: "u32" },\n { name: "num_heads", type: "u32" },\n { name: "alpha", type: "f32" }\n ];\n return `\n const TILE_SIZE = ${TILE_SIZE}u;\n\n var tileQ: array<${qInput.type.storage}, ${TILE_SIZE * TILE_SIZE}>;\n var tileK: array<${qInput.type.storage}, ${TILE_SIZE * TILE_SIZE}>;\n ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}\n ${shaderHelper.mainStart([\n TILE_SIZE,\n TILE_SIZE,\n 1\n ])}\n // x holds the N and y holds the M\n let headIdx = workgroup_id.z;\n let m = workgroup_id.y * TILE_SIZE;\n let n = workgroup_id.x * TILE_SIZE;\n let qOffset = uniforms.M * uniforms.K * headIdx + m * uniforms.K;\n let kOffset = uniforms.N * uniforms.K * headIdx + n * uniforms.K;\n\n var value = ${f32Type}(0);\n for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n if (global_id.y < uniforms.M && w + local_id.x < uniforms.K) {\n tileQ[TILE_SIZE * local_id.y + local_id.x] = q[qOffset + local_id.y * uniforms.K + w + local_id.x];\n }\n if (n + local_id.y < uniforms.N && w + local_id.x < uniforms.K) {\n tileK[TILE_SIZE * local_id.y + local_id.x] = key[kOffset + local_id.y * uniforms.K + w + local_id.x];\n }\n workgroupBarrier();\n\n for (var k: u32 = 0u; k < TILE_SIZE && w+k < uniforms.K; k++) {\n value += ${f32Type}(tileQ[TILE_SIZE * local_id.y + k] * tileK[TILE_SIZE * local_id.x + k]);\n }\n\n workgroupBarrier();\n }\n\n let headOffset = headIdx * uniforms.M * uniforms.N;\n if (global_id.y < uniforms.M && global_id.x < uniforms.N) {\n let outputIdx = headOffset + global_id.y * uniforms.N + global_id.x;\n var sum: f32 = ${(() => {\n switch (components) {\n case 1:\n return "value";\n case 2:\n return "value.x + value.y";\n case 4:\n return "value.x + value.y + value.z + value.w";\n default:\n throw new Error(`Unsupported components: ${components}`);\n }\n })()};\n\n ${(() => {\n if (relativePositionBiasInput) {\n return `\n let batch = workgroup_id.z / uniforms.num_heads;\n let head = workgroup_id.z % uniforms.num_heads;\n var indices = ${relativePositionBiasInput.type.indices}(batch, head, global_id.y, global_id.x);\n output[outputIdx] = ${output.type.value}(sum * uniforms.alpha) + ${relativePositionBiasInput.getByIndices("indices")};`;\n }\n return `output[outputIdx] = ${output.type.value} (sum * uniforms.alpha);`;\n })()}\n }\n }`;\n };\n return {\n name: "AttentionProbs",\n shaderCache: { hint: `${components}`, inputDependencies },\n getRunData: () => ({\n outputs: [{ dims: probsShape, dataType: q.dataType, gpuDataType: 0 /* default */ }],\n dispatchGroup: dispatch,\n programUniforms\n }),\n getShaderSource\n };\n };\n createVxAttentionScoreProgramInfo = (_context, probs, v, params, pastSequenceLength) => {\n const totalSequenceLength = pastSequenceLength + params.kvSequenceLength;\n const outputShape = [params.batchSize, params.sequenceLength, params.vHiddenSize];\n const TILE_SIZE = 12;\n const dispatch = {\n x: Math.ceil(params.vHeadSize / TILE_SIZE),\n y: Math.ceil(params.sequenceLength / TILE_SIZE),\n z: params.batchSize * params.numHeads\n };\n const programUniforms = [\n { type: 12 /* uint32 */, data: params.sequenceLength },\n { type: 12 /* uint32 */, data: totalSequenceLength },\n { type: 12 /* uint32 */, data: params.vHeadSize },\n { type: 12 /* uint32 */, data: params.numHeads },\n { type: 12 /* uint32 */, data: params.vHiddenSize }\n ];\n const inputDependencies = ["type", "type"];\n const getShaderSource = (shaderHelper) => {\n const probsHelper = inputVariable("probs", probs.dataType, probs.dims);\n const vHelper = inputVariable("v", v.dataType, v.dims);\n const output = outputVariable("output", probs.dataType, outputShape);\n const uniforms = [\n { name: "M", type: "u32" },\n { name: "K", type: "u32" },\n { name: "N", type: "u32" },\n { name: "num_heads", type: "u32" },\n { name: "v_hidden_size", type: "u32" }\n ];\n return `\n const TILE_SIZE = ${TILE_SIZE}u;\n var tileQ: array<${probsHelper.type.value}, ${TILE_SIZE * TILE_SIZE}>;\n var tileK: array<${probsHelper.type.value}, ${TILE_SIZE * TILE_SIZE}>;\n ${shaderHelper.registerUniforms(uniforms).declareVariables(probsHelper, vHelper, output)}\n ${shaderHelper.mainStart([\n TILE_SIZE,\n TILE_SIZE,\n 1\n ])}\n let headIdx = workgroup_id.z;\n let m = global_id.y;\n let n = global_id.x;\n\n let offsetA = headIdx * (uniforms.M * uniforms.K) + m * uniforms.K;\n let offsetB = headIdx * (uniforms.N * uniforms.K) + n;\n\n var value = ${probsHelper.type.storage}(0);\n for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n if (m < uniforms.M && w + local_id.x < uniforms.K) {\n tileQ[TILE_SIZE * local_id.y + local_id.x] = probs[offsetA + w + local_id.x];\n }\n if (n < uniforms.N && w + local_id.y < uniforms.K) {\n tileK[TILE_SIZE * local_id.y + local_id.x] = v[offsetB + (w + local_id.y) * uniforms.N];\n }\n workgroupBarrier();\n for (var k: u32 = 0u; k < TILE_SIZE && w+k < uniforms.K; k++) {\n value += tileQ[TILE_SIZE * local_id.y + k] * tileK[TILE_SIZE * k + local_id.x];\n }\n workgroupBarrier();\n }\n\n // we need to transpose output from BNSH_v to BSND_v\n let batchIdx = workgroup_id.z / uniforms.num_heads;\n let currentBatchHeadNumber = workgroup_id.z % uniforms.num_heads;\n if (m < uniforms.M && n < uniforms.N) {\n let outputIdx = batchIdx * uniforms.M * uniforms.v_hidden_size + m * uniforms.v_hidden_size\n + currentBatchHeadNumber * uniforms.N + n;\n output[outputIdx] = value;\n }\n }`;\n };\n return {\n name: "AttentionScore",\n shaderCache: { inputDependencies },\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: probs.dataType, gpuDataType: 0 /* default */ }],\n dispatchGroup: dispatch,\n programUniforms\n }),\n getShaderSource\n };\n };\n applyAttention = (context, q, k, v, _maskIndex, _past, pastKey, pastValue, relativePositionBias, parameters, attributes) => {\n const outputPresentKey = context.outputCount > 1;\n const outputPresentValue = context.outputCount > 2;\n const pastSequenceLength = outputPresentKey && outputPresentValue ? parameters.pastSequenceLength : 0;\n const totalSequenceLength = pastSequenceLength + parameters.kvSequenceLength;\n const presentKeyShape = [parameters.batchSize, parameters.numHeads, totalSequenceLength, parameters.headSize];\n const concatKeyInputs = pastKey ? [pastKey, k] : [k];\n const key = outputPresentKey ? context.compute(\n createConcatProgramInfo(concatKeyInputs, 2, presentKeyShape, k.dataType),\n { inputs: concatKeyInputs, outputs: [1] }\n )[0] : k;\n const presentValueShape = [parameters.batchSize, parameters.numHeads, totalSequenceLength, parameters.headSize];\n const concatValueInputs = pastValue ? [pastValue, v] : [v];\n const value = outputPresentValue ? context.compute(\n createConcatProgramInfo(concatValueInputs, 2, presentValueShape, v.dataType),\n { inputs: concatValueInputs, outputs: [2] }\n )[0] : v;\n const inputsK = [q, key];\n if (relativePositionBias) {\n inputsK.push(relativePositionBias);\n }\n const probs = context.compute(\n createAttentionProbsProgramInfo(\n context,\n q,\n key,\n relativePositionBias,\n parameters,\n attributes,\n pastSequenceLength\n ),\n { inputs: inputsK, outputs: [-1] }\n )[0];\n context.compute(\n createInPlaceSoftmaxProgramInfo(\n context,\n probs,\n parameters.batchSize * parameters.numHeads * parameters.sequenceLength,\n totalSequenceLength\n ),\n { inputs: [probs], outputs: [] }\n );\n const inputsV = [probs, value];\n context.compute(\n createVxAttentionScoreProgramInfo(context, probs, value, parameters, pastSequenceLength),\n { inputs: inputsV, outputs: [0] }\n );\n };\n prepare = (context, parameters) => {\n const outputShape = [\n parameters.batchSize,\n parameters.numHeads,\n parameters.sequenceLength,\n parameters.headSize\n ];\n const M = parameters.sequenceLength;\n const K = parameters.inputHiddenSize;\n const N = parameters.headSize;\n const TILE_SIZE = 12;\n const dispatch = {\n x: Math.ceil(parameters.headSize / TILE_SIZE),\n y: Math.ceil(parameters.sequenceLength / TILE_SIZE),\n z: parameters.batchSize * parameters.numHeads\n };\n const inputs = [context.inputs[0], context.inputs[1], context.inputs[2]];\n const programUniforms = [\n { type: 12 /* uint32 */, data: M },\n { type: 12 /* uint32 */, data: K },\n { type: 12 /* uint32 */, data: N },\n { type: 12 /* uint32 */, data: parameters.numHeads },\n { type: 12 /* uint32 */, data: parameters.headSize },\n { type: 12 /* uint32 */, data: parameters.hiddenSize },\n { type: 12 /* uint32 */, data: parameters.hiddenSize + parameters.hiddenSize + parameters.vHiddenSize }\n ];\n const getShaderSource = (shaderHelper) => {\n const outputQ = outputVariable("output_q", inputs[0].dataType, outputShape);\n const outputK = outputVariable("output_k", inputs[0].dataType, outputShape);\n const outputV = outputVariable("output_v", inputs[0].dataType, outputShape);\n const input = inputVariable("input", inputs[0].dataType, inputs[0].dims);\n const weight = inputVariable("weight", inputs[1].dataType, inputs[1].dims);\n const bias = inputVariable("bias", inputs[2].dataType, inputs[2].dims);\n const dataType = input.type.storage;\n const uniforms = [\n { name: "M", type: "u32" },\n { name: "K", type: "u32" },\n { name: "N", type: "u32" },\n { name: "num_heads", type: "u32" },\n { name: "head_size", type: "u32" },\n { name: "hidden_size", type: "u32" },\n { name: "ldb", type: "u32" }\n ];\n return `\n const TILE_SIZE = ${TILE_SIZE}u;\n var tileInput: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n var tileWeightQ: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n var tileWeightK: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n var tileWeightV: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n ${shaderHelper.registerUniforms(uniforms).declareVariables(input, weight, bias, outputQ, outputK, outputV)}\n ${shaderHelper.mainStart([\n TILE_SIZE,\n TILE_SIZE,\n 1\n ])}\n let batchIndex = workgroup_id.z / uniforms.num_heads;\n let headNumber = workgroup_id.z % uniforms.num_heads;\n let m = global_id.y;\n let n = global_id.x;\n\n let inputOffset = batchIndex * (uniforms.M * uniforms.K) + m * uniforms.K;\n let biasOffsetQ = headNumber * uniforms.head_size;\n let biasOffsetK = uniforms.hidden_size + biasOffsetQ;\n let biasOffsetV = uniforms.hidden_size + biasOffsetK;\n\n var valueQ = ${dataType}(0);\n var valueK = ${dataType}(0);\n var valueV = ${dataType}(0);\n for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n if (m < uniforms.M && w + local_id.x < uniforms.K) {\n tileInput[TILE_SIZE * local_id.y + local_id.x] = input[inputOffset + w + local_id.x];\n }\n if (n < uniforms.N && w + local_id.y < uniforms.K) {\n let offset = n + (w + local_id.y) * uniforms.ldb;\n tileWeightQ[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetQ + offset];\n tileWeightK[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetK + offset];\n tileWeightV[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetV + offset];\n }\n workgroupBarrier();\n for (var k: u32 = 0u; k ({\n outputs: [\n { dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: 0 /* default */ },\n { dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: 0 /* default */ },\n { dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: 0 /* default */ }\n ],\n dispatchGroup: dispatch,\n programUniforms\n }),\n getShaderSource\n },\n { inputs, outputs: [-1, -1, -1] }\n );\n };\n attention = (context, attributes) => {\n const params = validateAttentionInputs(context.inputs, attributes);\n const [q, k, v] = prepare(context, params);\n return applyAttention(\n context,\n q,\n k,\n v,\n context.inputs[4],\n void 0,\n void 0,\n void 0,\n context.inputs[5],\n params,\n attributes\n );\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/batch-norm.ts\n var validateInputs5, createBatchNormInferenceProgramInfo, parseBatchNormAttributes, batchNorm;\n var init_batch_norm = __esm({\n "web/lib/wasm/jsep/webgpu/ops/batch-norm.ts"() {\n "use strict";\n init_esm();\n init_wasm_common();\n init_util();\n init_attribute_with_cache_key();\n init_common();\n validateInputs5 = (inputs, attributes) => {\n if (!inputs || inputs.length !== 5) {\n throw new Error("BatchNormalization requires 5 inputs");\n }\n const checkShapeEqual = (actual, expected, message) => {\n const r = expected.length;\n if (r !== actual.length) {\n throw new Error(`${message}: num dimensions != ${r}`);\n }\n expected.forEach((v, i) => {\n if (v !== actual[i]) {\n throw new Error(`${message}: dim[${i}] do not match`);\n }\n });\n };\n if (inputs[0].dims.length > 1) {\n const shape = attributes.format === "NHWC" ? attributes.spatial ? inputs[0].dims.slice(-1) : inputs[0].dims.slice(-1).concat(inputs[0].dims.slice(1, inputs[0].dims.length - 1)) : inputs[0].dims.slice(1, attributes.spatial ? 2 : void 0);\n checkShapeEqual(inputs[1].dims, shape, "Invalid input scale");\n checkShapeEqual(inputs[2].dims, shape, "Invalid input B");\n checkShapeEqual(inputs[3].dims, shape, "Invalid input mean");\n checkShapeEqual(inputs[4].dims, shape, "Invalid input var");\n } else {\n checkShapeEqual(inputs[1].dims, [1], "Invalid input scale");\n checkShapeEqual(inputs[2].dims, [1], "Invalid input B");\n checkShapeEqual(inputs[3].dims, [1], "Invalid input mean");\n checkShapeEqual(inputs[4].dims, [1], "Invalid input var");\n }\n };\n createBatchNormInferenceProgramInfo = (inputs, attributes) => {\n const { epsilon, spatial, format } = attributes;\n const yShape = inputs[0].dims;\n const components = spatial ? getMaxComponents(yShape[yShape.length - 1]) : 1;\n const cComponents = format === "NHWC" && yShape.length > 1 ? components : 1;\n const outputSize = ShapeUtil.size(yShape) / components;\n const useShapesUniforms = spatial;\n const shapeOrRank = useShapesUniforms ? yShape.length : yShape;\n const x = inputVariable("x", inputs[0].dataType, inputs[0].dims, components);\n const scale = inputVariable("scale", inputs[1].dataType, inputs[1].dims, cComponents);\n const bias = inputVariable("bias", inputs[2].dataType, inputs[2].dims, cComponents);\n const inputMean = inputVariable("inputMean", inputs[3].dataType, inputs[3].dims, cComponents);\n const inputVar = inputVariable("inputVar", inputs[4].dataType, inputs[4].dims, cComponents);\n const y = outputVariable("y", inputs[0].dataType, shapeOrRank, components);\n const calcCOffset = () => {\n let cOffset = "";\n if (spatial) {\n cOffset = `let cOffset = ${yShape.length === 1 ? "0u" : format === "NHWC" ? `outputIndices[${yShape.length - 1}] / ${components}` : "outputIndices[1]"};`;\n } else {\n if (format === "NCHW") {\n cOffset = `\n ${y.indicesSet("outputIndices", "0", "0")}\n let cOffset = ${y.indicesToOffset("outputIndices")};`;\n } else {\n cOffset = `var cIndices = ${scale.type.indices}(0);\n cIndices[0] = outputIndices[${yShape.length - 1}];`;\n for (let i = 1; i < scale.rank; i++) {\n cOffset += `cIndices[${i}] = outputIndices[${i}];`;\n }\n cOffset += `let cOffset = ${scale.indicesToOffset("cIndices")};`;\n }\n }\n return cOffset;\n };\n const getInferenceModeShaderSource = (helper) => `\n const epsilon = ${epsilon};\n ${helper.registerUniform("outputSize", "u32").declareVariables(x, scale, bias, inputMean, inputVar, y)}\n ${helper.mainStart()}\n ${helper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}\n var outputIndices = ${y.offsetToIndices(`global_idx * ${components}`)};\n ${calcCOffset()}\n let scale = ${scale.getByOffset("cOffset")};\n let bias = ${bias.getByOffset("cOffset")};\n let inputMean = ${inputMean.getByOffset("cOffset")};\n let inputVar = ${inputVar.getByOffset("cOffset")};\n let x = ${x.getByOffset("global_idx")};\n let value = (x - inputMean) * inverseSqrt(inputVar + epsilon) * scale + bias;\n ${y.setByOffset("global_idx", "value")}\n }`;\n return {\n name: "BatchNormalization",\n shaderCache: {\n hint: `${attributes.epsilon}_${attributes.format}_${spatial}_${components}`,\n inputDependencies: useShapesUniforms ? ["rank", "type", "type", "type", "type"] : void 0\n },\n getShaderSource: getInferenceModeShaderSource,\n getRunData: () => ({\n outputs: [{ dims: inputs[0].dims, dataType: inputs[0].dataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms: useShapesUniforms ? [\n { type: 12 /* uint32 */, data: outputSize },\n ...createTensorShapeVariables(yShape)\n ] : [\n { type: 12 /* uint32 */, data: outputSize }\n ]\n })\n };\n };\n parseBatchNormAttributes = (attributes) => createAttributeWithCacheKey(attributes);\n batchNorm = (context, attributes) => {\n const { inputs, outputCount } = context;\n const updatedAttributes = parseBatchNormAttributes({ ...attributes, outputCount });\n if (env2.webgpu.validateInputContent) {\n validateInputs5(inputs, updatedAttributes);\n }\n if (attributes.trainingMode) {\n throw new Error("BatchNormalization trainingMode is not supported yet.");\n } else {\n context.compute(createBatchNormInferenceProgramInfo(inputs, updatedAttributes));\n }\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/bias-add.ts\n var validateInputs6, createBiasAddProgramInfo, biasAdd;\n var init_bias_add = __esm({\n "web/lib/wasm/jsep/webgpu/ops/bias-add.ts"() {\n "use strict";\n init_util();\n init_common();\n validateInputs6 = (inputs) => {\n if (inputs[0].dims.length !== 3) {\n throw new Error("input should have 3 dimensions");\n }\n if (![320, 640, 1280].includes(inputs[0].dims[2])) {\n throw new Error("number of channels should be 320, 640 or 1280");\n }\n if (inputs[1].dims.length !== 1) {\n throw new Error("bias is expected to have 1 dimensions");\n }\n if (inputs[0].dims[2] !== inputs[1].dims[0]) {\n throw new Error("last dimension of input and bias are not the same");\n }\n };\n createBiasAddProgramInfo = (inputs) => {\n const outputShape = inputs[0].dims;\n const channels = inputs[0].dims[2];\n const outputSize = ShapeUtil.size(outputShape) / 4;\n const dataType = inputs[0].dataType;\n const input = inputVariable("input", dataType, outputShape, 4);\n const bias = inputVariable("bias", dataType, [channels], 4);\n const residual = inputVariable("residual", dataType, outputShape, 4);\n const output = outputVariable("output", dataType, outputShape, 4);\n const getShaderSource = (shaderHelper) => `\n const channels = ${channels}u / 4;\n ${shaderHelper.declareVariables(input, bias, residual, output)}\n\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}\n let value = ${input.getByOffset("global_idx")}\n + ${bias.getByOffset("global_idx % channels")} + ${residual.getByOffset("global_idx")};\n ${output.setByOffset("global_idx", "value")}\n }`;\n return {\n name: "BiasAdd",\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) }\n }),\n getShaderSource\n };\n };\n biasAdd = (context) => {\n validateInputs6(context.inputs);\n context.compute(createBiasAddProgramInfo(context.inputs));\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/unary-op.ts\n var createElementwiseProgramShader, createElementwiseProgramInfo, abs, acos, acosh, asin, asinh, atan, atanh, parseCastAttributes, cast, generateClipAttributesFromInputs, clip, ceil, cos, cosh, parseAlphaAttributes, elu, erfImpl, erf, exp, floor, gelu, leakyRelu, not, neg, reciprocal, relu, sigmoid, parseHardSigmoidAttributes, hardSigmoid, sin, sinh, sqrt, tan, tanhExpression, tanh, fastGeluImpl, fastGeluExpression, fastGelu, thresholdedRelu, log;\n var init_unary_op = __esm({\n "web/lib/wasm/jsep/webgpu/ops/unary-op.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_attribute_with_cache_key();\n init_common();\n createElementwiseProgramShader = (shaderHelper, datasize, inputDataType, outputDataType, funcCall, additionalImplementation) => {\n const vecSize = Math.ceil(datasize / 4);\n let expression = "";\n if (typeof funcCall === "string") {\n expression = `${funcCall}(a)`;\n } else {\n expression = funcCall("a");\n }\n const input = inputVariable("inputData", inputDataType, [vecSize], 4);\n const output = outputVariable("outputData", outputDataType, [vecSize], 4);\n return `\n ${shaderHelper.registerUniform("vec_size", "u32").declareVariables(input, output)}\n\n ${additionalImplementation ?? ""}\n\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.vec_size")}\n\n let a = ${input.getByOffset("global_idx")};\n ${output.setByOffset("global_idx", expression)}\n }`;\n };\n createElementwiseProgramInfo = (input, name, funcCall, additionalImplementation, cacheKey, outputDataType = input.dataType) => ({\n name,\n shaderCache: { hint: cacheKey, inputDependencies: ["type"] },\n getShaderSource: (shaderHelper) => createElementwiseProgramShader(\n shaderHelper,\n ShapeUtil.size(input.dims),\n input.dataType,\n outputDataType,\n funcCall,\n additionalImplementation\n ),\n getRunData: (inputTensors) => ({\n outputs: [{ dims: input.dims, dataType: outputDataType }],\n dispatchGroup: { x: Math.ceil(\n ShapeUtil.size(inputTensors[0].dims) / 64 / 4\n /* vec size */\n ) },\n programUniforms: [\n { type: 12 /* uint32 */, data: Math.ceil(ShapeUtil.size(input.dims) / 4) }\n ]\n })\n });\n abs = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Abs", "abs"));\n };\n acos = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Acos", "acos"));\n };\n acosh = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Acosh", "acosh"));\n };\n asin = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Asin", "asin"));\n };\n asinh = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Asinh", "asinh"));\n };\n atan = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Atan", "atan"));\n };\n atanh = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Atanh", "atanh"));\n };\n parseCastAttributes = (attributes) => createAttributeWithCacheKey(attributes);\n cast = (context, attributes) => {\n let func;\n switch (attributes.to) {\n case 10 /* float16 */:\n func = "vec4";\n break;\n case 1 /* float */:\n func = "vec4";\n break;\n case 12 /* uint32 */:\n func = "vec4";\n break;\n case 6 /* int32 */:\n func = "vec4";\n break;\n case 9 /* bool */:\n func = "vec4";\n break;\n default:\n throw new RangeError(`not supported type (specified in attribute \'to\' from \'Cast\' operator): ${attributes.to}`);\n }\n context.compute(\n createElementwiseProgramInfo(context.inputs[0], "Cast", func, void 0, attributes.cacheKey, attributes.to)\n );\n };\n generateClipAttributesFromInputs = (inputs) => {\n const min = inputs.length >= 2 && inputs[1].data !== 0 ? inputs[1].getFloat32Array()[0] : MIN_CLIP;\n const max = inputs.length >= 3 && inputs[2].data !== 0 ? inputs[2].getFloat32Array()[0] : MAX_CLIP;\n return createAttributeWithCacheKey({ min, max });\n };\n clip = (context, clipAttributes) => {\n const attributes = context.inputs.length === 1 ? clipAttributes : generateClipAttributesFromInputs(context.inputs);\n const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n context.compute(\n createElementwiseProgramInfo(\n context.inputs[0],\n "Clip",\n (a) => `clamp(${a}, clip_min_, clip_max_)`,\n `\n const clip_min_: vec4<${dataType}> = vec4(${dataType}(${attributes.min}));\n const clip_max_: vec4<${dataType}> = vec4(${dataType}(${attributes.max}));\n`,\n attributes.cacheKey\n ),\n { inputs: [0] }\n );\n };\n ceil = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Ceil", "ceil"));\n };\n cos = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Cos", "cos"));\n };\n cosh = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Cosh", "cosh"));\n };\n parseAlphaAttributes = (attributes) => createAttributeWithCacheKey(attributes);\n elu = (context, attributes) => {\n const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n context.compute(createElementwiseProgramInfo(\n context.inputs[0],\n "Elu",\n (a) => `elu_vf32(${a})`,\n `\n const elu_alpha_ = ${dataType}(${attributes.alpha});\n\n fn elu_f32(a: ${dataType}) -> ${dataType} {\n return select((exp(a) - 1.0) * elu_alpha_, a, a >= 0.0);\n }\n\n fn elu_vf32(v: vec4<${dataType}>) -> vec4<${dataType}> {\n return vec4(elu_f32(v.x), elu_f32(v.y), elu_f32(v.z), elu_f32(v.w));\n }`,\n attributes.cacheKey\n ));\n };\n erfImpl = (varType = "f32") => `\nconst r0: ${varType} = 0.3275911;\nconst r1: ${varType} = 0.254829592;\nconst r2: ${varType} = -0.284496736;\nconst r3: ${varType} = 1.421413741;\nconst r4: ${varType} = -1.453152027;\nconst r5: ${varType} = 1.061405429;\n\nfn erf_vf32(v: vec4<${varType}>) -> vec4<${varType}> {\n let absv = abs(v);\n let x = 1.0 / (1.0 + r0 * absv);\n return sign(v) * (1.0 - ((((r5 * x + r4) * x + r3) * x + r2) * x + r1) * x * exp(-absv * absv));\n}`;\n erf = (context) => {\n const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Erf", (a) => `erf_vf32(${a})`, erfImpl(dataType)));\n };\n exp = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Exp", "exp"));\n };\n floor = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Floor", "floor"));\n };\n gelu = (context) => {\n const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n context.compute(createElementwiseProgramInfo(\n context.inputs[0],\n "Gelu",\n (a) => `0.5 * ${a} * (1.0 + erf_vf32(${a} * 0.7071067811865475))`,\n erfImpl(dataType)\n ));\n };\n leakyRelu = (context, attributes) => {\n const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n context.compute(createElementwiseProgramInfo(\n context.inputs[0],\n "LeakyRelu",\n (a) => `select(leaky_relu_alpha_ * ${a}, ${a}, ${a} >= vec4<${dataType}>(0.0))`,\n `const leaky_relu_alpha_ = ${dataType}(${attributes.alpha});`,\n attributes.cacheKey\n ));\n };\n not = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Not", (a) => `!${a}`));\n };\n neg = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Neg", (a) => `-${a}`));\n };\n reciprocal = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Reciprocal", (a) => `1.0/${a}`));\n };\n relu = (context) => {\n const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n context.compute(createElementwiseProgramInfo(\n context.inputs[0],\n "Relu",\n (a) => `select(vec4<${dataType}>(0.0), ${a}, ${a} > vec4<${dataType}>(0.0))`\n ));\n };\n sigmoid = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Sigmoid", (a) => `(1.0 / (1.0 + exp(-${a})))`));\n };\n parseHardSigmoidAttributes = (attributes) => createAttributeWithCacheKey(attributes);\n hardSigmoid = (context, attributes) => {\n const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n context.compute(createElementwiseProgramInfo(\n context.inputs[0],\n "HardSigmoid",\n (a) => `max(vec4<${dataType}>(0.0), min(vec4<${dataType}>(1.0), ${attributes.alpha} * ${a} + vec4<${dataType}>(${attributes.beta})))`,\n void 0,\n attributes.cacheKey\n ));\n };\n sin = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Sin", "sin"));\n };\n sinh = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Sinh", "sinh"));\n };\n sqrt = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Sqrt", "sqrt"));\n };\n tan = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Tan", "tan"));\n };\n tanhExpression = (a) => `sign(${a}) * (1 - exp(-2 * abs(${a}))) / (1 + exp(-2 * abs(${a})))`;\n tanh = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Tanh", tanhExpression));\n };\n fastGeluImpl = (varType = "f32") => `\nconst fast_gelu_a: ${varType} = 0.5;\nconst fast_gelu_b: ${varType} = 0.7978845608028654;\nconst fast_gelu_c: ${varType} = 0.035677408136300125;\n\nfn tanh_v(v: vec4<${varType}>) -> vec4<${varType}> {\n return ${tanhExpression("v")};\n}\n`;\n fastGeluExpression = (x) => `(fast_gelu_a + fast_gelu_a * tanh_v(${x} * (fast_gelu_c * ${x} * ${x} + fast_gelu_b))) * ${x}`;\n fastGelu = (context) => {\n const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n context.compute(createElementwiseProgramInfo(\n context.inputs[0],\n "FastGelu",\n fastGeluExpression,\n fastGeluImpl(dataType),\n void 0,\n context.inputs[0].dataType\n ));\n };\n thresholdedRelu = (context, attributes) => {\n const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n context.compute(createElementwiseProgramInfo(\n context.inputs[0],\n "ThresholdedRelu",\n (a) => `select(vec4<${dataType}>(0.0), ${a}, ${a} > thresholded_relu_alpha_)`,\n `const thresholded_relu_alpha_ = vec4<${dataType}>(${attributes.alpha});`,\n attributes.cacheKey\n ));\n return 0;\n };\n log = (context) => {\n context.compute(createElementwiseProgramInfo(context.inputs[0], "Log", "log"));\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/bias-split-gelu.ts\n var validateInputs7, createBiasSplitGeluProgramInfo, biasSplitGelu;\n var init_bias_split_gelu = __esm({\n "web/lib/wasm/jsep/webgpu/ops/bias-split-gelu.ts"() {\n "use strict";\n init_util();\n init_common();\n init_unary_op();\n validateInputs7 = (inputs) => {\n if (inputs[0].dims.length !== 3) {\n throw new Error("input should have 3 dimensions");\n }\n if (![2560, 5120, 10240].includes(inputs[0].dims[2])) {\n throw new Error("hidden state should be 2560, 5120 or 10240");\n }\n if (inputs[1].dims.length !== 1) {\n throw new Error("bias is expected to have 1 dimensions");\n }\n if (inputs[0].dims[2] !== inputs[1].dims[0]) {\n throw new Error("last dimension of input and bias are not the same");\n }\n };\n createBiasSplitGeluProgramInfo = (inputs) => {\n const outputShape = inputs[0].dims.slice();\n outputShape[2] = outputShape[2] / 2;\n const input = inputVariable("input", inputs[0].dataType, inputs[0].dims, 4);\n const bias = inputVariable("bias", inputs[0].dataType, [inputs[0].dims[2]], 4);\n const output = outputVariable("output", inputs[0].dataType, outputShape, 4);\n const outputSize = ShapeUtil.size(outputShape) / 4;\n const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n const getShaderSource = (shaderHelper) => `\n const M_SQRT2 = sqrt(2.0);\n const halfChannels = ${inputs[0].dims[2] / 4 / 2}u;\n\n ${shaderHelper.declareVariables(input, bias, output)}\n\n ${erfImpl(dataType)}\n\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}\n let biasIdx = global_idx % halfChannels;\n let batchIndex = global_idx / halfChannels;\n let inputOffset = biasIdx + batchIndex * halfChannels * 2;\n let valueLeft = input[inputOffset] + bias[biasIdx];\n let valueRight = input[inputOffset + halfChannels] + bias[biasIdx + halfChannels];\n let geluRight = valueRight * 0.5 * (erf_vf32(valueRight / M_SQRT2) + 1);\n\n ${output.setByOffset("global_idx", "valueLeft * geluRight")}\n }`;\n return {\n name: "BiasSplitGelu",\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) }\n }),\n getShaderSource\n };\n };\n biasSplitGelu = (context) => {\n validateInputs7(context.inputs);\n context.compute(createBiasSplitGeluProgramInfo(context.inputs));\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/binary-op.ts\n var createBinaryOpProgramShader, createBinaryOpProgramInfo, runBinaryOp, add, div, equal, mul, pow, sub, greater, less, greaterOrEqual, lessOrEqual;\n var init_binary_op = __esm({\n "web/lib/wasm/jsep/webgpu/ops/binary-op.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_common();\n createBinaryOpProgramShader = (shaderHelper, dimsA, dimsB, dimsOutput, vectorize, doBroadcast, sharedDimensionDivisibleBy4, funcCall, typeA, typeB, typeOutput, additionalImplementation) => {\n let expressionScalar;\n let expressionVector;\n if (typeof funcCall === "string") {\n expressionScalar = expressionVector = (a2, b2) => `${funcCall}((${a2}),(${b2}))`;\n } else if (typeof funcCall === "function") {\n expressionScalar = expressionVector = funcCall;\n } else {\n expressionScalar = funcCall.scalar;\n expressionVector = funcCall.vector;\n }\n const output = outputVariable("outputData", typeOutput, dimsOutput.length, 4);\n const a = inputVariable("aData", typeA, dimsA.length, 4);\n const b = inputVariable("bData", typeB, dimsB.length, 4);\n let assignment;\n if (vectorize) {\n if (doBroadcast) {\n const isAOneElement = ShapeUtil.size(dimsA) === 1;\n const isBOneElement = ShapeUtil.size(dimsB) === 1;\n const aLastDimDivisibleBy4 = dimsA.length > 0 && dimsA[dimsA.length - 1] % 4 === 0;\n const bLastDimDivisibleBy4 = dimsB.length > 0 && dimsB[dimsB.length - 1] % 4 === 0;\n if (isAOneElement || isBOneElement) {\n assignment = output.setByOffset(\n "global_idx",\n expressionVector(\n isAOneElement ? `${a.type.value}(${a.getByOffset("0")}.x)` : a.getByOffset("global_idx"),\n isBOneElement ? `${b.type.value}(${b.getByOffset("0")}.x)` : b.getByOffset("global_idx")\n )\n );\n } else {\n assignment = `\n let outputIndices = ${output.offsetToIndices("global_idx * 4u")};\n let offsetA = ${a.broadcastedIndicesToOffset("outputIndices", output)};\n let offsetB = ${b.broadcastedIndicesToOffset("outputIndices", output)};\n ${output.setByOffset(\n "global_idx",\n expressionVector(\n sharedDimensionDivisibleBy4 || aLastDimDivisibleBy4 ? a.getByOffset("offsetA / 4u") : `${a.type.value}(${a.getByOffset("offsetA / 4u")}[offsetA % 4u])`,\n sharedDimensionDivisibleBy4 || bLastDimDivisibleBy4 ? b.getByOffset("offsetB / 4u") : `${b.type.value}(${b.getByOffset("offsetB / 4u")}[offsetB % 4u])`\n )\n )}\n `;\n }\n } else {\n assignment = output.setByOffset(\n "global_idx",\n expressionVector(a.getByOffset("global_idx"), b.getByOffset("global_idx"))\n );\n }\n } else {\n if (!doBroadcast) {\n throw new Error("no necessary to use scalar implementation for element-wise binary op implementation.");\n }\n const singleAssignment = (resStr, x, typeCast = "") => {\n const expressionA = `aData[indexA${x}][componentA${x}]`;\n const expressionB = `bData[indexB${x}][componentB${x}]`;\n return `\n let outputIndices${x} = ${output.offsetToIndices(`global_idx * 4u + ${x}u`)};\n let offsetA${x} = ${a.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n let offsetB${x} = ${b.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n let indexA${x} = offsetA${x} / 4u;\n let indexB${x} = offsetB${x} / 4u;\n let componentA${x} = offsetA${x} % 4u;\n let componentB${x} = offsetB${x} % 4u;\n ${resStr}[${x}] = ${typeCast}(${expressionScalar(expressionA, expressionB)});\n `;\n };\n if (typeOutput === 9 /* bool */) {\n assignment = `\n var data = vec4(0);\n ${singleAssignment("data", 0, "u32")}\n ${singleAssignment("data", 1, "u32")}\n ${singleAssignment("data", 2, "u32")}\n ${singleAssignment("data", 3, "u32")}\n outputData[global_idx] = dot(vec4(0x1, 0x100, 0x10000, 0x1000000), vec4(data));`;\n } else {\n assignment = `\n ${singleAssignment("outputData[global_idx]", 0)}\n ${singleAssignment("outputData[global_idx]", 1)}\n ${singleAssignment("outputData[global_idx]", 2)}\n ${singleAssignment("outputData[global_idx]", 3)}\n `;\n }\n }\n return `\n ${shaderHelper.registerUniform("vec_size", "u32").declareVariables(a, b, output)}\n\n ${additionalImplementation ?? ""}\n\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.vec_size")}\n ${assignment}\n }`;\n };\n createBinaryOpProgramInfo = (name, cacheKey, a, b, funcCall, additionalImplementation, outputDataType = a.dataType) => {\n const isBroadcast = !ShapeUtil.areEqual(a.dims, b.dims);\n let outputShape = a.dims;\n let outputSize = ShapeUtil.size(a.dims);\n let vectorize = false;\n let sharedDimensionDivisibleBy4 = false;\n const cacheKeyAux = [isBroadcast];\n if (isBroadcast) {\n const calculatedShape = BroadcastUtil.calcShape(a.dims, b.dims, false);\n if (!calculatedShape) {\n throw new Error("Can\'t perform binary op on the given tensors");\n }\n outputShape = calculatedShape;\n outputSize = ShapeUtil.size(outputShape);\n const isAOneElement = ShapeUtil.size(a.dims) === 1;\n const isBOneElement = ShapeUtil.size(b.dims) === 1;\n const aLastDimDivisibleBy4 = a.dims.length > 0 && a.dims[a.dims.length - 1] % 4 === 0;\n const bLastDimDivisibleBy4 = b.dims.length > 0 && b.dims[b.dims.length - 1] % 4 === 0;\n cacheKeyAux.push(isAOneElement);\n cacheKeyAux.push(isBOneElement);\n cacheKeyAux.push(aLastDimDivisibleBy4);\n cacheKeyAux.push(bLastDimDivisibleBy4);\n let sharedDimension = 1;\n for (let i = 1; i < outputShape.length; i++) {\n const dimA = a.dims[a.dims.length - i] ?? 1;\n const dimB = b.dims[b.dims.length - i] ?? 1;\n if (dimA === dimB) {\n sharedDimension *= dimA;\n } else {\n break;\n }\n }\n if (sharedDimension % 4 === 0) {\n sharedDimensionDivisibleBy4 = true;\n vectorize = true;\n } else if (isAOneElement || isBOneElement || aLastDimDivisibleBy4 || bLastDimDivisibleBy4) {\n vectorize = true;\n }\n } else {\n vectorize = true;\n }\n cacheKeyAux.push(vectorize);\n return {\n name,\n shaderCache: {\n hint: cacheKey + cacheKeyAux.map((x) => x.toString()).join("_"),\n inputDependencies: ["rank", "rank"]\n },\n getShaderSource: (shaderHelper) => createBinaryOpProgramShader(\n shaderHelper,\n a.dims,\n b.dims,\n outputShape,\n vectorize,\n isBroadcast,\n sharedDimensionDivisibleBy4,\n funcCall,\n a.dataType,\n b.dataType,\n outputDataType,\n additionalImplementation\n ),\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: outputDataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64 / 4\n /* component size */\n ) },\n programUniforms: [\n { type: 12 /* uint32 */, data: Math.ceil(ShapeUtil.size(outputShape) / 4) },\n ...createTensorShapeVariables(a.dims, b.dims, outputShape)\n ]\n })\n };\n };\n runBinaryOp = (context, name, funcCall, additionalImplementation, cacheKey, outputDataType) => {\n context.compute(createBinaryOpProgramInfo(\n name,\n cacheKey ?? "",\n context.inputs[0],\n context.inputs[1],\n funcCall,\n additionalImplementation,\n outputDataType\n ));\n };\n add = (context) => {\n runBinaryOp(context, "Add", (a, b) => `${a}+${b}`);\n };\n div = (context) => {\n runBinaryOp(context, "Div", (a, b) => `${a}/${b}`);\n };\n equal = (context) => {\n runBinaryOp(\n context,\n "Equal",\n { scalar: (a, b) => `u32(${a}==${b})`, vector: (a, b) => `vec4(${a}==${b})` },\n void 0,\n void 0,\n 9 /* bool */\n );\n };\n mul = (context) => {\n runBinaryOp(context, "Mul", (a, b) => `${a}*${b}`);\n };\n pow = (context) => {\n const type = inputVariable("input", context.inputs[0].dataType, context.inputs[0].dims).type.value;\n const roundStr = type === "i32" ? "round" : "";\n runBinaryOp(\n context,\n "Pow",\n { scalar: (a, b) => `pow_custom(${a},${b})`, vector: (a, b) => `pow_vector_custom(${a},${b})` },\n `\n fn pow_custom(a : ${type}, b : ${type}) -> ${type} {\n if (b == ${type}(0.0)) {\n return ${type}(1.0);\n } else if (a < ${type}(0.0) && f32(b) != floor(f32(b))) {\n return ${type}(pow(f32(a), f32(b))); // NaN\n }\n return select(sign(a), ${type}(1.0), round(f32(abs(b) % ${type}(2.0))) != 1.0) * ${type}(${roundStr}(pow(f32(abs(a)), f32(b))));\n }\n fn pow_vector_custom(a : vec4<${type}>, b : vec4<${type}>) -> vec4<${type}> {\n // TODO: implement vectorized pow\n return vec4<${type}>(pow_custom(a.x, b.x), pow_custom(a.y, b.y), pow_custom(a.z, b.z), pow_custom(a.w, b.w));\n }\n `\n );\n };\n sub = (context) => {\n runBinaryOp(context, "Sub", (a, b) => `${a}-${b}`);\n };\n greater = (context) => {\n runBinaryOp(\n context,\n "Greater",\n { scalar: (a, b) => `u32(${a}>${b})`, vector: (a, b) => `vec4(${a}>${b})` },\n void 0,\n void 0,\n 9 /* bool */\n );\n };\n less = (context) => {\n runBinaryOp(\n context,\n "Less",\n { scalar: (a, b) => `u32(${a}<${b})`, vector: (a, b) => `vec4(${a}<${b})` },\n void 0,\n void 0,\n 9 /* bool */\n );\n };\n greaterOrEqual = (context) => {\n runBinaryOp(\n context,\n "GreaterOrEqual",\n { scalar: (a, b) => `u32(${a}>=${b})`, vector: (a, b) => `vec4(${a}>=${b})` },\n void 0,\n void 0,\n 9 /* bool */\n );\n };\n lessOrEqual = (context) => {\n runBinaryOp(\n context,\n "LessOrEqual",\n { scalar: (a, b) => `u32(${a}<=${b})`, vector: (a, b) => `vec4(${a}<=${b})` },\n void 0,\n void 0,\n 9 /* bool */\n );\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/fuse-utils.ts\n var getActivationSnippet, appendActivationUniformsData, appendActivationUniforms, parseInternalActivationAttributes;\n var init_fuse_utils = __esm({\n "web/lib/wasm/jsep/webgpu/ops/fuse-utils.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n getActivationSnippet = (attributes, valueType, baseType = "f32") => {\n switch (attributes.activation) {\n case "Relu":\n return `value = max(value, ${valueType}(0.0));`;\n case "Sigmoid":\n return `value = (${valueType}(1.0) / (${valueType}(1.0) + exp(-value)));`;\n case "Clip":\n return `value = clamp(value, ${valueType}(${baseType}(uniforms.clip_min)), ${valueType}(${baseType}(uniforms.clip_max)));`;\n case "HardSigmoid":\n return `value = max(${valueType}(0.0), min(${valueType}(1.0), ${baseType}(uniforms.alpha) * value + ${baseType}(uniforms.beta)));`;\n case "LeakyRelu":\n return `value = select(${baseType}(uniforms.alpha) * value, value, value >= ${valueType}(0.0));`;\n case "":\n return "";\n default:\n throw new Error(`Unsupported activation ${attributes.activation}`);\n }\n };\n appendActivationUniformsData = (attributes, programUniform) => {\n if (attributes.activation === "Clip") {\n programUniform.push(\n { type: 1 /* float */, data: attributes.clipMax },\n { type: 1 /* float */, data: attributes.clipMin }\n );\n } else if (attributes.activation === "HardSigmoid") {\n programUniform.push(\n { type: 1 /* float */, data: attributes.alpha },\n { type: 1 /* float */, data: attributes.beta }\n );\n } else if (attributes.activation === "LeakyRelu") {\n programUniform.push({ type: 1 /* float */, data: attributes.alpha });\n }\n };\n appendActivationUniforms = (attributes, uniforms) => {\n if (attributes.activation === "Clip") {\n uniforms.push({ name: "clip_max", type: "f32" }, { name: "clip_min", type: "f32" });\n } else if (attributes.activation === "HardSigmoid") {\n uniforms.push({ name: "alpha", type: "f32" }, { name: "beta", type: "f32" });\n } else if (attributes.activation === "LeakyRelu") {\n uniforms.push({ name: "alpha", type: "f32" });\n }\n };\n parseInternalActivationAttributes = (attributes) => {\n const activation = attributes?.activation || "";\n if (activation === "HardSigmoid") {\n const [alpha, beta] = attributes?.activation_params || [0.2, 0.5];\n return { activation, alpha, beta };\n } else if (activation === "Clip") {\n const [clipMin, clipMax] = attributes?.activation_params || [MIN_CLIP, MAX_CLIP];\n return { activation, clipMax, clipMin };\n } else if (activation === "LeakyRelu") {\n const [alpha] = attributes?.activation_params || [0.01];\n return { activation, alpha };\n }\n return { activation };\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/3rd-party/activation_util.ts\n var typeSnippet, biasSnippet;\n var init_activation_util = __esm({\n "web/lib/wasm/jsep/webgpu/ops/3rd-party/activation_util.ts"() {\n "use strict";\n typeSnippet = (component, dataType) => {\n switch (component) {\n case 1:\n return dataType;\n case 2:\n return `vec2<${dataType}>`;\n case 3:\n return `vec3<${dataType}>`;\n case 4:\n return `vec4<${dataType}>`;\n default:\n throw new Error(`${component}-component is not supported.`);\n }\n };\n biasSnippet = (hasBias) => `\n ${hasBias ? "value = value + getBiasByOutputCoords(coords);" : ""}\n `;\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_util.ts\n var utilFunctions;\n var init_conv_util = __esm({\n "web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_util.ts"() {\n "use strict";\n utilFunctions = (strideStr) => `\nfn getIndexFromCoords4D(coords : vec4, shape : vec4) -> i32 {\n return dot(coords, vec4(\n shape.y * shape.z * shape.w, shape.z * shape.w, shape.w, 1));\n}\nfn getOutputIndexFromCoords(coords : vec4) -> i32 {\n return dot(coords, vec4(\n i32(${strideStr}.x), i32(${strideStr}.y), i32(${strideStr}.z), 1));\n}\n`;\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/3rd-party/matmul_packed_webgpu.ts\n var writeDataToSubAVec4Snippet, calculateResultSnippet, makeMatMulPackedVec4Source, writeDataToSubASnippet, readDataFromSubASnippet, makeMatMulPackedSource, matMulReadWriteFnSource, createMatmulProgramInfo;\n var init_matmul_packed_webgpu = __esm({\n "web/lib/wasm/jsep/webgpu/ops/3rd-party/matmul_packed_webgpu.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_common();\n init_fuse_utils();\n init_activation_util();\n writeDataToSubAVec4Snippet = (transpose2, batchDims) => {\n if (transpose2) {\n return `\n mm_Asub[inputRow][inputCol] = mm_readA(batch,\n kStart + inputRow,\n globalRowStart / innerElementSize + inputCol${batchDims ? ", batchIndices" : ""});\n `;\n } else {\n return `\n mm_Asub[inputRow][inputCol] = mm_readA(batch,\n globalRow + innerRow,\n kStart / innerElementSize + inputCol${batchDims ? ", batchIndices" : ""});\n `;\n }\n };\n calculateResultSnippet = (transposeA, innerElementSize) => {\n if (transposeA) {\n return `\n let ACached0 = mm_Asub[k * innerElementSize][localRow];\n let ACached1 = mm_Asub[k * innerElementSize + 1][localRow];\n let ACached2 = mm_Asub[k * innerElementSize + 2][localRow];\n ${innerElementSize === 3 ? "" : "let ACached3 = mm_Asub[k * innerElementSize + 3][localRow];"}\n for (var i = 0; i < rowPerThread; i = i + 1) {\n acc[i] = BCached0 * ACached0[i] + acc[i];\n acc[i] = BCached1 * ACached1[i] + acc[i];\n acc[i] = BCached2 * ACached2[i] + acc[i];\n ${innerElementSize === 3 ? "" : "acc[i] = BCached3 * ACached3[i] + acc[i];"}\n }`;\n } else {\n return `\n for (var i = 0; i < rowPerThread; i = i + 1) {\n let ACached = mm_Asub[tileRow + i][k];\n acc[i] = BCached0 * ACached.x + acc[i];\n acc[i] = BCached1 * ACached.y + acc[i];\n acc[i] = BCached2 * ACached.z + acc[i];\n ${innerElementSize === 3 ? "" : "acc[i] = BCached3 * ACached.w + acc[i];"}\n }`;\n }\n };\n makeMatMulPackedVec4Source = (workPerThread, workgroupSize, type = "f32", batchDims, transposeA = false, tileInner = 32, splitK = false, splitedDimInner = 32) => {\n const tileAOuter = workgroupSize[1] * workPerThread[1];\n const tileBOuter = workgroupSize[0] * workPerThread[0];\n const tileAWidth = transposeA ? tileAOuter : tileInner;\n const tileAHight = transposeA ? tileInner : tileAOuter;\n const innerElementSize = tileAWidth / workgroupSize[0];\n const rowPerThreadB = tileInner / workgroupSize[1];\n if (!((transposeA && innerElementSize === 4 && workPerThread[1] === 4 || !transposeA && (innerElementSize === 3 || innerElementSize === 4)) && tileAWidth % workgroupSize[0] === 0 && tileInner % workgroupSize[1] === 0 && workPerThread[0] === 4)) {\n throw new Error(`If transposeA ${transposeA} is true, innerElementSize ${innerElementSize} and workPerThread[1] ${workPerThread[1]} must be 4.\n Otherwise, innerElementSize ${innerElementSize} must be 3 or 4.\n tileAWidth ${tileAWidth} must be divisible by workgroupSize[0]${workgroupSize[0]}. tileInner ${tileInner} must be divisible by workgroupSize[1] ${workgroupSize[1]}. colPerThread ${workPerThread[0]} must be 4.`);\n }\n return `\nvar mm_Asub: array, ${tileAWidth / innerElementSize}>, ${tileAHight}>;\nvar mm_Bsub: array, ${tileBOuter / workPerThread[0]}>, ${tileInner}>;\n\nconst rowPerThread = ${workPerThread[1]};\nconst colPerThread = ${workPerThread[0]};\nconst innerElementSize = ${innerElementSize};\nconst tileInner = ${tileInner};\n\n@compute @workgroup_size(${workgroupSize[0]}, ${workgroupSize[1]}, ${workgroupSize[2]})\nfn main(@builtin(local_invocation_id) localId : vec3,\n @builtin(global_invocation_id) globalId : vec3,\n @builtin(workgroup_id) workgroupId : vec3) {\n let localRow = i32(localId.y);\n let tileRow = localRow * rowPerThread;\n let tileCol = i32(localId.x);\n\n let globalRow =i32(globalId.y) * rowPerThread;\n let globalCol = i32(globalId.x);\n let batch = ${splitK ? "0" : "i32(globalId.z)"};\n ${batchDims ? `let batchIndices = ${batchDims.offsetToIndices("u32(batch)")};` : ""}\n let globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n\n let num_tiles = ${splitK ? `${Math.ceil(splitedDimInner / tileInner)}` : "(uniforms.dim_inner - 1) / tileInner + 1"};\n var kStart = ${splitK ? `i32(globalId.z) * ${splitedDimInner}` : "0"};\n\n var acc: array, rowPerThread>;\n\n // Loop over shared dimension.\n let tileRowB = localRow * ${rowPerThreadB};\n for (var t = 0; t < num_tiles; t = t + 1) {\n // Load one tile of A into local memory.\n for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n let inputRow = tileRow + innerRow;\n let inputCol = tileCol;\n ${writeDataToSubAVec4Snippet(transposeA, batchDims)}\n }\n\n // Load one tile of B into local memory.\n for (var innerRow = 0; innerRow < ${rowPerThreadB}; innerRow = innerRow + 1) {\n let inputRow = tileRowB + innerRow;\n let inputCol = tileCol;\n mm_Bsub[inputRow][inputCol] = mm_readB(batch, kStart + inputRow, globalCol${batchDims ? ", batchIndices" : ""});\n }\n kStart = kStart + tileInner;\n workgroupBarrier();\n\n // Compute acc values for a single thread.\n for (var k = 0; k < tileInner / innerElementSize; k = k + 1) {\n let BCached0 = mm_Bsub[k * innerElementSize][tileCol];\n let BCached1 = mm_Bsub[k * innerElementSize + 1][tileCol];\n let BCached2 = mm_Bsub[k * innerElementSize + 2][tileCol];\n ${innerElementSize === 3 ? "" : "let BCached3 = mm_Bsub[k * innerElementSize + 3][tileCol];"}\n\n ${calculateResultSnippet(transposeA, innerElementSize)}\n }\n\n workgroupBarrier();\n }\n\n for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n mm_write(batch, globalRow + innerRow, globalCol, acc[innerRow]);\n }\n}`;\n };\n writeDataToSubASnippet = (transpose2, batchDims) => {\n if (transpose2) {\n return `\n mm_Asub[inputRow][inputCol] = mm_readA(batch,\n kStart + inputRow,\n globalRowStart + inputCol${batchDims ? ", batchIndices" : ""});\n `;\n } else {\n return `\n mm_Asub[inputRow][inputCol] = mm_readA(batch,\n globalRowStart + inputRow,\n kStart + inputCol${batchDims ? ", batchIndices" : ""});\n `;\n }\n };\n readDataFromSubASnippet = (transposeA) => transposeA ? "let ACached = mm_Asub[k][tileRow + innerRow];" : "let ACached = mm_Asub[tileRow + innerRow][k];";\n makeMatMulPackedSource = (workPerThread, workgroupSize, type = "f32", batchDims, transposeA = false, tileInner = 32, splitK = false, splitedDimInner = 32, sequentialAccessByThreads = false) => {\n const tileAOuter = workPerThread[1] * workgroupSize[1];\n const tileBOuter = workPerThread[0] * workgroupSize[0];\n const tileAWidth = transposeA ? tileAOuter : tileInner;\n const tileAHight = transposeA ? tileInner : tileAOuter;\n if (!(tileAHight % workgroupSize[1] === 0 && tileAWidth % workgroupSize[0] === 0 && tileInner % workgroupSize[1] === 0)) {\n throw new Error(`tileAHight ${tileAHight} must be divisible by workgroupSize[1]${workgroupSize[1]}, tileAWidth ${tileAWidth} must be divisible by workgroupSize[0]${workgroupSize[0]}, tileInner ${tileInner} must be divisible by workgroupSize[1]${workgroupSize[1]}`);\n }\n const rowPerThreadA = tileAHight / workgroupSize[1];\n const colPerThreadA = tileAWidth / workgroupSize[0];\n const rowPerThreadB = tileInner / workgroupSize[1];\n const matmulSnippet = sequentialAccessByThreads ? `\n let localRow = i32(localId.y);\n let localCol = i32(localId.x);\n let globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n let globalColStart = i32(workgroupId.x) * ${tileBOuter};\n\n // Loop over shared dimension.\n for (var t = 0; t < num_tiles; t = t + 1) {\n // Load one tile of A into local memory.\n for (var inputRow = localRow; inputRow < ${tileAHight}; inputRow = inputRow + ${workgroupSize[1]}) {\n for (var inputCol = localCol; inputCol < ${tileAWidth}; inputCol = inputCol + ${workgroupSize[0]}) {\n ${writeDataToSubASnippet(transposeA, batchDims)}\n }\n }\n // Load one tile of B into local memory.\n for (var inputRow = localRow; inputRow < ${tileInner}; inputRow = inputRow + ${workgroupSize[1]}) {\n for (var inputCol = localCol; inputCol < ${tileBOuter}; inputCol = inputCol + ${workgroupSize[0]}) {\n mm_Bsub[inputRow][inputCol] = mm_readB(batch,\n kStart + inputRow,\n globalColStart + inputCol${batchDims ? ", batchIndices" : ""});\n }\n }\n kStart = kStart + tileInner;\n workgroupBarrier();\n\n // Compute acc values for a single thread.\n var BCached : array<${type}, colPerThread>;\n for (var k = 0; k < tileInner; k = k + 1) {\n for (var inner = 0; inner < colPerThread; inner = inner + 1) {\n BCached[inner] = mm_Bsub[k][localCol + inner * ${workgroupSize[0]}];\n }\n for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n let ACached = ${transposeA ? `mm_Asub[k][localRow + innerRow * ${workgroupSize[1]}];` : `mm_Asub[localRow + innerRow * ${workgroupSize[1]}][k];`}\n for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n acc[innerRow][innerCol] = acc[innerRow][innerCol] +\n ACached * BCached[innerCol];\n }\n }\n }\n workgroupBarrier();\n }\n for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n let gRow = globalRowStart + localRow + innerRow * ${workgroupSize[1]};\n for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n let gCol = globalColStart + localCol + innerCol * ${workgroupSize[0]};\n mm_write(batch, gRow, gCol, acc[innerRow][innerCol]);\n }\n }\n ` : `\nlet tileRow = i32(localId.y) * rowPerThread;\nlet tileCol = i32(localId.x) * colPerThread;\n\nlet globalRow = i32(globalId.y) * rowPerThread;\nlet globalCol = i32(globalId.x) * colPerThread;\nlet globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n\nlet tileRowA = i32(localId.y) * ${rowPerThreadA};\nlet tileColA = i32(localId.x) * ${colPerThreadA};\nlet tileRowB = i32(localId.y) * ${rowPerThreadB};\n// Loop over shared dimension.\nfor (var t = 0; t < num_tiles; t = t + 1) {\n // Load one tile of A into local memory.\n for (var innerRow = 0; innerRow < ${rowPerThreadA}; innerRow = innerRow + 1) {\n for (var innerCol = 0; innerCol < ${colPerThreadA}; innerCol = innerCol + 1) {\n let inputRow = tileRowA + innerRow;\n let inputCol = tileColA + innerCol;\n ${writeDataToSubASnippet(transposeA, batchDims)}\n }\n }\n\n // Load one tile of B into local memory.\n for (var innerRow = 0; innerRow < ${rowPerThreadB}; innerRow = innerRow + 1) {\n for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n let inputRow = tileRowB + innerRow;\n let inputCol = tileCol + innerCol;\n mm_Bsub[inputRow][inputCol] = mm_readB(batch,\n kStart + inputRow,\n globalCol + innerCol${batchDims ? ", batchIndices" : ""});\n }\n }\n kStart = kStart + tileInner;\n workgroupBarrier();\n\n // Compute acc values for a single thread.\n var BCached : array<${type}, colPerThread>;\n for (var k = 0; k < tileInner; k = k + 1) {\n for (var inner = 0; inner < colPerThread; inner = inner + 1) {\n BCached[inner] = mm_Bsub[k][tileCol + inner];\n }\n\n for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n ${readDataFromSubASnippet(transposeA)}\n for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n acc[innerRow][innerCol] = acc[innerRow][innerCol] + ACached * BCached[innerCol];\n }\n }\n }\n\n workgroupBarrier();\n}\n\nfor (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n mm_write(batch, globalRow + innerRow, globalCol + innerCol,\n acc[innerRow][innerCol]);\n }\n}\n`;\n return `\n var mm_Asub : array, ${tileAHight}>;\n var mm_Bsub : array, ${tileInner}>;\n const rowPerThread = ${workPerThread[1]};\n const colPerThread = ${workPerThread[0]};\n const tileInner = ${tileInner};\n\n@compute @workgroup_size(${workgroupSize[0]}, ${workgroupSize[1]}, ${workgroupSize[2]})\nfn main(@builtin(local_invocation_id) localId : vec3,\n @builtin(global_invocation_id) globalId : vec3,\n @builtin(workgroup_id) workgroupId : vec3) {\n let batch = ${splitK ? "0" : "i32(globalId.z)"};\n ${batchDims ? `let batchIndices = ${batchDims.offsetToIndices("u32(batch)")};` : ""}\n let num_tiles = ${splitK ? `${Math.ceil(splitedDimInner / tileInner)}` : "(uniforms.dim_inner - 1) / tileInner + 1"};\n var kStart = ${splitK ? `i32(globalId.z) * ${splitedDimInner}` : "0"};\n\n var acc : array, rowPerThread>;\n\n // Without this initialization strange values show up in acc.\n for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n acc[innerRow][innerCol] = 0.0;\n }\n }\n ${matmulSnippet}\n }\n`;\n };\n matMulReadWriteFnSource = (component, hasBias, applyActivation, variables, batchShapes, isChannelsLast = false) => {\n const [batchAShape, batchBShape, batchShape] = batchShapes;\n const [batchVariable, aVariable, bVariable, outputVariable2] = variables;\n const broadCastADims = getBroadcastDims(batchAShape, batchShape);\n const broadCastBDims = getBroadcastDims(batchBShape, batchShape);\n const dataType = tensorTypeToWsglStorageType(variables[0].type.tensor);\n const getAIndices = () => {\n const aRank = aVariable.rank;\n const batchRank = batchVariable.rank;\n let resStr = `var aIndices: ${aVariable.type.indices};`;\n for (let i = aRank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) {\n resStr += `\naIndices[${i}] = ${batchRank > 1 ? `batchIndices[${j}]` : "batchIndices"};`;\n }\n broadCastADims.forEach((i) => {\n resStr += `\naIndices[${i}] = 0;`;\n });\n resStr += `\naIndices[${aRank - 2}] = u32(row);\n aIndices[${aRank - 1}] = u32(colIn);`;\n return resStr;\n };\n const getBIndices = () => {\n const bRank = bVariable.rank;\n const batchRank = batchVariable.rank;\n let resStr = `var bIndices: ${bVariable.type.indices};`;\n for (let i = bRank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) {\n resStr += `\nbIndices[${i}] = ${batchRank > 1 ? `batchIndices[${j}]` : "batchIndices"};`;\n }\n broadCastBDims.forEach((i) => {\n resStr += `\nbIndices[${i}] = 0;`;\n });\n resStr += `\nbIndices[${bRank - 2}] = u32(row);\n bIndices[${bRank - 1}] = u32(colIn);`;\n return resStr;\n };\n const source = `\n fn mm_readA(batch: i32, row: i32, colIn: i32, batchIndices: ${batchVariable.type.indices}) -> ${typeSnippet(component, dataType)} {\n var value = ${typeSnippet(component, dataType)}(0.0);\n let col = colIn * ${component};\n if(row < uniforms.dim_a_outer && col < uniforms.dim_inner)\n {\n ${getAIndices()}\n value = ${aVariable.getByIndices("aIndices")};\n }\n return value;\n }\n\n fn mm_readB(batch: i32, row: i32, colIn: i32, batchIndices: ${batchVariable.type.indices}) -> ${typeSnippet(component, dataType)} {\n var value = ${typeSnippet(component, dataType)}(0.0);\n let col = colIn * ${component};\n if(row < uniforms.dim_inner && col < uniforms.dim_b_outer)\n {\n ${getBIndices()}\n value = ${bVariable.getByIndices("bIndices")};\n }\n return value;\n }\n\n fn mm_write(batch: i32, row: i32, colIn: i32, valueIn: ${typeSnippet(component, dataType)}) {\n let col = colIn * ${component};\n if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer) {\n var value = valueIn;\n let coords = vec3(batch, row, colIn);\n ${hasBias ? `value = value + ${isChannelsLast ? "bias[colIn]" : `${typeSnippet(component, dataType)}(bias[row])`};` : ""}\n ${applyActivation}\n ${outputVariable2.setByIndices("vec3(coords)", "value")}\n }\n }\n `;\n return source;\n };\n createMatmulProgramInfo = (inputs, activationAttributes, outputShape, reshapedOutputShape, isChannelsLast = false) => {\n const aShape = inputs[0].dims;\n const bShape = inputs[1].dims;\n const outerDimsA = aShape.slice(0, -2);\n const outerDimsB = bShape.slice(0, -2);\n const outerDims = reshapedOutputShape ? reshapedOutputShape.slice(0, -2) : outputShape.slice(0, -2);\n const batchSize = ShapeUtil.size(outerDims);\n const dimAOuter = aShape[aShape.length - 2];\n const dimInner = aShape[aShape.length - 1];\n const dimBOuter = bShape[bShape.length - 1];\n const isVec4 = dimInner % 4 === 0 && dimBOuter % 4 === 0;\n const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];\n const workgroupSize = [8, 8, 1];\n const dispatch = [\n Math.ceil(dimBOuter / workgroupSize[0] / elementsPerThread[0]),\n Math.ceil(dimAOuter / workgroupSize[1] / elementsPerThread[1]),\n Math.ceil(batchSize / workgroupSize[2] / elementsPerThread[2])\n ];\n const components = isVec4 ? 4 : 1;\n const aShapeTemp = [...outerDimsA, dimAOuter, dimInner / components];\n const aRank = aShapeTemp.length;\n const bShapeTemp = [...outerDimsB, dimInner, dimBOuter / components];\n const bRank = bShapeTemp.length;\n const outputShapeTemp = [batchSize, dimAOuter, dimBOuter / components];\n const programUniforms = [\n { type: 6 /* int32 */, data: dimAOuter },\n { type: 6 /* int32 */, data: dimBOuter },\n { type: 6 /* int32 */, data: dimInner }\n ];\n appendActivationUniformsData(activationAttributes, programUniforms);\n programUniforms.push(...createTensorShapeVariables(outerDims, aShapeTemp, bShapeTemp));\n const inputDependencies = ["rank", "rank"];\n const hasBias = inputs.length > 2;\n if (hasBias) {\n programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n inputDependencies.push("rank");\n }\n programUniforms.push(...createTensorShapeVariables(outputShapeTemp));\n const getShaderSource = (shaderHelper) => {\n const batchRank = outerDims.length;\n const batchDims = internalVariable("batchDims", inputs[0].dataType, batchRank, 1);\n const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n const A = inputVariable("a", inputs[0].dataType, aRank, components);\n const B = inputVariable("b", inputs[1].dataType, bRank, components);\n const output = outputVariable("result", inputs[0].dataType, outputShapeTemp.length, components);\n const inputVariables = [A, B];\n if (hasBias) {\n const biasComponents = isChannelsLast ? components : 1;\n inputVariables.push(inputVariable("bias", inputs[2].dataType, inputs[2].dims.length, biasComponents));\n }\n const uniforms = [{ name: "dim_a_outer", type: "i32" }, { name: "dim_b_outer", type: "i32" }, { name: "dim_inner", type: "i32" }];\n appendActivationUniforms(activationAttributes, uniforms);\n const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n const applyActivation = getActivationSnippet(activationAttributes, output.type.value, baseType);\n const declareFunctions = matMulReadWriteFnSource(\n components,\n hasBias,\n applyActivation,\n [batchDims, A, B, output],\n [outerDimsA, outerDimsB, outerDims],\n isChannelsLast\n );\n return `\n ${shaderHelper.registerUniforms(uniforms).registerInternalVariables(batchDims).declareVariables(\n ...inputVariables,\n output\n )}\n ${declareFunctions}\n ${isVec4 ? makeMatMulPackedVec4Source(elementsPerThread, workgroupSize, dataType, batchDims) : makeMatMulPackedSource(elementsPerThread, workgroupSize, dataType, batchDims)}\n `;\n };\n return {\n name: "MatMul",\n shaderCache: {\n hint: `${elementsPerThread};${activationAttributes.activation};${isVec4};${isChannelsLast}`,\n inputDependencies\n },\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] },\n programUniforms\n }),\n getShaderSource\n };\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/3rd-party/conv2d_mm_webgpu.ts\n var conv2dCommonSnippet, createConv2DMatMulProgramInfo;\n var init_conv2d_mm_webgpu = __esm({\n "web/lib/wasm/jsep/webgpu/ops/3rd-party/conv2d_mm_webgpu.ts"() {\n "use strict";\n init_wasm_common();\n init_log();\n init_common();\n init_fuse_utils();\n init_activation_util();\n init_conv_util();\n init_matmul_packed_webgpu();\n conv2dCommonSnippet = (isChannelsLast, fitAOuter, fitBOuter, fitInner, addBias = false, attributes, innerElementSizeX = 4, innerElementSizeW = 4, innerElementSize = 4, dataType = "f32") => {\n const getXSnippet = (innerElementSize2) => {\n switch (innerElementSize2) {\n case 1:\n return "resData = x[xIndex];";\n case 3:\n return `resData = vec3<${dataType}>(x[xIndex], x[xIndex + 1], x[xIndex + 2]);`;\n case 4:\n return "resData = x[xIndex / 4];";\n default:\n throw new Error(`innerElementSize ${innerElementSize2} is not supported.`);\n }\n };\n const getWSnippet = (innerElementSize2) => {\n switch (innerElementSize2) {\n case 1:\n return "return w[row * i32(uniforms.w_shape[3]) + colIn];";\n case 4:\n return "return w[row * i32(uniforms.w_shape[3]) / 4 + colIn];";\n default:\n throw new Error(`innerElementSize ${innerElementSize2} is not supported.`);\n }\n };\n const coordASnippet = isChannelsLast ? `\n let coord = vec4(batch, xRow, xCol, xCh);\n ` : `\n let coord = vec4(batch, xCh, xRow, xCol);\n `;\n const coordResSnippet = isChannelsLast ? `\n let coords = vec4(\n batch,\n row / outWidth,\n row % outWidth,\n col);\n ` : `\n let coords = vec4(\n batch,\n row,\n col / outWidth,\n col % outWidth);\n `;\n const xHeight = isChannelsLast ? "i32(uniforms.x_shape[1])" : "i32(uniforms.x_shape[2])";\n const xWidth = isChannelsLast ? "i32(uniforms.x_shape[2])" : "i32(uniforms.x_shape[3])";\n const row = isChannelsLast ? "row" : "col";\n const col = isChannelsLast ? "col" : "row";\n const readXSnippet = `\n let inChannels = i32(uniforms.w_shape[2]);\n let outWidth = ${isChannelsLast ? "i32(uniforms.result_shape[2])" : "i32(uniforms.result_shape[3])"};\n let outRow = ${row} / outWidth;\n let outCol = ${row} % outWidth;\n\n let WRow = ${col} / (i32(uniforms.w_shape[1]) * inChannels);\n let WCol = ${col} / inChannels % i32(uniforms.w_shape[1]);\n let xRow = outRow * uniforms.stride[0] + uniforms.dilation[0] * WRow - uniforms.pad[0];\n let xCol = outCol * uniforms.stride[1] + uniforms.dilation[1] * WCol - uniforms.pad[1];\n let xCh = ${col} % inChannels;\n var resData = ${typeSnippet(innerElementSizeX, dataType)}(0.0);\n // The bounds checking is always needed since we use it to pad zero for\n // the \'same\' padding type.\n if (xRow >= 0 && xRow < ${xHeight} && xCol >= 0 && xCol < ${xWidth}) {\n ${coordASnippet}\n let xIndex = getIndexFromCoords4D(coord, vec4(uniforms.x_shape));\n ${getXSnippet(innerElementSizeX)}\n }\n return resData;`;\n const sampleX = isChannelsLast ? fitAOuter && fitInner ? `\n let col = colIn * ${innerElementSizeX};\n ${readXSnippet}` : `\n let col = colIn * ${innerElementSizeX};\n if (row < uniforms.dim_a_outer && col < uniforms.dim_inner) {\n ${readXSnippet}\n }\n return ${typeSnippet(innerElementSizeX, dataType)}(0.0);` : fitInner && fitBOuter ? `\n let col = colIn * ${innerElementSizeX};\n ${readXSnippet}` : `\n let col = colIn * ${innerElementSizeX};\n if (row < uniforms.dim_inner && col < uniforms.dim_b_outer) {\n ${readXSnippet}\n }\n return ${typeSnippet(innerElementSizeX, dataType)}(0.0);`;\n const sampleW = `${getWSnippet(innerElementSizeW)}`;\n const resType = typeSnippet(innerElementSize, dataType);\n const aType = isChannelsLast ? typeSnippet(innerElementSizeX, dataType) : typeSnippet(innerElementSizeW, dataType);\n const bType = isChannelsLast ? typeSnippet(innerElementSizeW, dataType) : typeSnippet(innerElementSizeX, dataType);\n const applyActivation = getActivationSnippet(attributes, resType, dataType);\n const userCode = `\n fn mm_readA(batch: i32, row : i32, colIn : i32) -> ${aType} {\n ${isChannelsLast ? sampleX : sampleW}\n }\n\n fn mm_readB(batch: i32, row : i32, colIn : i32) -> ${bType} {\n ${isChannelsLast ? sampleW : sampleX}\n }\n\n fn mm_write(batch: i32, row : i32, colIn : i32, valueIn : ${resType}) {\n let col = colIn * ${innerElementSize};\n if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer)\n {\n var value = valueIn;\n let outWidth = ${isChannelsLast ? "i32(uniforms.result_shape[2])" : "i32(uniforms.result_shape[3])"};\n ${coordResSnippet}\n ${biasSnippet(addBias)}\n ${applyActivation}\n setOutputAtCoords(coords[0], coords[1], coords[2], coords[3], value);\n }\n }`;\n return userCode;\n };\n createConv2DMatMulProgramInfo = (inputs, attributes, outputShape, dimAOuter, dimBOuter, dimInner, hasBias, sequentialAccessByThreads) => {\n const isChannelsLast = attributes.format === "NHWC";\n const inChannels = isChannelsLast ? inputs[0].dims[3] : inputs[0].dims[1];\n const batchSize = outputShape[0];\n const outWidth = isChannelsLast ? outputShape[2] : outputShape[3];\n const outHeight = isChannelsLast ? outputShape[1] : outputShape[2];\n const outChannels = isChannelsLast ? outputShape[3] : outputShape[1];\n const isVec4 = isChannelsLast && (inChannels % 4 === 0 || inChannels % 3 === 0) && outChannels % 4 === 0;\n const dispatchX = isChannelsLast ? outChannels : outWidth * outHeight;\n const dispatchY = isChannelsLast ? outWidth * outHeight : outChannels;\n const workGroupSize = [8, 8, 1];\n const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];\n const dispatch = [\n Math.ceil(dispatchX / workGroupSize[0] / elementsPerThread[0]),\n Math.ceil(dispatchY / workGroupSize[1] / elementsPerThread[1]),\n Math.ceil(batchSize / workGroupSize[2] / elementsPerThread[2])\n ];\n LOG_DEBUG("verbose", () => `[conv2d_mm_webgpu] dispatch = ${dispatch}`);\n const innerElementSize = isVec4 ? isChannelsLast && inChannels % 4 !== 0 ? 3 : 4 : 1;\n const tileAOuter = workGroupSize[1] * elementsPerThread[1];\n const tileBOuter = workGroupSize[0] * elementsPerThread[0];\n const tileInner = Math.max(workGroupSize[0] * innerElementSize, workGroupSize[1]);\n const fitAOuter = dimAOuter % tileAOuter === 0;\n const fitBOuter = dimBOuter % tileBOuter === 0;\n const fitInner = dimInner % tileInner === 0;\n const elementsSize = isVec4 ? [innerElementSize, 4, 4] : [1, 1, 1];\n const programUniforms = [\n { type: 6 /* int32 */, data: dimAOuter },\n { type: 6 /* int32 */, data: dimBOuter },\n { type: 6 /* int32 */, data: dimInner },\n { type: 6 /* int32 */, data: [attributes.pads[0], attributes.pads[1]] },\n { type: 6 /* int32 */, data: attributes.strides },\n { type: 6 /* int32 */, data: attributes.dilations }\n ];\n appendActivationUniformsData(attributes, programUniforms);\n programUniforms.push(...createTensorShapeVariables(inputs[0].dims, inputs[1].dims));\n const inputDependencies = ["rank", "rank"];\n if (hasBias) {\n programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n inputDependencies.push("rank");\n }\n programUniforms.push(...createTensorShapeVariables(outputShape));\n const getShaderSource = (shaderHelper) => {\n const uniforms = [\n { name: "dim_a_outer", type: "i32" },\n { name: "dim_b_outer", type: "i32" },\n { name: "dim_inner", type: "i32" },\n { name: "pad", type: "i32", length: 2 },\n { name: "stride", type: "i32", length: 2 },\n { name: "dilation", type: "i32", length: 2 }\n ];\n appendActivationUniforms(attributes, uniforms);\n const components = isVec4 ? 4 : 1;\n const t = tensorTypeToWsglStorageType(inputs[0].dataType);\n let declareFunctions = `\n fn setOutputAtIndex(flatIndex : i32, value : ${isVec4 ? `vec4<${t}>` : t}) {\n result[flatIndex] = ${isVec4 ? `vec4<${t}>` : t}(value);\n }\n fn setOutputAtCoords(d0 : i32, d1 : i32, d2 : i32, d3 : i32, value : ${isVec4 ? `vec4<${t}>` : t}) {\n let flatIndex = getOutputIndexFromCoords(vec4(d0, d1, d2, d3));\n setOutputAtIndex(flatIndex ${isVec4 ? "/ 4" : ""}, value);\n }`;\n const x = inputVariable(\n "x",\n inputs[0].dataType,\n inputs[0].dims.length,\n innerElementSize === 3 ? 1 : innerElementSize\n );\n const w = inputVariable("w", inputs[1].dataType, inputs[1].dims.length, components);\n const inputVariables = [x, w];\n const output = outputVariable("result", inputs[0].dataType, outputShape.length, components);\n if (hasBias) {\n const bias = inputVariable("bias", inputs[2].dataType, inputs[2].dims.length, components);\n inputVariables.push(bias);\n declareFunctions += `\n fn getBiasByOutputCoords(coords : vec4) -> ${isVec4 ? `vec4<${t}>` : t} {\n return bias[coords.${isChannelsLast ? "w" : "y"}${isVec4 ? "/ 4" : ""}];\n }`;\n }\n return `\n ${utilFunctions("uniforms.result_strides")}\n //struct Uniforms { xShape : vec4, wShape : vec4, outShape : vec4,\n // outShapeStrides: vec3, filterDims : vec2, pad : vec2, stride : vec2,\n // dilation : vec2, dimAOuter : i32, dimBOuter : i32, dimInner : i32 };\n ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n ${declareFunctions}\n ${conv2dCommonSnippet(\n isChannelsLast,\n fitAOuter,\n fitBOuter,\n fitInner,\n hasBias,\n attributes,\n elementsSize[0],\n elementsSize[1],\n elementsSize[2],\n t\n )}\n ${isVec4 ? makeMatMulPackedVec4Source(elementsPerThread, workGroupSize, t, void 0, !isChannelsLast, tileInner) : makeMatMulPackedSource(\n elementsPerThread,\n workGroupSize,\n t,\n void 0,\n !isChannelsLast,\n tileInner,\n false,\n void 0,\n sequentialAccessByThreads\n )}`;\n };\n return {\n name: "Conv2DMatMul",\n shaderCache: {\n hint: `${attributes.cacheKey};${innerElementSize};${isVec4};${fitAOuter};${fitBOuter};${fitInner};${tileAOuter};${tileBOuter};${tileInner}`,\n inputDependencies\n },\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] },\n programUniforms\n }),\n getShaderSource\n };\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/conv-grouped.ts\n var createGroupedConvProgramInfo, createGroupedConvVectorizeProgramInfo;\n var init_conv_grouped = __esm({\n "web/lib/wasm/jsep/webgpu/ops/conv-grouped.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_common();\n init_conv();\n init_fuse_utils();\n createGroupedConvProgramInfo = (inputs, attributes, squeezeOutputShapeFunction) => {\n const hasBias = inputs.length > 2;\n const processBias = hasBias ? "value += b[output_channel];" : "";\n const xShape = inputs[0].dims;\n const wShape = inputs[1].dims;\n const outputChannelsPerGroup = wShape[0] / attributes.group;\n const isChannelLast = attributes.format === "NHWC";\n const outputShape = calculateOutputShape(\n xShape,\n wShape,\n attributes.dilations,\n attributes.pads,\n attributes.strides,\n isChannelLast\n );\n const outputSize = ShapeUtil.size(outputShape);\n const programUniforms = [\n { type: 12 /* uint32 */, data: outputSize },\n { type: 12 /* uint32 */, data: attributes.dilations },\n { type: 12 /* uint32 */, data: [attributes.strides[0], attributes.strides[1]] },\n { type: 12 /* uint32 */, data: [attributes.pads[0], attributes.pads[1]] },\n { type: 12 /* uint32 */, data: outputChannelsPerGroup }\n ];\n appendActivationUniformsData(attributes, programUniforms);\n programUniforms.push(...createTensorShapeVariables(xShape, wShape));\n const inputDependencies = ["rank", "rank"];\n if (hasBias) {\n programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n inputDependencies.push("rank");\n }\n programUniforms.push(...createTensorShapeVariables(outputShape));\n const getShaderSource = (shaderHelper) => {\n const output = outputVariable("output", inputs[0].dataType, outputShape.length);\n const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n const applyActivation = getActivationSnippet(attributes, output.type.value, baseType);\n const x = inputVariable("x", inputs[0].dataType, xShape.length);\n const w = inputVariable("w", inputs[1].dataType, wShape.length);\n const inputVars = [x, w];\n if (hasBias) {\n inputVars.push(inputVariable("b", inputs[2].dataType, inputs[2].dims.length));\n }\n const uniforms = [\n { name: "output_size", type: "u32" },\n { name: "dilations", type: "u32", length: attributes.dilations.length },\n { name: "strides", type: "u32", length: 2 },\n { name: "pads", type: "u32", length: 2 },\n { name: "output_channels_per_group", type: "u32" }\n ];\n appendActivationUniforms(attributes, uniforms);\n return `\n ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}\n\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}\n\n let outputIndices = ${output.offsetToIndices("global_idx")};\n let batch: u32 = outputIndices[0];\n let output_channel: u32 = outputIndices[${isChannelLast ? 3 : 1}];\n let xRCCorner: vec2 = vec2(outputIndices[${isChannelLast ? 1 : 2}], outputIndices[${isChannelLast ? 2 : 3}]) * uniforms.strides - uniforms.pads;\n let group_id: u32 = output_channel / uniforms.output_channels_per_group;\n\n var value: ${output.type.value} = ${output.type.value}(0);\n for (var wInChannel: u32 = 0u; wInChannel < uniforms.w_shape[1]; wInChannel++) {\n let input_channel = group_id * uniforms.w_shape[1] + wInChannel;\n for (var wHeight: u32 = 0u; wHeight < uniforms.w_shape[2]; wHeight++) {\n let xHeight = xRCCorner.x + wHeight * uniforms.dilations[0];\n\n if (xHeight < 0u || xHeight >= uniforms.x_shape[${isChannelLast ? 1 : 2}]) {\n continue;\n }\n\n for (var wWidth: u32 = 0u; wWidth < uniforms.w_shape[3]; wWidth++) {\n let xWidth = xRCCorner.y + wWidth * uniforms.dilations[1];\n if (xWidth < 0u || xWidth >= uniforms.x_shape[${isChannelLast ? 2 : 3}]) {\n continue;\n }\n\n let xVal = ${isChannelLast ? x.get("batch", "xHeight", "xWidth", "input_channel") : x.get("batch", "input_channel", "xHeight", "xWidth")};\n let wVal = ${w.get("output_channel", "wInChannel", "wHeight", "wWidth")};\n value += xVal*wVal;\n }\n }\n }\n ${processBias}\n ${applyActivation}\n ${output.setByOffset("global_idx", "value")}\n }`;\n };\n return {\n name: "GroupedConv",\n shaderCache: { hint: attributes.cacheKey, inputDependencies },\n getRunData: () => ({\n outputs: [{\n dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,\n dataType: inputs[0].dataType\n }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms\n }),\n getShaderSource\n };\n };\n createGroupedConvVectorizeProgramInfo = (inputs, attributes, outputShape) => {\n const hasBias = inputs.length > 2;\n const components = getMaxComponents(outputShape[3]);\n const outputNumber = getMaxComponents(outputShape[2]);\n const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;\n const xShape = [inputs[0].dims[0], inputs[0].dims[1], inputs[0].dims[2], inputs[0].dims[3] / components];\n const wShape = [inputs[1].dims[0], inputs[1].dims[1], inputs[1].dims[2], inputs[1].dims[3] / components];\n const outputShapeInShader = [outputShape[0], outputShape[1], outputShape[2], outputShape[3] / components];\n const programUniforms = [\n { type: 12 /* uint32 */, data: outputSize },\n { type: 6 /* int32 */, data: [attributes.strides[0], attributes.strides[1]] },\n { type: 6 /* int32 */, data: [attributes.pads[0], attributes.pads[1]] }\n ];\n appendActivationUniformsData(attributes, programUniforms);\n programUniforms.push(...createTensorShapeVariables(xShape, wShape, outputShapeInShader));\n const xNumber = (outputNumber - 1) * attributes.strides[1] + wShape[1];\n const getShaderSource = (shaderHelper) => {\n const output = outputVariable("output", inputs[0].dataType, outputShapeInShader.length, components);\n const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n const applyActivation = getActivationSnippet(attributes, output.type.value, baseType);\n const x = inputVariable("x", inputs[0].dataType, xShape.length, components);\n const w = inputVariable("w", inputs[1].dataType, wShape.length, components);\n const inputVars = [x, w];\n if (hasBias) {\n inputVars.push(inputVariable("b", inputs[2].dataType, inputs[2].dims, components));\n }\n const processBias = hasBias ? "value += b[output_channel];" : "";\n const uniforms = [\n { name: "output_size", type: "u32" },\n { name: "strides", type: "i32", length: 2 },\n { name: "pads", type: "i32", length: 2 }\n ];\n appendActivationUniforms(attributes, uniforms);\n return `\n ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}\n let width0 = uniforms.output_shape[3];\n let output_channel = global_idx % width0;\n var index1 = global_idx / width0;\n let width1 = uniforms.output_shape[2] / ${outputNumber}u;\n let col = (index1 % width1) * ${outputNumber}u;\n index1 = index1 / width1;\n let row = index1 % uniforms.output_shape[1];\n let batch = index1 / uniforms.output_shape[1];\n\n let x_corner = vec2(i32(row), i32(col)) * uniforms.strides - uniforms.pads;\n\n var x_vals: array<${x.type.value}, ${xNumber}>;\n var values: array<${output.type.value}, ${outputNumber}>;\n let input_channel = output_channel;\n // Use constant instead of uniform can give better performance for w\'s height/width.\n for (var w_height: u32 = 0u; w_height < ${wShape[0]}; w_height++) {\n let x_height = x_corner.x + i32(w_height);\n if (x_height >= 0 && u32(x_height) < uniforms.x_shape[1]) {\n for (var i = 0; i < ${xNumber}; i++) {\n let x_width = x_corner.y + i;\n if (x_width >= 0 && u32(x_width) < uniforms.x_shape[2]) {\n x_vals[i] = ${x.get("batch", "u32(x_height)", "u32(x_width)", "input_channel")};\n } else {\n x_vals[i] = ${x.type.value}(0);\n }\n }\n for (var w_width: u32 = 0u; w_width < ${wShape[1]}; w_width++) {\n let w_val = ${w.get("w_height", "w_width", "0", "output_channel")};\n for (var i = 0u; i < ${outputNumber}u; i++) {\n values[i] = fma(x_vals[i * u32(uniforms.strides[1]) + w_width], w_val, values[i]);\n }\n }\n }\n }\n\n for (var i = 0u; i < ${outputNumber}u; i++) {\n var value = values[i];\n ${processBias}\n ${applyActivation}\n ${output.set("batch", "row", "col + i", "output_channel", "value")};\n }\n }`;\n };\n return {\n name: "GroupedConv-Vectorize",\n shaderCache: {\n hint: `${attributes.cacheKey};${components};${outputNumber};${xNumber};${wShape[0]};${wShape[1]}`,\n inputDependencies: hasBias ? ["rank", "rank", "type"] : ["rank", "rank"]\n },\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms\n }),\n getShaderSource\n };\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/matmul.ts\n var createNaiveMatmulProgramInfo, validateInputs8, matMul;\n var init_matmul = __esm({\n "web/lib/wasm/jsep/webgpu/ops/matmul.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_matmul_packed_webgpu();\n init_common();\n init_fuse_utils();\n createNaiveMatmulProgramInfo = (inputs, activationAttributes, outputShape, reshapedOutputShape, isChannelsLast = false) => {\n const aShape = inputs[0].dims;\n const bShape = inputs[1].dims;\n const M = aShape[aShape.length - 2];\n const N = bShape[bShape.length - 1];\n const K = aShape[aShape.length - 1];\n const components = getMaxComponents(N);\n const aComponents = getMaxComponents(K);\n const outputNumber = getMaxComponents(M);\n const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;\n const hasBias = inputs.length > 2;\n const outerDims = reshapedOutputShape ? reshapedOutputShape.slice(0, -2) : outputShape.slice(0, -2);\n const batchSize = ShapeUtil.size(outerDims);\n const outputShapeInShader = [batchSize, M, N];\n const programUniforms = [\n { type: 12 /* uint32 */, data: outputSize },\n { type: 12 /* uint32 */, data: M },\n { type: 12 /* uint32 */, data: N },\n { type: 12 /* uint32 */, data: K }\n ];\n appendActivationUniformsData(activationAttributes, programUniforms);\n programUniforms.push(...createTensorShapeVariables(outerDims, aShape, bShape));\n if (hasBias) {\n programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n }\n programUniforms.push(...createTensorShapeVariables(outputShapeInShader));\n const getShaderSource = (shaderHelper) => {\n const batchDims = internalVariable("batch_dims", inputs[0].dataType, outerDims.length);\n const a = inputVariable("a", inputs[0].dataType, aShape.length, aComponents);\n const b = inputVariable("b", inputs[1].dataType, bShape.length, components);\n const output = outputVariable("output", inputs[0].dataType, outputShapeInShader.length, components);\n const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n const applyActivation = getActivationSnippet(activationAttributes, output.type.value, baseType);\n const inputVariables = [a, b];\n let processBias = "";\n if (hasBias) {\n const biasComponents = isChannelsLast ? components : 1;\n inputVariables.push(inputVariable("bias", inputs[2].dataType, inputs[2].dims.length, biasComponents));\n processBias = `${isChannelsLast ? `value += bias[col / ${biasComponents}];` : `value += ${output.type.value}(bias[row + i]);`}`;\n }\n const outerDimsA = aShape.slice(0, -2);\n const outerDimsB = bShape.slice(0, -2);\n const broadCastADims = getBroadcastDims(outerDimsA, outerDims);\n const broadCastBDims = getBroadcastDims(outerDimsB, outerDims);\n const uniforms = [\n { name: "output_size", type: "u32" },\n { name: "M", type: "u32" },\n { name: "N", type: "u32" },\n { name: "K", type: "u32" }\n ];\n appendActivationUniforms(activationAttributes, uniforms);\n const getIndices = (variable, broadCastDims) => {\n const rank = variable.rank;\n const name = variable.name;\n if (rank === 2) {\n return `var ${name}_indices = ${variable.type.indices}(0u, 0u);`;\n }\n const batchRank = batchDims.rank;\n let resStr = `var ${name}_indices: ${variable.type.indices};`;\n for (let i = rank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) {\n resStr += `\n${name}_indices[${i}] = ${batchRank > 1 ? `batch_indices[${j}]` : "batch_indices"};`;\n }\n broadCastDims.forEach((i) => {\n resStr += `\n${name}_indices[${i}] = 0;`;\n });\n resStr += `${name}_indices[${rank - 2}] = 0u;\n ${name}_indices[${rank - 1}] = 0u;`;\n return resStr;\n };\n const calcResult = () => {\n let calcStr = `var a_data: ${a.type.value};`;\n for (let i = 0; i < aComponents; i++) {\n calcStr += `\n let b_data${i} = b[(b_offset + (k + ${i}) * uniforms.N + col) / ${components}];`;\n }\n for (let i = 0; i < outputNumber; i++) {\n calcStr += `a_data = a[(a_offset + (row + ${i}) * uniforms.K + k) / ${aComponents}];`;\n for (let j = 0; j < aComponents; j++) {\n calcStr += `\n values[${i}] = fma(${b.type.value}(a_data${aComponents === 1 ? "" : `[${j}]`}), b_data${j}, values[${i}]);\n`;\n }\n }\n return calcStr;\n };\n return `\n ${shaderHelper.registerUniforms(uniforms).registerInternalVariables(batchDims).declareVariables(\n ...inputVariables,\n output\n )}\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}\n let col = (global_idx % (uniforms.N / ${components})) * ${components};\n var index1 = global_idx / (uniforms.N / ${components});\n let stride1 = uniforms.M / ${outputNumber};\n let row = (index1 % stride1) * ${outputNumber};\n let batch = index1 / stride1;\n\n ${outputShape.length === 2 ? "" : `let batch_indices = ${batchDims.offsetToIndices("batch")};`}\n ${getIndices(a, broadCastADims)}\n let a_offset = ${a.indicesToOffset("a_indices")};\n ${getIndices(b, broadCastBDims)}\n let b_offset = ${b.indicesToOffset("b_indices")};\n var values: array<${output.type.value}, ${outputNumber}>;\n for (var k: u32 = 0u; k < uniforms.K; k = k + ${aComponents}) {\n ${calcResult()}\n }\n for (var i = 0u; i < ${outputNumber}u; i++) {\n var value = values[i];\n ${processBias}\n ${applyActivation}\n let cur_indices = ${output.type.indices}(batch, row + i, col);\n let offset = ${output.indicesToOffset("cur_indices")};\n ${output.setByOffset(`offset / ${components}`, "value")};\n }\n }\n `;\n };\n return {\n name: "MatMulNaive",\n shaderCache: {\n hint: `${activationAttributes.activation};${components};${aComponents};${outputNumber};${isChannelsLast}`,\n inputDependencies: hasBias ? ["rank", "rank", "rank"] : ["rank", "rank"]\n },\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms\n }),\n getShaderSource\n };\n };\n validateInputs8 = (inputs) => {\n if (!inputs || inputs.length !== 2) {\n throw new Error("MatMul requires 2 inputs.");\n }\n if (inputs[0].dims[inputs[0].dims.length - 1] !== inputs[1].dims[inputs[1].dims.length - 2]) {\n throw new Error("shared dimension does not match.");\n }\n };\n matMul = (context) => {\n validateInputs8(context.inputs);\n const outputShape = BroadcastUtil.calcShape(context.inputs[0].dims, context.inputs[1].dims, true);\n if (!outputShape) {\n throw new Error("Can\'t use matmul on the given tensors");\n }\n const N = outputShape[outputShape.length - 1];\n const K = context.inputs[0].dims[context.inputs[0].dims.length - 1];\n if (N < 8 && K < 8) {\n context.compute(createNaiveMatmulProgramInfo(context.inputs, { activation: "" }, outputShape));\n } else {\n context.compute(createMatmulProgramInfo(context.inputs, { activation: "" }, outputShape));\n }\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/conv.ts\n var calculateOutputShape, weightTransposeAttribute, validateInputs9, getAdjustedConvAttributes, parseConvAttributes, conv2d, conv1d, conv;\n var init_conv = __esm({\n "web/lib/wasm/jsep/webgpu/ops/conv.ts"() {\n "use strict";\n init_util();\n init_conv2d_mm_webgpu();\n init_matmul_packed_webgpu();\n init_conv_grouped();\n init_fuse_utils();\n init_matmul();\n init_transpose();\n calculateOutputShape = (inputShape, kernelShape, dilations, adjustPads, strides, isChannelLast) => {\n const batchSize = inputShape[0];\n const inputSpatialShape = inputShape.slice(isChannelLast ? 1 : 2, isChannelLast ? 3 : 4);\n const spatialRank = inputSpatialShape.length;\n const outChannels = kernelShape[0];\n const kernelSpatialShape = kernelShape.slice(2);\n const dilatedKernelShape = kernelSpatialShape.map((v, i) => v + (v - 1) * (dilations[i] - 1));\n const inputSpatialShapeWithPad = inputSpatialShape.map((v, i) => v + adjustPads[i] + adjustPads[i + spatialRank]);\n const outputShape = inputSpatialShapeWithPad.map((v, i) => Math.floor((v - dilatedKernelShape[i] + strides[i]) / strides[i]));\n outputShape.splice(0, 0, batchSize);\n outputShape.splice(isChannelLast ? 3 : 1, 0, outChannels);\n return outputShape;\n };\n weightTransposeAttribute = [2, 3, 1, 0];\n validateInputs9 = (inputs, attributes) => {\n if (!inputs || inputs.length !== 2 && inputs.length !== 3) {\n throw new Error("Conv requires 2 or 3 inputs");\n }\n if (inputs[0].dims.length !== 4 && inputs[0].dims.length !== 3) {\n throw new Error("currently only support conv 1D and 2D");\n }\n if (inputs[0].dims.length !== inputs[1].dims.length) {\n throw new Error("filter does not have same dimension as input");\n }\n const dataChannel = inputs[0].dims[attributes.format === "NHWC" ? inputs[0].dims.length - 1 : 1];\n const filterInChannel = inputs[1].dims[1] * attributes.group;\n if (dataChannel !== filterInChannel) {\n throw new Error("FILTER_IN_CHANNEL should be equal to DATA_CHANNEL");\n }\n if (inputs.length === 3 && (inputs[2].dims.length !== 1 || inputs[1].dims[0] !== inputs[2].dims[0])) {\n throw new Error("invalid bias");\n }\n const spatialRank = inputs[0].dims.length - 2;\n if (attributes.dilations.length !== spatialRank) {\n throw new Error(`dilations should be ${spatialRank}D`);\n }\n if (attributes.strides.length !== spatialRank) {\n throw new Error(`strides should be ${spatialRank}D`);\n }\n if (attributes.pads.length !== spatialRank * 2) {\n throw new Error(`pads should be ${spatialRank * 2}D`);\n }\n if (attributes.kernelShape.length !== 0 && attributes.kernelShape.length !== inputs[1].dims.length - 2) {\n throw new Error("invalid kernel shape");\n }\n };\n getAdjustedConvAttributes = (attributes, inputs) => {\n const kernelShape = attributes.kernelShape.slice();\n for (let i = 2; i < inputs[1].dims.length; ++i) {\n if (kernelShape[i - 2] === 0) {\n kernelShape[i - 2] = inputs[1].dims[i];\n }\n }\n const pads = attributes.pads.slice();\n PoolConvUtil.adjustPadsBasedOnAutoPad(\n inputs[0].dims,\n attributes.strides,\n attributes.dilations,\n kernelShape,\n pads,\n attributes.format === "NHWC",\n attributes.autoPad\n );\n const newAttributes = Object.assign({}, attributes);\n Object.assign(newAttributes, { kernelShape, pads });\n return newAttributes;\n };\n parseConvAttributes = (attributes) => {\n const activationAttributes = parseInternalActivationAttributes(attributes);\n const format = attributes.format;\n const autoPad = ["NOTSET", "VALID", "SAME_UPPER", "SAME_LOWER"][attributes.auto_pad];\n const dilations = attributes.dilations;\n const group = attributes.group;\n const kernelShape = attributes.kernel_shape;\n const pads = attributes.pads;\n const strides = attributes.strides;\n const wIsConst = attributes.w_is_const();\n return {\n autoPad,\n format,\n dilations,\n group,\n kernelShape,\n pads,\n strides,\n wIsConst,\n ...activationAttributes,\n cacheKey: `${attributes.format};${activationAttributes.activation};`\n };\n };\n conv2d = (context, inputs, attributes) => {\n const adjustedAttributes = getAdjustedConvAttributes(attributes, inputs);\n const isChannelsLast = attributes.format === "NHWC";\n if (attributes.group !== 1) {\n const enableGroupedConvVectorize = !context.adapterInfo.isArchitecture("ampere");\n if (enableGroupedConvVectorize && isChannelsLast && inputs[1].dims[0] === attributes.group && inputs[1].dims[1] === 1 && attributes.dilations[0] === 1 && attributes.dilations[1] === 1) {\n const outputShape2 = calculateOutputShape(\n inputs[0].dims,\n inputs[1].dims,\n attributes.dilations,\n adjustedAttributes.pads,\n attributes.strides,\n isChannelsLast\n );\n const transposedWeight2 = context.kernelCustomData.wT ?? context.compute(\n createTransposeProgramInfo(inputs[1], weightTransposeAttribute),\n { inputs: [1], outputs: [attributes.wIsConst ? -2 : -1] }\n )[0];\n if (attributes.wIsConst && !context.kernelCustomData.wT) {\n context.kernelCustomData.wT = transposedWeight2;\n }\n const convInputs2 = [inputs[0], transposedWeight2];\n if (inputs.length === 3) {\n convInputs2.push(inputs[2]);\n }\n context.compute(\n createGroupedConvVectorizeProgramInfo(convInputs2, adjustedAttributes, outputShape2),\n { inputs: convInputs2 }\n );\n } else {\n context.compute(createGroupedConvProgramInfo(inputs, adjustedAttributes));\n }\n return;\n }\n const hasBias = inputs.length === 3;\n const inputHeight = inputs[0].dims[isChannelsLast ? 1 : 2];\n const inputWidth = inputs[0].dims[isChannelsLast ? 2 : 3];\n const inputChannels = inputs[0].dims[isChannelsLast ? 3 : 1];\n const weightHeight = inputs[1].dims[2];\n const weightWidth = inputs[1].dims[3];\n const outputShape = calculateOutputShape(\n inputs[0].dims,\n inputs[1].dims,\n attributes.dilations,\n adjustedAttributes.pads,\n attributes.strides,\n isChannelsLast\n );\n const outHeight = outputShape[isChannelsLast ? 1 : 2];\n const outWidth = outputShape[isChannelsLast ? 2 : 3];\n const outChannels = outputShape[isChannelsLast ? 3 : 1];\n const sameSize = isChannelsLast && weightHeight === inputHeight && weightWidth === inputWidth && attributes.pads[0] === 0 && attributes.pads[1] === 0;\n if (sameSize || weightHeight === 1 && weightWidth === 1 && attributes.dilations[0] === 1 && attributes.dilations[1] === 1 && attributes.strides[0] === 1 && attributes.strides[1] === 1 && attributes.pads[0] === 0 && attributes.pads[1] === 0) {\n const batch = outputShape[0];\n let xReshaped, wReshaped, matmulOutputShape;\n const matmulInputs = [];\n if (isChannelsLast) {\n const transposedWeight2 = context.kernelCustomData.wT ?? context.compute(\n createTransposeProgramInfo(inputs[1], weightTransposeAttribute),\n { inputs: [1], outputs: [attributes.wIsConst ? -2 : -1] }\n )[0];\n if (attributes.wIsConst && !context.kernelCustomData.wT) {\n context.kernelCustomData.wT = transposedWeight2;\n }\n if (sameSize) {\n const sharedDim = inputHeight * inputWidth * inputChannels;\n xReshaped = inputs[0].reshape([1, batch, sharedDim]);\n wReshaped = transposedWeight2.reshape([1, sharedDim, outChannels]);\n matmulOutputShape = [1, batch, outChannels];\n } else {\n xReshaped = inputs[0].reshape([batch, inputHeight * inputWidth, inputChannels]);\n wReshaped = transposedWeight2.reshape([1, inputChannels, outChannels]);\n matmulOutputShape = [batch, outHeight * outWidth, outChannels];\n }\n matmulInputs.push(xReshaped);\n matmulInputs.push(wReshaped);\n } else {\n xReshaped = inputs[0].reshape([batch, inputChannels, inputHeight * inputWidth]);\n wReshaped = inputs[1].reshape([1, outChannels, inputChannels]);\n matmulOutputShape = [batch, outChannels, outHeight * outWidth];\n matmulInputs.push(wReshaped);\n matmulInputs.push(xReshaped);\n }\n if (hasBias) {\n matmulInputs.push(inputs[2]);\n }\n const N = matmulOutputShape[2];\n const K = matmulInputs[0].dims[matmulInputs[0].dims.length - 1];\n if (N < 8 && K < 8) {\n context.compute(\n createNaiveMatmulProgramInfo(\n matmulInputs,\n adjustedAttributes,\n outputShape,\n matmulOutputShape,\n isChannelsLast\n ),\n { inputs: matmulInputs }\n );\n } else {\n context.compute(\n createMatmulProgramInfo(matmulInputs, adjustedAttributes, outputShape, matmulOutputShape, isChannelsLast),\n { inputs: matmulInputs }\n );\n }\n return;\n }\n const sequentialAccessByThreads = (\n /* backend.adapterInfo.isIntel() */\n true\n );\n const transposedWeight = context.kernelCustomData.wT ?? context.compute(\n createTransposeProgramInfo(inputs[1], weightTransposeAttribute),\n { inputs: [1], outputs: [attributes.wIsConst ? -2 : -1] }\n )[0];\n if (attributes.wIsConst && !context.kernelCustomData.wT) {\n context.kernelCustomData.wT = transposedWeight;\n }\n const convInputs = [inputs[0], transposedWeight];\n if (hasBias) {\n convInputs.push(inputs[2]);\n }\n const dimAOuter = isChannelsLast ? outHeight * outWidth : outChannels;\n const dimBOuter = isChannelsLast ? outChannels : outHeight * outWidth;\n const dimInner = weightHeight * weightWidth * inputChannels;\n context.compute(\n createConv2DMatMulProgramInfo(\n convInputs,\n adjustedAttributes,\n outputShape,\n dimAOuter,\n dimBOuter,\n dimInner,\n hasBias,\n sequentialAccessByThreads\n ),\n { inputs: convInputs }\n );\n };\n conv1d = (context, attributes) => {\n const isChannelLast = attributes.format === "NHWC";\n const inputs = [\n context.inputs[0].reshape(\n isChannelLast ? (\n // [N, W, C] -> [N, H=1, W, C]\n [context.inputs[0].dims[0], 1, context.inputs[0].dims[1], context.inputs[0].dims[2]]\n ) : (\n // [N, C, W] -> [N, C, H=1, W]\n [context.inputs[0].dims[0], context.inputs[0].dims[1], 1, context.inputs[0].dims[2]]\n )\n ),\n //[FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kW] -> [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kH=1, kW]\n context.inputs[1].reshape([context.inputs[1].dims[0], context.inputs[1].dims[1], 1, context.inputs[1].dims[2]])\n ];\n if (context.inputs.length === 3) {\n inputs.push(context.inputs[2]);\n }\n const pads = [0, attributes.pads[0], 0, attributes.pads[1]];\n const strides = [1].concat(attributes.strides);\n const dilations = [1].concat(attributes.dilations);\n const kernelShape = [1].concat(attributes.kernelShape);\n const adjustedAttributes = getAdjustedConvAttributes({ ...attributes, pads, strides, dilations, kernelShape }, inputs);\n context.compute(createGroupedConvProgramInfo(\n inputs,\n adjustedAttributes,\n (outputShape) => isChannelLast ? [outputShape[0], outputShape[2], outputShape[3]] : []\n ));\n };\n conv = (context, attributes) => {\n validateInputs9(context.inputs, attributes);\n if (context.inputs[0].dims.length === 3) {\n conv1d(context, attributes);\n } else {\n conv2d(context, context.inputs, attributes);\n }\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_mm_webgpu.ts\n var conv2dTransposeCommonSnippet, createConv2DTransposeMatMulProgramInfo;\n var init_conv_backprop_mm_webgpu = __esm({\n "web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_mm_webgpu.ts"() {\n "use strict";\n init_wasm_common();\n init_log();\n init_common();\n init_fuse_utils();\n init_activation_util();\n init_conv_util();\n init_matmul_packed_webgpu();\n conv2dTransposeCommonSnippet = (isChannelsLast, addBias = false, attributes, type, innerElementSize = 4) => {\n const getWSnippet = (innerElementSize2) => {\n switch (innerElementSize2) {\n case 1:\n return "return w[getIndexFromCoords4D(coord, vec4(uniforms.w_shape))];";\n case 4:\n return `\n let coord1 = vec4(coordX, coordY, col + 1, rowInner);\n let coord2 = vec4(coordX, coordY, col + 2, rowInner);\n let coord3 = vec4(coordX, coordY, col + 3, rowInner);\n let v0 = w[getIndexFromCoords4D(coord, vec4(uniforms.w_shape))];\n let v1 = w[getIndexFromCoords4D(coord1, vec4(uniforms.w_shape))];\n let v2 = w[getIndexFromCoords4D(coord2, vec4(uniforms.w_shape))];\n let v3 = w[getIndexFromCoords4D(coord3, vec4(uniforms.w_shape))];\n return ${type}(v0, v1, v2, v3);\n `;\n default:\n throw new Error(`innerElementSize ${innerElementSize2} is not supported.`);\n }\n };\n const coordASnippet = isChannelsLast ? `\n let coord = vec4(batch, iXR, iXC, xCh);\n ` : `\n let coord = vec4(batch, xCh, iXR, iXC);\n `;\n const coordResSnippet = isChannelsLast ? `\n let coords = vec4(\n batch,\n row / outWidth,\n row % outWidth,\n col);\n ` : `\n let coords = vec4(\n batch,\n row,\n col / outWidth,\n col % outWidth);\n `;\n const xHeight = isChannelsLast ? "i32(uniforms.x_shape[1])" : "i32(uniforms.x_shape[2])";\n const xWidth = isChannelsLast ? "i32(uniforms.x_shape[2])" : "i32(uniforms.x_shape[3])";\n const row = isChannelsLast ? "row" : "col";\n const col = isChannelsLast ? "col" : "row";\n const readASnippet = `\n let inChannels = ${isChannelsLast ? "i32(uniforms.x_shape[3])" : "i32(uniforms.x_shape[1])"};\n let outWidth = ${isChannelsLast ? "i32(uniforms.result_shape[2])" : "i32(uniforms.result_shape[3])"};\n let outRow = ${row} / outWidth;\n let outCol = ${row} % outWidth;\n\n let WRow = ${col} / (uniforms.filter_dims[1] * inChannels);\n let WCol = ${col} / inChannels % uniforms.filter_dims[1];\n let xR = f32(outRow - uniforms.pads[0] + uniforms.dilations[0] * WRow) / f32(uniforms.strides[0]);\n let xC = f32(outCol - uniforms.pads[1] + uniforms.dilations[1] * WCol) / f32(uniforms.strides[1]);\n if (xR < 0.0 || xR >= f32(${xHeight}) || fract(xR) > 0.0) {\n return ${type}(0.0);\n }\n if (xC < 0.0 || xC >= f32(${xWidth}) || fract(xC) > 0.0) {\n return ${type}(0.0);\n }\n let iXR = i32(xR);\n let iXC = i32(xC);\n let xCh = ${col} % inChannels;\n ${coordASnippet}\n return x[getIndexFromCoords4D(coord, vec4(uniforms.x_shape))/${innerElementSize}];`;\n const sampleA = isChannelsLast ? `\n let col = colIn * ${innerElementSize};\n if (row < uniforms.dim_a_outer && col < uniforms.dim_inner) {\n ${readASnippet}\n }\n return ${type}(0.0);` : `\n let col = colIn * ${innerElementSize};\n if (row < uniforms.dim_inner && col < uniforms.dim_b_outer) {\n ${readASnippet}\n }\n return ${type}(0.0);`;\n const sampleW = `\n let col = colIn * ${innerElementSize};\n let inChannels = ${isChannelsLast ? "i32(uniforms.x_shape[3])" : "i32(uniforms.x_shape[1])"};\n let coordX = uniforms.filter_dims[0] - 1 - row / (uniforms.filter_dims[1] * inChannels);\n let coordY = uniforms.filter_dims[1] - 1 - (row / inChannels) % uniforms.filter_dims[1];\n if (${isChannelsLast ? "row < uniforms.dim_inner && col < uniforms.dim_b_outer" : "row < uniforms.dim_inner && col < uniforms.dim_a_outer"} && coordX >= 0 && coordY >= 0) {\n let rowInner = row % inChannels;\n let coord = vec4(coordX, coordY, col, rowInner);\n ${getWSnippet(innerElementSize)}\n }\n return ${type}(0.0);\n `;\n const applyActivation = getActivationSnippet(attributes, type);\n const userCode = `\n fn mm_readA(batch: i32, row : i32, colIn : i32) -> ${type} {\n ${isChannelsLast ? sampleA : sampleW}\n }\n\n fn mm_readB(batch: i32, row : i32, colIn : i32) -> ${type} {\n ${isChannelsLast ? sampleW : sampleA}\n }\n\n fn mm_write(batch: i32, row : i32, colIn : i32, valueInput : ${type}) {\n let col = colIn * ${innerElementSize};\n if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer) {\n var value = valueInput;\n let outWidth = ${isChannelsLast ? "i32(uniforms.result_shape[2])" : "i32(uniforms.result_shape[3])"};\n ${coordResSnippet}\n ${biasSnippet(addBias)}\n ${applyActivation}\n result[getIndexFromCoords4D(coords, vec4(uniforms.result_shape))/${innerElementSize}] = value;\n }\n }`;\n return userCode;\n };\n createConv2DTransposeMatMulProgramInfo = (inputs, attributes, outputShape, dimAOuter, dimBOuter, dimInner, hasBias, sequentialAccessByThreads) => {\n const isChannelsLast = attributes.format === "NHWC";\n const inChannels = isChannelsLast ? inputs[0].dims[3] : inputs[0].dims[1];\n const batchSize = outputShape[0];\n const outWidth = isChannelsLast ? outputShape[2] : outputShape[3];\n const outHeight = isChannelsLast ? outputShape[1] : outputShape[2];\n const outChannels = isChannelsLast ? outputShape[3] : outputShape[1];\n const isVec4 = isChannelsLast && (inChannels % 4 === 0 && inChannels % 3) && outChannels % 4 === 0;\n const dispatchX = isChannelsLast ? outChannels : outWidth * outHeight;\n const dispatchY = isChannelsLast ? outWidth * outHeight : outChannels;\n const workGroupSize = [8, 8, 1];\n const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];\n const dispatch = [\n Math.ceil(dispatchX / workGroupSize[0] / elementsPerThread[0]),\n Math.ceil(dispatchY / workGroupSize[1] / elementsPerThread[1]),\n Math.ceil(batchSize / workGroupSize[2] / elementsPerThread[2])\n ];\n LOG_DEBUG("verbose", () => `[conv_backprop_mm_webgpu] dispatch = ${dispatch}`);\n const innerElementSize = isVec4 ? 4 : 1;\n const tileInner = Math.max(workGroupSize[0] * innerElementSize, workGroupSize[1]);\n const components = isVec4 ? 4 : 1;\n const filterDims = [attributes.kernelShape[isChannelsLast ? 1 : 2], attributes.kernelShape[isChannelsLast ? 2 : 3]];\n const effectiveFilterDims = [\n filterDims[0] + (attributes.dilations[0] <= 1 ? 0 : (filterDims[0] - 1) * (attributes.dilations[0] - 1)),\n filterDims[1] + (attributes.dilations[1] <= 1 ? 0 : (filterDims[1] - 1) * (attributes.dilations[1] - 1))\n ];\n const pads = [\n effectiveFilterDims[0] - 1 - Math.floor((attributes.pads[0] + attributes.pads[2]) / 2),\n effectiveFilterDims[1] - 1 - Math.floor((attributes.pads[1] + attributes.pads[3]) / 2)\n ];\n const programUniforms = [\n { type: 6 /* int32 */, data: dimAOuter },\n { type: 6 /* int32 */, data: dimBOuter },\n { type: 6 /* int32 */, data: dimInner },\n { type: 6 /* int32 */, data: attributes.strides },\n { type: 6 /* int32 */, data: attributes.dilations },\n { type: 6 /* int32 */, data: filterDims },\n { type: 6 /* int32 */, data: pads }\n ];\n appendActivationUniformsData(attributes, programUniforms);\n programUniforms.push(...createTensorShapeVariables(inputs[0].dims, inputs[1].dims));\n const inputDependencies = ["rank", "rank"];\n if (hasBias) {\n programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n inputDependencies.push("rank");\n }\n programUniforms.push(...createTensorShapeVariables(outputShape));\n const getShaderSource = (shaderHelper) => {\n const x = inputVariable("x", inputs[0].dataType, inputs[0].dims.length, components);\n const w = inputVariable("w", inputs[1].dataType, inputs[1].dims.length, 1);\n const output = outputVariable("result", inputs[0].dataType, outputShape.length, components);\n const inputVariables = [x, w];\n let declareFunctions = "";\n if (hasBias) {\n const bias = inputVariable("bias", inputs[2].dataType, inputs[2].dims.length, components);\n inputVariables.push(bias);\n declareFunctions += `\n fn getBiasByOutputCoords(coords : vec4) -> ${bias.type.value} {\n return bias[coords.${isChannelsLast ? "w" : "y"}${isVec4 ? "/ 4" : ""}];\n }`;\n }\n const uniforms = [\n { name: "dim_a_outer", type: "i32" },\n { name: "dim_b_outer", type: "i32" },\n { name: "dim_inner", type: "i32" },\n { name: "strides", type: "i32", length: 2 },\n { name: "dilations", type: "i32", length: 2 },\n { name: "filter_dims", type: "i32", length: filterDims.length },\n { name: "pads", type: "i32", length: pads.length }\n ];\n appendActivationUniforms(attributes, uniforms);\n const elemType = tensorTypeToWsglStorageType(inputs[0].dataType, 1);\n if (elemType !== "f16" && elemType !== "f32") {\n throw new Error(`elemType ${elemType} is not supported.`);\n }\n return `\n ${utilFunctions("uniforms.result_strides")}\n ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)};\n ${declareFunctions}\n ${conv2dTransposeCommonSnippet(isChannelsLast, hasBias, attributes, x.type.value, innerElementSize)}\n ${isVec4 ? makeMatMulPackedVec4Source(\n elementsPerThread,\n workGroupSize,\n elemType,\n void 0,\n !isChannelsLast,\n tileInner\n ) : makeMatMulPackedSource(\n elementsPerThread,\n workGroupSize,\n elemType,\n void 0,\n !isChannelsLast,\n tileInner,\n false,\n void 0,\n sequentialAccessByThreads\n )}`;\n };\n return {\n name: "Conv2DTransposeMatMul",\n shaderCache: { hint: `${attributes.cacheKey};${elementsPerThread};${workGroupSize};${isVec4}`, inputDependencies },\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] },\n programUniforms\n }),\n getShaderSource\n };\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_webgpu.ts\n var createConvTranspose2DOpProgramShaderSource, createConvTranspose2DProgramInfo;\n var init_conv_backprop_webgpu = __esm({\n "web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_webgpu.ts"() {\n "use strict";\n init_wasm_common();\n init_log();\n init_util();\n init_common();\n createConvTranspose2DOpProgramShaderSource = (shaderHelper, inputs, outputShape, hasBias, is1DimensionDispatch, isVec4 = false, dataType, uniforms, isChannelsLast = false) => {\n const rowDim = isChannelsLast ? 1 : 2;\n const colDim = isChannelsLast ? 2 : 3;\n const channelDim = isChannelsLast ? 3 : 1;\n const workPerThread = isVec4 ? 2 : 1;\n let declareFunctions = `\n fn setOutputAtIndex(flatIndex : u32, value : ${isVec4 ? `vec4<${dataType}>` : dataType}) {\n result[flatIndex] = ${isVec4 ? `vec4<${dataType}>` : dataType}(value);\n }`;\n if (hasBias) {\n declareFunctions += `\n fn getBiasByOutputCoords(coords : vec4) -> ${isVec4 ? `vec4<${dataType}>` : dataType} {\n return bias[coords.${isChannelsLast ? "w" : "y"}${isVec4 ? "/ 4" : ""}];\n }`;\n }\n const components = isVec4 ? 4 : 1;\n const w = inputVariable("W", inputs[1].dataType, inputs[1].dims.length, components);\n const dy = inputVariable("Dy", inputs[0].dataType, inputs[0].dims.length, components);\n const inputVariables = [dy, w];\n if (hasBias) {\n inputVariables.push(inputVariable("bias", inputs[2].dataType, [outputShape[channelDim]].length, components));\n }\n const output = outputVariable("result", inputs[0].dataType, outputShape.length, components);\n const codeSnippet4 = `{\n let batch: u32 = ${is1DimensionDispatch ? "global_id.z" : "workgroup_id.z"} / uniforms.result_shape[1];\n let r = ${is1DimensionDispatch ? "global_id.z" : "workgroup_id.z"} % uniforms.result_shape[1];\n let c = ${is1DimensionDispatch ? "global_id.y" : "workgroup_id.y"} * ${workPerThread};\n let d1: u32 = ${is1DimensionDispatch ? "global_id.x" : "workgroup_id.x"} * 4;\n\n let dyCorner = vec2(i32(r), i32(c)) - vec2(uniforms.pads);\n\n // Convolve dy(?, ?, d2) with w(:, :, d1, d2) to compute dx(xR, xC, d1).\n // ? = to be determined. : = across all values in that axis.\n var dotProd: array, ${workPerThread}>;\n for (var i = 0; i < ${workPerThread}; i++) {\n dotProd[i] = vec4<${dataType}>(0.0);\n }\n for (var wR: u32 = 0; wR < uniforms.filter_dims[0]; wR = wR + 1) {\n var dyR = (${dataType}(dyCorner.x) + ${dataType}(wR)) / ${dataType}(uniforms.strides.x);\n let wRPerm = uniforms.filter_dims[0] - 1 - wR;\n if (dyR < 0.0 || dyR >= ${dataType}(uniforms.Dy_shape[1]) ||\n fract(dyR) > 0.0 || wRPerm < 0) {\n continue;\n }\n let idyR: u32 = u32(dyR);\n\n for (var wC: u32 = 0; wC < uniforms.filter_dims[1]; wC = wC + 1) {\n let dyC = (${dataType}(dyCorner.y) + ${dataType}(wC)) / ${dataType}(uniforms.strides.y);\n let dyC2 = (${dataType}(dyCorner.y) + 1.0 + ${dataType}(wC)) / ${dataType}(uniforms.strides.y);\n let wCPerm = uniforms.filter_dims[1] - 1 - wC;\n if (wCPerm < 0) {\n continue;\n }\n var bDyCVal = true;\n var bDyCVal2 = true;\n if (dyC < 0.0 || dyC >= ${dataType}(uniforms.Dy_shape[2]) ||\n fract(dyC) > 0.0) {\n bDyCVal = false;\n }\n if (dyC2 < 0.0 || dyC2 >= ${dataType}(uniforms.Dy_shape[2]) ||\n fract(dyC2) > 0.0) {\n bDyCVal2 = false;\n }\n\n let idyC: u32 = u32(dyC);\n let idyC2: u32 = u32(dyC2);\n if (bDyCVal && bDyCVal2) {\n let d2Length = uniforms.Dy_shape[3];\n for (var d2 :u32 = 0; d2 < d2Length; d2 = d2 + 4) {\n let wValue0 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1", "d2")};\n let wValue1 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 1", "d2")};\n let wValue2 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 2", "d2")};\n let wValue3 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 3", "d2")};\n\n var xValue = ${dy.get("batch", "idyR", "idyC", "d2")};\n let tmpval = vec4<${dataType}>(dot(xValue, wValue0),\n dot(xValue, wValue1),\n dot(xValue, wValue2),\n dot(xValue, wValue3));\n dotProd[0] = dotProd[0] + tmpval;\n\n xValue = ${dy.get("batch", "idyR", "idyC2", "d2")};\n\n dotProd[1] = dotProd[1] + vec4<${dataType}>(dot(xValue, wValue0),\n dot(xValue, wValue1),\n dot(xValue, wValue2),\n dot(xValue, wValue3));\n }\n } else if (bDyCVal) {\n let d2Length = uniforms.Dy_shape[${channelDim}];\n for (var d2: u32 = 0; d2 < d2Length; d2 = d2 + 4) {\n let wValue0 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1", "d2")};\n let wValue1 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 1", "d2")};\n let wValue2 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 2", "d2")};\n let wValue3 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 3", "d2")};\n\n var xValue = ${dy.get("batch", "idyR", "idyC", "d2")};\n let tmpval = vec4<${dataType}>(dot(xValue, wValue0),\n dot(xValue, wValue1),\n dot(xValue, wValue2),\n dot(xValue, wValue3));\n dotProd[0] = dotProd[0] + tmpval;\n }\n } else if (bDyCVal2) {\n let d2Length = uniforms.Dy_shape[3];\n for (var d2: u32 = 0; d2 < d2Length; d2 = d2 + 4) {\n let wValue0 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1", "d2")};\n let wValue1 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 1", "d2")};\n let wValue2 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 2", "d2")};\n let wValue3 = ${w.get("u32(wRPerm)", "u32(wCPerm)", "d1 + 3", "d2")};\n\n var xValue = ${dy.get("batch", "idyR", "idyC2", "d2")};\n let tmpval = vec4<${dataType}>(dot(xValue, wValue0),\n dot(xValue, wValue1),\n dot(xValue, wValue2),\n dot(xValue, wValue3));\n dotProd[1] = dotProd[1] + tmpval;\n }\n }\n }\n }\n\n for (var i: u32 = 0; i < ${workPerThread}; i = i + 1) {\n let value = dotProd[i] + ${hasBias ? "bias[c+i]" : `vec4<${dataType}>(0.0)`};\n ${output.set("batch", "r", "c + i", "d1", "value")};\n }\n }`;\n const codeSnippet = `\n let outputIndices = ${output.offsetToIndices("global_idx")};\n let batch = ${output.indicesGet("outputIndices", 0)};\n let d1 = ${output.indicesGet("outputIndices", channelDim)};\n let r = ${output.indicesGet("outputIndices", rowDim)};\n let c = ${output.indicesGet("outputIndices", colDim)};\n let dyCorner = vec2(i32(r), i32(c)) - uniforms.pads;\n let dyRCorner = dyCorner.x;\n let dyCCorner = dyCorner.y;\n let groupId = d1 / uniforms.output_channels_per_group;\n let wOutChannel = d1 - groupId * uniforms.output_channels_per_group;\n // Convolve dy(?, ?, d2) with w(:, :, d1, d2) to compute dx(xR, xC, d1).\n // ? = to be determined. : = across all values in that axis.\n var dotProd = ${dataType}(0.0);\n for (var wR: u32 = 0; wR < uniforms.effective_filter_dims.x; wR = wR + 1) {\n if (wR % uniforms.dilations.x != 0) {\n continue;\n }\n let dyR = (${dataType}(dyRCorner) + ${dataType}(wR)) / ${dataType}(uniforms.strides[0]);\n let wRPerm = uniforms.filter_dims.x - 1 - wR / uniforms.dilations.x;\n if (dyR < 0.0 || dyR >= ${dataType}(uniforms.Dy_shape[${rowDim}]) || fract(dyR) > 0.0 ||\n wRPerm < 0) {\n continue;\n }\n let idyR: u32 = u32(dyR);\n\n for (var wC: u32 = 0; wC < uniforms.effective_filter_dims.y; wC = wC + 1) {\n if (wC % uniforms.dilations.y != 0) {\n continue;\n }\n let dyC = (${dataType}(dyCCorner) + ${dataType}(wC)) / ${dataType}(uniforms.strides.y);\n let wCPerm = uniforms.filter_dims.y - 1 - wC / uniforms.dilations.y;\n if (dyC < 0.0 || dyC >= ${dataType}(uniforms.Dy_shape[${colDim}]) ||\n fract(dyC) > 0.0 || wCPerm < 0) {\n continue;\n }\n let idyC: u32 = u32(dyC);\n var inputChannel = groupId * uniforms.input_channels_per_group;\n for (var d2: u32 = 0; d2 < uniforms.input_channels_per_group; d2 = d2 + 1) {\n let xValue = ${isChannelsLast ? dy.get("batch", "idyR", "idyC", "inputChannel") : dy.get("batch", "inputChannel", "idyR", "idyC")};\n let wValue = ${w.get("inputChannel", "wOutChannel", "u32(wRPerm)", "u32(wCPerm)")};\n dotProd = dotProd + xValue * wValue;\n inputChannel = inputChannel + 1;\n }\n }\n }\n let value = dotProd + ${hasBias ? "bias[d1]" : `${dataType}(0.0)`};\n ${output.setByOffset("global_idx", "value")};\n `;\n return `\n ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n ${declareFunctions}\n\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")};\n ${isVec4 ? codeSnippet4 : codeSnippet}}`;\n };\n createConvTranspose2DProgramInfo = (inputs, attributes, squeezeOutputShapeFunction) => {\n const hasBias = inputs.length > 2;\n const outputShape = attributes.outputShape;\n const outputSize = ShapeUtil.size(outputShape);\n const dispatch = [\n Math.ceil(outputSize / 64),\n 1,\n 1\n ];\n LOG_DEBUG("verbose", () => `[conv2d_backprop_webgpu] dispatch = ${dispatch}`);\n const isChannelsLast = attributes.format === "NHWC";\n const inputDependencies = ["rank", "rank"];\n const strides = [attributes.strides[0], attributes.strides[1]];\n const filterDims = [attributes.kernelShape[isChannelsLast ? 1 : 2], attributes.kernelShape[isChannelsLast ? 2 : 3]];\n const dilations = [attributes.dilations[0], attributes.dilations[1]];\n const effectiveFilterDims = [\n filterDims[0] + (attributes.dilations[0] <= 1 ? 0 : (attributes.kernelShape[isChannelsLast ? 1 : 2] - 1) * (attributes.dilations[0] - 1)),\n filterDims[1] + (attributes.dilations[1] <= 1 ? 0 : (attributes.kernelShape[isChannelsLast ? 2 : 3] - 1) * (attributes.dilations[1] - 1))\n ];\n const pads = [\n effectiveFilterDims[0] - 1 - Math.floor((attributes.pads[0] + attributes.pads[2]) / 2),\n effectiveFilterDims[1] - 1 - Math.floor(attributes.pads[1] + attributes.pads[3]) / 2\n ];\n const isVec4 = false;\n const group = attributes.group;\n const wShape = inputs[1].dims;\n const inputChannelsPerGroup = wShape[0] / group;\n const outputChannelsPerGroup = wShape[1];\n const programUniforms = [\n { type: 12 /* uint32 */, data: outputSize },\n { type: 12 /* uint32 */, data: strides },\n { type: 12 /* uint32 */, data: filterDims },\n { type: 12 /* uint32 */, data: dilations },\n { type: 12 /* uint32 */, data: effectiveFilterDims },\n { type: 6 /* int32 */, data: pads },\n { type: 12 /* uint32 */, data: inputChannelsPerGroup },\n { type: 12 /* uint32 */, data: outputChannelsPerGroup },\n ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims)\n ];\n if (hasBias) {\n programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n inputDependencies.push("rank");\n }\n programUniforms.push(...createTensorShapeVariables(outputShape));\n const is1DimensionDispatch = dispatch[1] === 1 && dispatch[2] === 1;\n const getShaderSource = (shaderHelper) => {\n const uniforms = [\n { name: "output_size", type: "u32" },\n { name: "strides", type: "u32", length: strides.length },\n { name: "filter_dims", type: "u32", length: filterDims.length },\n { name: "dilations", type: "u32", length: filterDims.length },\n { name: "effective_filter_dims", type: "u32", length: effectiveFilterDims.length },\n { name: "pads", type: "i32", length: pads.length },\n { name: "input_channels_per_group", type: "u32" },\n { name: "output_channels_per_group", type: "u32" }\n ];\n const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n return `${createConvTranspose2DOpProgramShaderSource(\n shaderHelper,\n inputs,\n outputShape,\n hasBias,\n is1DimensionDispatch,\n isVec4,\n dataType,\n uniforms,\n isChannelsLast\n )}`;\n };\n return {\n name: "ConvTranspose2D",\n shaderCache: { hint: `${attributes.cacheKey};`, inputDependencies },\n getRunData: () => ({\n dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] },\n outputs: [{\n dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,\n dataType: inputs[0].dataType\n }],\n programUniforms\n }),\n getShaderSource\n };\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/conv-transpose.ts\n var computeTotalPad, distributePadding, calculateOutputShapeAndPads, getAdjustedConvTransposeAttributes, parseConvTransposeAttributes, validateInputs10, weightTransposePerm, convTranspose2d, convTranspose1d, convTranspose;\n var init_conv_transpose = __esm({\n "web/lib/wasm/jsep/webgpu/ops/conv-transpose.ts"() {\n "use strict";\n init_conv_backprop_mm_webgpu();\n init_conv_backprop_webgpu();\n init_fuse_utils();\n init_transpose();\n computeTotalPad = (inDim, stride, adj, kernel, dilation, outSize) => (inDim - 1) * stride + adj + (kernel - 1) * dilation + 1 - outSize;\n distributePadding = (totalPad, autoPad, pads, head, tail) => {\n const smallPad = Math.floor(totalPad / 2);\n if (autoPad === "SAME_UPPER") {\n pads[head] = smallPad;\n pads[tail] = totalPad - smallPad;\n } else if (autoPad === "SAME_LOWER") {\n pads[head] = totalPad - smallPad;\n pads[tail] = smallPad;\n }\n };\n calculateOutputShapeAndPads = (inputShape, kernelShape, dilations, autoPad, group, pads, strides, isChannelLast, outputPadding, outputShape) => {\n const spatialRank = inputShape.length - 2;\n const updateOutputShape = outputShape.length === 0;\n if (outputPadding.length === 0) {\n for (let i = 0; i < spatialRank; ++i) {\n outputPadding.push(0);\n }\n }\n const batchSize = inputShape[0];\n const outChannels = kernelShape[isChannelLast ? 3 : 1] * group;\n for (let i = 0, j = inputShape.length - spatialRank - (isChannelLast ? 1 : 0); i < spatialRank; ++i, ++j) {\n const inSize = inputShape[j];\n const outSize = updateOutputShape ? inSize * strides[i] : outputShape[i];\n const totalPad = computeTotalPad(inSize, strides[i], pads[i], kernelShape[j], dilations[i], outSize);\n distributePadding(totalPad, autoPad, pads, i, i + spatialRank);\n if (updateOutputShape) {\n outputShape.push(\n strides[i] * (inSize - 1) + outputPadding[i] + (kernelShape[j] - 1) * dilations[i] + 1 - pads[i] - pads[i + spatialRank]\n );\n }\n }\n outputShape.splice(0, 0, batchSize);\n outputShape.splice(isChannelLast ? 3 : 1, 0, outChannels);\n };\n getAdjustedConvTransposeAttributes = (attributes, inputs) => {\n const kernelShape = attributes.kernelShape.slice();\n if (attributes.kernelShape.length === 0 || attributes.kernelShape.reduce((a, b) => a * b, 1) === 0) {\n kernelShape.length = 0;\n for (let i = 2; i < inputs[1].dims.length; ++i) {\n kernelShape.push(inputs[1].dims[i]);\n }\n }\n const isChannelsLast = attributes.format === "NHWC";\n kernelShape.splice(0, 0, inputs[1].dims[0]);\n kernelShape.splice(isChannelsLast ? 3 : 1, 0, inputs[1].dims[1]);\n const pads = attributes.pads.slice();\n const outputShape = attributes.outputShape.slice();\n const outputPadding = attributes.outputPadding.slice();\n const inputShape = inputs[0].dims;\n let dilations = attributes.dilations.slice();\n if (dilations.reduce((a, b) => a + b, 0) === 0) {\n const spatialRank = inputs[0].dims.length - 2;\n dilations = new Array(spatialRank).fill(1);\n }\n let strides = attributes.strides.slice();\n if (strides.reduce((a, b) => a + b, 0) === 0) {\n const spatialRank = inputs[0].dims.length - 2;\n strides = new Array(spatialRank).fill(1);\n }\n calculateOutputShapeAndPads(\n inputShape,\n kernelShape,\n dilations,\n attributes.autoPad,\n attributes.group,\n pads,\n strides,\n isChannelsLast,\n outputPadding,\n outputShape\n );\n const newAttributes = Object.assign({}, attributes);\n Object.assign(newAttributes, { kernelShape, pads, outputPadding, outputShape, dilations, strides });\n return newAttributes;\n };\n parseConvTransposeAttributes = (attributes) => {\n const activationAttributes = parseInternalActivationAttributes(attributes);\n const format = attributes.format;\n const autoPad = [\n "NOTSET",\n "VALID",\n "SAME_UPPER",\n "SAME_LOWER"\n ][typeof attributes.autoPad == "undefined" ? 0 : attributes.autoPad];\n const dilations = attributes.dilations;\n const group = attributes.group;\n const kernelShape = attributes.kernelShape;\n const pads = attributes.pads;\n const strides = attributes.strides;\n const wIsConst = attributes.wIsConst();\n const outputPadding = attributes.outputPadding;\n const outputShape = attributes.outputShape;\n return {\n autoPad,\n format,\n dilations,\n group,\n kernelShape,\n outputPadding,\n outputShape,\n pads,\n strides,\n wIsConst,\n ...activationAttributes,\n cacheKey: `${attributes.format};${activationAttributes.activation};`\n };\n };\n validateInputs10 = (inputs, attributes) => {\n if (!inputs || inputs.length !== 2 && inputs.length !== 3) {\n throw new Error("Conv requires 2 or 3 inputs");\n }\n if (inputs[0].dims.length !== 4 && inputs[0].dims.length !== 3) {\n throw new Error("currently only support 2-dimensional conv");\n }\n if (inputs[0].dims.length !== inputs[1].dims.length) {\n throw new Error("filter does not have same dimension as input");\n }\n const dataChannel = inputs[0].dims[attributes.format === "NHWC" ? inputs[0].dims.length - 1 : 1];\n const filterInChannel = inputs[1].dims[0];\n if (dataChannel !== filterInChannel) {\n throw new Error("FILTER_IN_CHANNEL should be equal to DATA_CHANNEL");\n }\n const featureMaps = inputs[1].dims[1] * attributes.group;\n if (inputs.length === 3 && (inputs[2].dims.length !== 1 || inputs[2].dims[0] !== featureMaps)) {\n throw new Error("invalid bias");\n }\n const spatialRank = inputs[0].dims.length - 2;\n const dilationsSet = attributes.dilations.reduce((a, b) => a + b, 0) > 0;\n if (dilationsSet && attributes.dilations.length !== spatialRank) {\n throw new Error(`dilations should be ${spatialRank}D`);\n }\n const stridesSet = attributes.strides.reduce((a, b) => a + b, 0) > 0;\n if (stridesSet && attributes.strides.length !== spatialRank) {\n throw new Error(`strides should be ${spatialRank}D`);\n }\n const padsSet = attributes.pads.reduce((a, b) => a + b, 0) > 0;\n if (padsSet && attributes.pads.length !== spatialRank * 2) {\n throw new Error(`pads should be ${spatialRank * 2}D`);\n }\n if (attributes.outputPadding.length !== spatialRank && attributes.outputPadding.length !== 0) {\n throw new Error(`output_padding should be ${spatialRank}D`);\n }\n const kernelShapeSet = attributes.kernelShape.reduce((a, b) => a + b, 0) > 0;\n if (kernelShapeSet && attributes.kernelShape.length !== 0 && attributes.kernelShape.length !== inputs[1].dims.length - 2) {\n throw new Error("invalid kernel shape");\n }\n if (attributes.outputShape.length !== 0 && attributes.outputShape.length !== inputs[0].dims.length - 2) {\n throw new Error("invalid output shape");\n }\n };\n weightTransposePerm = [2, 3, 1, 0];\n convTranspose2d = (context, inputs, attributes) => {\n const adjustedAttributes = getAdjustedConvTransposeAttributes(attributes, inputs);\n const isChannelsLast = attributes.format === "NHWC";\n const outputShape = adjustedAttributes.outputShape;\n const outChannels = outputShape[isChannelsLast ? 3 : 1];\n const inputChannels = inputs[0].dims[isChannelsLast ? 3 : 1];\n if (adjustedAttributes.group !== 1 || outChannels === 1 && inputChannels === 1) {\n context.compute(createConvTranspose2DProgramInfo(inputs, adjustedAttributes));\n return;\n }\n const outHeight = outputShape[isChannelsLast ? 1 : 2];\n const outWidth = outputShape[isChannelsLast ? 2 : 3];\n const weightHeight = inputs[1].dims[2];\n const weightWidth = inputs[1].dims[3];\n const dimAOuter = isChannelsLast ? outHeight * outWidth : outChannels;\n const dimBOuter = isChannelsLast ? outChannels : outHeight * outWidth;\n const dimInner = weightHeight * weightWidth * inputChannels;\n const sequentialAccessByThreads = (\n /* backend.adapterInfo.isIntel() */\n true\n );\n const transposedWeight = context.kernelCustomData.wT ?? context.compute(\n createTransposeProgramInfo(inputs[1], weightTransposePerm),\n { inputs: [1], outputs: [attributes.wIsConst ? -2 : -1] }\n )[0];\n if (attributes.wIsConst && !context.kernelCustomData.wT) {\n context.kernelCustomData.wT = transposedWeight;\n }\n const convTransposeInputs = [inputs[0], transposedWeight];\n const hasBias = inputs.length === 3;\n if (hasBias) {\n if (!isChannelsLast && inputs[2].dims.length === 1) {\n convTransposeInputs.push(inputs[2].reshape([inputs[2].dims[0], 1, 1]));\n } else {\n convTransposeInputs.push(inputs[2]);\n }\n }\n context.compute(\n createConv2DTransposeMatMulProgramInfo(\n convTransposeInputs,\n adjustedAttributes,\n outputShape,\n dimAOuter,\n dimBOuter,\n dimInner,\n hasBias,\n sequentialAccessByThreads\n ),\n { inputs: convTransposeInputs }\n );\n };\n convTranspose1d = (context, attributes) => {\n const isChannelLast = attributes.format === "NHWC";\n const inputs = [\n context.inputs[0].reshape(\n isChannelLast ? (\n // [N, W, C] -> [N, H=1, W, C]\n [context.inputs[0].dims[0], 1, context.inputs[0].dims[1], context.inputs[0].dims[2]]\n ) : (\n // [N, C, W] -> [N, C, H=1, W]\n [context.inputs[0].dims[0], context.inputs[0].dims[1], 1, context.inputs[0].dims[2]]\n )\n ),\n //[FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kW] -> [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kH=1, kW]\n context.inputs[1].reshape([context.inputs[1].dims[0], context.inputs[1].dims[1], 1, context.inputs[1].dims[2]])\n ];\n if (context.inputs.length === 3) {\n inputs.push(context.inputs[2]);\n }\n let kernelShape = attributes.kernelShape;\n if (kernelShape.length === 0 || kernelShape[0] === 0) {\n kernelShape = [context.inputs[1].dims[2]];\n }\n let dilations = attributes.dilations;\n if (dilations.length === 0 || dilations[0] === 0) {\n dilations = [1];\n }\n let strides = attributes.strides;\n if (strides.length === 0 || strides[0] === 0) {\n strides = [1];\n }\n let pads = attributes.pads;\n if (pads.length === 0) {\n pads = [0, 0];\n }\n pads = [0, pads[0], 0, pads[1]];\n strides = [1].concat(strides);\n dilations = [1].concat(dilations);\n kernelShape = [1].concat(kernelShape);\n const adjustedAttributes = getAdjustedConvTransposeAttributes({ ...attributes, pads, strides, dilations, kernelShape }, inputs);\n context.compute(createConvTranspose2DProgramInfo(\n inputs,\n adjustedAttributes,\n (outputShape) => isChannelLast ? [outputShape[0], outputShape[2], outputShape[3]] : [outputShape[0], outputShape[1], outputShape[3]]\n ));\n };\n convTranspose = (context, attributes) => {\n validateInputs10(context.inputs, attributes);\n if (context.inputs[0].dims.length === 3) {\n convTranspose1d(context, attributes);\n } else {\n convTranspose2d(context, context.inputs, attributes);\n }\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/cumsum.ts\n var createCumsumProgramInfo, cumsum, parseCumSumAttributes;\n var init_cumsum = __esm({\n "web/lib/wasm/jsep/webgpu/ops/cumsum.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_attribute_with_cache_key();\n init_common();\n createCumsumProgramInfo = (inputType, inputShape, axisInput, attributes) => {\n const outputSize = ShapeUtil.size(inputShape);\n const rank = inputShape.length;\n const input = inputVariable("input", inputType, rank);\n const output = outputVariable("output", inputType, rank);\n const axisValue = axisInput.dataType === 6 /* int32 */ ? axisInput.getInt32Array()[0] : Number(axisInput.getBigInt64Array()[0]);\n const axis = ShapeUtil.normalizeAxis(axisValue, rank);\n const getShaderSource = (shaderHelper) => {\n const index = ` i32(${input.indicesGet("inputIndices", "uniforms.axis")}) `;\n const max = getElementAt("uniforms.input_shape", "uniforms.axis", rank);\n const lowerLimit = attributes.reverse ? index + (attributes.exclusive ? " + 1" : "") : "0";\n const upperLimit = attributes.reverse ? max : index + (attributes.exclusive ? "" : " + 1");\n return `\n ${shaderHelper.registerUniform("outputSize", "u32").registerUniform("axis", "u32").declareVariables(input, output)}\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}\n var inputIndices = ${output.offsetToIndices("global_idx")};\n var sum = ${output.type.value}(0);\n let first : i32 = ${lowerLimit};\n let last : i32 = ${upperLimit};\n for (var i : i32 = first; i < last; i++) {\n ${input.indicesSet("inputIndices", "uniforms.axis", "u32(i)")};\n sum = sum + ${input.getByIndices("inputIndices")};\n }\n ${output.setByOffset("global_idx", "sum")};\n }`;\n };\n return {\n name: "CumSum",\n shaderCache: { hint: attributes.cacheKey, inputDependencies: ["rank"] },\n getRunData: () => ({\n outputs: [{ dims: inputShape, dataType: inputType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms: [\n { type: 12 /* uint32 */, data: outputSize },\n { type: 12 /* uint32 */, data: axis },\n ...createTensorShapeVariables(inputShape, inputShape)\n ]\n }),\n getShaderSource\n };\n };\n cumsum = (context, attributes) => {\n const inputShape = context.inputs[0].dims;\n const inputType = context.inputs[0].dataType;\n const axis = context.inputs[1];\n context.compute(createCumsumProgramInfo(inputType, inputShape, axis, attributes), { inputs: [0] });\n };\n parseCumSumAttributes = (attributes) => {\n const exclusive = attributes.exclusive === 1;\n const reverse = attributes.reverse === 1;\n return createAttributeWithCacheKey({ exclusive, reverse });\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/depth-to-space.ts\n var validateInputs11, permFunctionBody2, createDepthToSpaceProgramInfo, depthToSpace, parseDepthToSpaceAttributes;\n var init_depth_to_space = __esm({\n "web/lib/wasm/jsep/webgpu/ops/depth-to-space.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_attribute_with_cache_key();\n init_common();\n validateInputs11 = (inputs) => {\n if (!inputs || inputs.length !== 1) {\n throw new Error("DepthToSpace requires 1 input.");\n }\n if (inputs[0].dims.length !== 4) {\n throw new Error("DepthToSpace requires 4D input.");\n }\n };\n permFunctionBody2 = (perm, rank, input, output) => {\n const reverseFunc = [];\n reverseFunc.push(`fn perm(i: ${output.type.indices}) -> ${input.type.indices} {\n var a: ${input.type.indices};`);\n for (let i = 0; i < rank; ++i) {\n reverseFunc.push(input.indicesSet("a", perm[i], `i[${i}]`));\n }\n reverseFunc.push("return a;}");\n return reverseFunc.join("\\n");\n };\n createDepthToSpaceProgramInfo = (inputTensor, attributes) => {\n let n, h, w, c;\n let shape;\n let perm;\n const isChannelLast = attributes.format === "NHWC";\n const blocksize = attributes.blocksize;\n const isDCRmode = attributes.mode === "DCR";\n if (isChannelLast) {\n [n, h, w, c] = inputTensor.dims;\n shape = isDCRmode ? [n, h, w, blocksize, blocksize, c / blocksize ** 2] : [n, h, w, c / blocksize ** 2, blocksize, blocksize];\n perm = isDCRmode ? [0, 1, 3, 2, 4, 5] : [0, 1, 4, 2, 5, 3];\n } else {\n [n, h, w, c] = [inputTensor.dims[0], inputTensor.dims[2], inputTensor.dims[3], inputTensor.dims[1]];\n shape = isDCRmode ? [n, blocksize, blocksize, c / blocksize ** 2, h, w] : [n, c / blocksize ** 2, blocksize, blocksize, h, w];\n perm = isDCRmode ? [0, 3, 4, 1, 5, 2] : [0, 1, 4, 2, 5, 3];\n }\n const reshapedInputTensor = inputTensor.reshape(shape);\n const reshapedInputRank = reshapedInputTensor.dims.length;\n const inputDataType = inputTensor.dataType;\n const reshapedInput = inputVariable("a", inputDataType, reshapedInputRank);\n const permedOutput = outputVariable("output", inputDataType, reshapedInputRank);\n const getShaderSource = (shaderHelper) => `\n ${shaderHelper.registerUniform("output_size", "u32").declareVariables(reshapedInput, permedOutput)}\n\n ${permFunctionBody2(perm, reshapedInputRank, reshapedInput, permedOutput)}\n\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}\n\n let indices = ${permedOutput.offsetToIndices("global_idx")};\n let aIndices = perm(indices);\n\n ${permedOutput.setByOffset("global_idx", reshapedInput.getByIndices("aIndices"))}\n }`;\n return {\n name: "DepthToSpace",\n shaderCache: { hint: `${inputTensor.dims};${attributes.blocksize};${attributes.mode}`, inputDependencies: ["rank"] },\n getRunData: (inputs) => {\n const outputShape = isChannelLast ? [n, h * blocksize, w * blocksize, c / blocksize ** 2] : [n, c / blocksize ** 2, h * blocksize, w * blocksize];\n const outputSize = ShapeUtil.size(outputShape);\n const shapeBeforePerm = reshapedInputTensor.dims;\n const shapeAfterPerm = ShapeUtil.sortBasedOnPerm(shapeBeforePerm, perm);\n return {\n outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms: [{ type: 12 /* uint32 */, data: outputSize }, ...createTensorShapeVariables(shapeBeforePerm, shapeAfterPerm)]\n };\n },\n getShaderSource\n };\n };\n depthToSpace = (context, attributes) => {\n validateInputs11(context.inputs);\n context.compute(createDepthToSpaceProgramInfo(context.inputs[0], attributes));\n };\n parseDepthToSpaceAttributes = (attributes) => createAttributeWithCacheKey({\n blocksize: attributes.blocksize,\n mode: attributes.mode,\n format: attributes.format\n });\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/einsum.ts\n var symbolPattern, termPattern, termPatternOnly, lhsPattern, lhsPatternOnly, EinsumTerm, EinsumEquation, appendMax, createEinsumProgramInfo, einsum, parseEinsumAttributes;\n var init_einsum = __esm({\n "web/lib/wasm/jsep/webgpu/ops/einsum.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_attribute_with_cache_key();\n init_common();\n symbolPattern = "[a-zA-Z]|\\\\.\\\\.\\\\.";\n termPattern = "(" + symbolPattern + ")+";\n termPatternOnly = "^" + termPattern + "$";\n lhsPattern = "(" + termPattern + ",)*" + termPattern;\n lhsPatternOnly = "^" + lhsPattern + "$";\n EinsumTerm = class {\n constructor(inputIndex = -1) {\n this.symbolToIndices = /* @__PURE__ */ new Map();\n this.inputIndex = inputIndex;\n }\n // Add a symbol to the term\n addSymbol(symbol, index) {\n let value = this.symbolToIndices.get(symbol);\n if (value === void 0) {\n value = [index];\n } else {\n value.push(index);\n }\n this.symbolToIndices.set(symbol, value);\n }\n // -1 for output and 0, 1, 2, ... for inputs\n };\n EinsumEquation = class {\n constructor(inputs, equation) {\n this.equation = equation;\n this.hasEllipsis = false;\n this.symbolToInfo = /* @__PURE__ */ new Map();\n this.lhs = new Array();\n this.outputDims = [];\n let [lhs, rhs] = equation.includes("->") ? equation.split("->", 2) : [equation, ""];\n if (!lhs.match(RegExp(lhsPatternOnly))) {\n throw new Error("Invalid LHS term");\n }\n const inputTerms = lhs.split(",");\n inputTerms.forEach((inputTerm, index) => {\n const dims = inputs[index].dims.slice();\n if (!inputTerm.match(RegExp(termPatternOnly))) {\n throw new Error("Invalid LHS term");\n }\n const einsumTerm = this.processTerm(inputTerm, true, dims, index);\n this.lhs.push(einsumTerm);\n });\n if (rhs === "") {\n rhs += [...this.symbolToInfo.entries()].filter(([sym, info]) => info.count === 1 || sym === "...").map(([sym]) => sym).join("");\n } else {\n if (!rhs.match(RegExp(termPattern))) {\n throw new Error("Invalid RHS");\n }\n }\n const rhsSymbols = rhs.match(RegExp(symbolPattern, "g"));\n rhsSymbols?.forEach((symbol) => {\n if (symbol === "...") {\n this.outputDims = this.outputDims.concat(this.ellipsisDims);\n } else {\n const info = this.symbolToInfo.get(symbol);\n if (info === void 0) {\n throw new Error("Invalid RHS symbol");\n }\n this.outputDims.push(info.dimValue);\n }\n });\n this.rhs = this.processTerm(rhs, false, this.outputDims);\n }\n // End of EinsumEqation constructor\n // Add a symbol to the equation\n addSymbol(symbol, dimValue, inputIndex) {\n let info = this.symbolToInfo.get(symbol);\n if (info !== void 0) {\n if (info.dimValue !== dimValue && info.count !== 1) {\n throw new Error("Dimension mismatch");\n } else {\n info.count++;\n info.inputIndices.push(inputIndex);\n }\n } else {\n info = { count: 1, dimValue, inputIndices: [inputIndex] };\n }\n this.symbolToInfo.set(symbol, info);\n }\n // Process one input/output term\n processTerm(term, isInput, dims, index = -1) {\n const rank = dims.length;\n let ellipsis = false;\n let ellipsisDims = [];\n let nextDim = 0;\n if (!term.match(RegExp(termPatternOnly)) && (!isInput && term !== "")) {\n throw new Error("Invalid LHS term");\n }\n const indexSymbols = term.match(RegExp(symbolPattern, "g"));\n const einsumTerm = new EinsumTerm(index);\n indexSymbols?.forEach((symbol, i) => {\n if (symbol === "...") {\n if (ellipsis) {\n throw new Error("Only one ellipsis is allowed per input term");\n }\n ellipsis = true;\n const ellipsisDimLength = rank - indexSymbols.length + 1;\n if (ellipsisDimLength < 0) {\n throw new Error("Ellipsis out of bounds");\n }\n ellipsisDims = dims.slice(nextDim, nextDim + ellipsisDimLength);\n if (this.hasEllipsis) {\n if (this.ellipsisDims.length !== ellipsisDims.length || this.ellipsisDims.toString() !== ellipsisDims.toString()) {\n throw new Error("Ellipsis dimensions mismatch");\n }\n } else if (isInput) {\n this.hasEllipsis = true;\n this.ellipsisDims = ellipsisDims;\n } else {\n throw new Error("Ellipsis must be specified in the LHS");\n }\n for (let j = 0; j < ellipsisDims.length; j++) {\n const symbol2 = String.fromCharCode("0".charCodeAt(0) + j);\n einsumTerm.addSymbol(symbol2, i + j);\n this.addSymbol(symbol2, dims[nextDim++], index);\n }\n } else {\n einsumTerm.addSymbol(symbol, i + (this.hasEllipsis ? this.ellipsisDims.length - 1 : 0));\n this.addSymbol(symbol, dims[nextDim++], index);\n }\n });\n return einsumTerm;\n }\n // Output dimensions of the equation\n };\n appendMax = (name) => name + "_max";\n createEinsumProgramInfo = (inputShapes, dataType, einsumEquation, outputShape) => {\n const ranks = inputShapes.map((dims) => dims.length);\n const inputVars = ranks.map((rank, index) => inputVariable(`input${index}`, dataType, rank));\n const outputSize = ShapeUtil.size(outputShape);\n const output = outputVariable("output", dataType, outputShape.length);\n const uniformsSymbols = [...einsumEquation.symbolToInfo.keys()].filter((symbol) => !einsumEquation.rhs.symbolToIndices.has(symbol));\n const getShaderSource = (shaderHelper) => {\n const idxCopy = [];\n const initProd = "var prod = 1.0;";\n const initSum = "var sum = 0.0;";\n const updateSum = "sum += prod;";\n const reduceOpsSetIndices = [];\n const reduceOpsLoopHeaders = [];\n const reduceOpsLoopFooters = [];\n const reduceOpCompute = [];\n const isReduceOpsWithoutLoop = einsumEquation.symbolToInfo.size === einsumEquation.rhs.symbolToIndices.size;\n einsumEquation.symbolToInfo.forEach((info, symbol) => {\n if (einsumEquation.rhs.symbolToIndices.has(symbol)) {\n const outputIndex = einsumEquation.rhs.symbolToIndices.get(symbol)?.[0];\n if (outputIndex !== void 0) {\n einsumEquation.lhs.forEach((term, i) => {\n if (info.inputIndices.includes(i)) {\n const indices = term.symbolToIndices.get(symbol);\n if (indices === void 0) {\n throw new Error("Invalid symbol error");\n }\n indices.forEach((index) => {\n idxCopy.push(`${inputVars[i].indicesSet(\n `input${i}Indices`,\n index,\n output.indicesGet("outputIndices", outputIndex)\n )}`);\n });\n }\n });\n }\n } else {\n einsumEquation.lhs.forEach((term, i) => {\n if (info.inputIndices.includes(i)) {\n const indices = term.symbolToIndices.get(symbol);\n if (indices === void 0) {\n throw new Error("Invalid symbol error");\n }\n indices.forEach((index) => {\n reduceOpsSetIndices.push(`${inputVars[i].indicesSet(`input${i}Indices`, index, `${symbol}`)}`);\n });\n reduceOpCompute.push(`prod *= ${inputVars[i].getByIndices(`input${i}Indices`)};`);\n }\n });\n reduceOpsLoopHeaders.push(\n `for(var ${symbol}: u32 = 0; ${symbol} < uniforms.${appendMax(symbol)}; ${symbol}++) {`\n );\n reduceOpsLoopFooters.push("}");\n }\n });\n const reduceOps2 = isReduceOpsWithoutLoop ? [\n ...idxCopy,\n `let sum = ${inputVars.map((inputVar, i) => inputVar.getByIndices(`input${i}Indices`)).join(" * ")};`\n ] : [\n ...idxCopy,\n initSum,\n ...reduceOpsLoopHeaders,\n ...reduceOpsSetIndices,\n initProd,\n ...reduceOpCompute,\n updateSum,\n ...reduceOpsLoopFooters\n ];\n return `\n ${shaderHelper.registerUniforms(uniformsSymbols.map((symbol) => ({ name: `${appendMax(symbol)}`, type: "u32" }))).registerUniform("outputSize", "u32").declareVariables(...inputVars, output)}\n\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}\n var outputIndices = ${output.offsetToIndices("global_idx")};\n ${inputVars.map((_var, i) => `var input${i}Indices: ${inputVars[i].type.indices};`).join("\\n")}\n ${reduceOps2.join("\\n")};\n ${output.setByOffset("global_idx", "sum")};\n }`;\n };\n return {\n name: "Einsum",\n shaderCache: { hint: einsumEquation.equation, inputDependencies: inputShapes.map(() => "rank") },\n getRunData: () => {\n const programUniformsInit = uniformsSymbols.filter((symbol) => einsumEquation.symbolToInfo.has(symbol)).map(\n (symbol) => ({ type: 12 /* uint32 */, data: einsumEquation.symbolToInfo.get(symbol)?.dimValue || 0 })\n );\n programUniformsInit.push({ type: 12 /* uint32 */, data: outputSize });\n const programUniforms = inputShapes.map((dims, _) => [...createTensorShapeVariables(dims)]).reduce((acc, inputProgramUniforms) => acc.concat(inputProgramUniforms), programUniformsInit);\n programUniforms.push(...createTensorShapeVariables(outputShape));\n return {\n outputs: [{ dims: outputShape, dataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms\n };\n },\n getShaderSource\n };\n };\n einsum = (context, attributes) => {\n const einsumEquation = new EinsumEquation(context.inputs, attributes.equation);\n const outputShape = einsumEquation.outputDims;\n const inputShapes = context.inputs.map((input, _) => input.dims);\n context.compute(createEinsumProgramInfo(inputShapes, context.inputs[0].dataType, einsumEquation, outputShape));\n };\n parseEinsumAttributes = (attributes) => {\n const equation = attributes.equation.replace(/\\s+/g, "");\n return createAttributeWithCacheKey({ equation });\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/expand.ts\n var validateInputs12, getAdjustedShape, calculateOutputShape2, createExpandProgramInfo, expand;\n var init_expand = __esm({\n "web/lib/wasm/jsep/webgpu/ops/expand.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_common();\n validateInputs12 = (inputs) => {\n if (!inputs || inputs.length !== 2) {\n throw new Error("Expand requires 2 input.");\n }\n const inputShape = inputs[0].dims;\n const shape = Array.from(inputs[1].getBigInt64Array(), Number);\n let shapeIndex = shape.length < inputShape.length ? 0 : shape.length - inputShape.length;\n let inputShapeIndex = inputShape.length < shape.length ? 0 : inputShape.length - shape.length;\n for (; shapeIndex < shape.length && inputShapeIndex < inputShape.length; ++shapeIndex, ++inputShapeIndex) {\n if (shape[shapeIndex] !== inputShape[inputShapeIndex] && shape[shapeIndex] !== 1 && inputShape[inputShapeIndex] !== 1) {\n throw new Error("Expand requires shape to be broadcastable to input");\n }\n }\n };\n getAdjustedShape = (shape1, shape2) => {\n const diff = shape1.length - shape2.length;\n const shape = [];\n for (let i = 0; i < diff; ++i) {\n shape.push(shape1[i]);\n }\n for (let i = 0; i < shape2.length; ++i) {\n shape.push(shape2[i] === 1 ? shape1[i + diff] : shape2[i]);\n }\n return shape;\n };\n calculateOutputShape2 = (inputShape, shape) => inputShape.length > shape.length ? getAdjustedShape(inputShape, shape) : getAdjustedShape(shape, inputShape);\n createExpandProgramInfo = (inputs) => {\n const inputShape = inputs[0].dims;\n const shape = Array.from(inputs[1].getBigInt64Array(), Number);\n const outputShape = calculateOutputShape2(inputShape, shape);\n const dataType = inputs[0].dataType;\n const components = dataType === 9 /* bool */ ? 4 : 1;\n const outputSize = Math.ceil(ShapeUtil.size(outputShape) / components);\n const getShaderSource = (shaderHelper) => {\n const input = inputVariable("input", dataType, inputShape.length, components);\n const output = outputVariable("output", dataType, outputShape.length, components);\n let assignment;\n if (dataType === 9 /* bool */) {\n const singleAssignment = (resStr, x, typeCast = "") => `\n let outputIndices${x} = ${output.offsetToIndices(`outputOffset + ${x}u`)};\n let offset${x} = ${input.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n let index${x} = offset${x} / 4u;\n let component${x} = offset${x} % 4u;\n ${resStr}[${x}] = ${typeCast}(${input.getByOffset(`index${x}`)}[component${x}]);\n `;\n assignment = `\n let outputOffset = global_idx * ${components};\n var data = vec4(0);\n ${singleAssignment("data", 0, "u32")}\n ${singleAssignment("data", 1, "u32")}\n ${singleAssignment("data", 2, "u32")}\n ${singleAssignment("data", 3, "u32")}\n ${output.setByOffset("global_idx", "data")}\n }`;\n } else {\n assignment = `\n let outputIndices = ${output.offsetToIndices("global_idx")};\n let inputOffset = ${input.broadcastedIndicesToOffset("outputIndices", output)};\n ${output.setByOffset("global_idx", input.getByOffset("inputOffset"))}\n }`;\n }\n return `\n ${shaderHelper.registerUniform("vec_size", "u32").declareVariables(input, output)}\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.vec_size")}\n ${assignment}`;\n };\n const programUniforms = [{ type: 12 /* uint32 */, data: outputSize }, ...createTensorShapeVariables(inputShape, outputShape)];\n return {\n name: "Expand",\n shaderCache: { hint: `${outputShape.length}`, inputDependencies: ["rank"] },\n getShaderSource,\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms\n })\n };\n };\n expand = (context) => {\n validateInputs12(context.inputs);\n context.compute(createExpandProgramInfo(context.inputs), { inputs: [0] });\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/fast-gelu.ts\n var createFastGeluProgramInfo, fastGelu2;\n var init_fast_gelu = __esm({\n "web/lib/wasm/jsep/webgpu/ops/fast-gelu.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_common();\n init_unary_op();\n createFastGeluProgramInfo = (inputTensors) => {\n const dataType = inputTensors[0].dataType;\n const outputSize = ShapeUtil.size(inputTensors[0].dims);\n const biasLength = ShapeUtil.size(inputTensors[1].dims);\n const useVec4 = biasLength % 4 === 0;\n const getShaderSource = (shaderHelper) => {\n const x = inputVariable("x", dataType, [1], 4);\n const bias = inputVariable("bias", dataType, [1], 4);\n const y = outputVariable("y", dataType, [1], 4);\n const uniforms = [{ name: "output_vec_size", type: "u32" }, { name: "bias_size", type: "u32" }];\n const singleElementBias = (i) => `\n let bias${i}_offset: u32 = (global_idx * 4 + ${i}) % uniforms.bias_size;\n let bias${i} = ${bias.getByOffset(`bias${i}_offset / 4`)}[bias${i}_offset % 4];`;\n const biasGetExpression = useVec4 ? `\n let bias = ${bias.getByOffset("global_idx % (uniforms.bias_size / 4)")};` : `${singleElementBias(0)}${singleElementBias(1)}${singleElementBias(2)}${singleElementBias(3)}\n let bias = ${x.type.value}(bias0, bias1, bias2, bias3);`;\n return `${shaderHelper.registerUniforms(uniforms).declareVariables(x, bias, y)}\n\n ${fastGeluImpl(tensorTypeToWsglValueType(dataType))}\n\n ${shaderHelper.mainStart(WORKGROUP_SIZE)}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_vec_size")}\n\n let x = ${x.getByOffset("global_idx")};\n ${biasGetExpression}\n let x_in = x + bias;\n ${y.setByOffset("global_idx", fastGeluExpression("x_in"))}\n }`;\n };\n return {\n name: "FastGeluWithBias",\n shaderCache: { hint: `${useVec4}`, inputDependencies: ["type", "type"] },\n getShaderSource,\n getRunData: (inputs) => ({\n outputs: [{ dims: inputs[0].dims, dataType: inputs[0].dataType }],\n programUniforms: [{ type: 12 /* uint32 */, data: Math.ceil(outputSize / 4) }, { type: 12 /* uint32 */, data: biasLength }],\n dispatchGroup: { x: Math.ceil(outputSize / WORKGROUP_SIZE / 4) }\n })\n };\n };\n fastGelu2 = (context) => {\n if (context.inputs.length < 2 || ShapeUtil.size(context.inputs[1].dims) === 0) {\n fastGelu(context);\n } else {\n context.compute(createFastGeluProgramInfo(context.inputs));\n }\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/gather.ts\n var validateInputs13, createGatherProgramInfo, parseGatherAttributes, gather;\n var init_gather = __esm({\n "web/lib/wasm/jsep/webgpu/ops/gather.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_attribute_with_cache_key();\n init_common();\n validateInputs13 = (inputs) => {\n if (!inputs || inputs.length !== 2) {\n throw new Error("Gather requires 2 inputs.");\n }\n };\n createGatherProgramInfo = (inputs, attributes) => {\n const inputShape = inputs[0].dims;\n const indicesShape = inputs[1].dims;\n const inputRank = inputShape.length;\n const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank);\n const outputShape = inputShape.slice(0);\n outputShape.splice(axis, 1, ...indicesShape);\n const axisDimLimit = inputShape[axis];\n const components = inputs[0].dataType === 9 /* bool */ ? 4 : 1;\n const outputSize = Math.ceil(ShapeUtil.size(outputShape) / components);\n const programUniforms = [\n { type: 12 /* uint32 */, data: outputSize },\n { type: 6 /* int32 */, data: axisDimLimit },\n { type: 12 /* uint32 */, data: axis },\n ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims, outputShape)\n ];\n const getShaderSource = (shaderHelper) => {\n const data = inputVariable("data", inputs[0].dataType, inputs[0].dims.length, components);\n const indices = inputVariable("inputIndices", inputs[1].dataType, inputs[1].dims.length);\n const output = outputVariable("output", inputs[0].dataType, outputShape.length, components);\n const calcDataIndices = (x) => {\n const indicesRank = indicesShape.length;\n let calcStr = `var indicesIndices${x} = ${indices.type.indices}(0);`;\n for (let i = 0; i < indicesRank; i++) {\n calcStr += `${indicesRank > 1 ? `indicesIndices${x}[${i}]` : `indicesIndices${x}`} = ${outputShape.length > 1 ? `outputIndices${x}[uniforms.axis + ${i}]` : `outputIndices${x}`};`;\n }\n calcStr += `\n var idx${x} = ${indices.getByIndices(`indicesIndices${x}`)};\n if (idx${x} < 0) {\n idx${x} = idx${x} + uniforms.axisDimLimit;\n }\n var dataIndices${x} : ${data.type.indices};\n `;\n for (let i = 0, j = 0; i < inputRank; i++) {\n if (i === axis) {\n calcStr += `${inputRank > 1 ? `dataIndices${x}[${i}]` : `dataIndices${x}`} = u32(idx${x});`;\n j += indicesRank;\n } else {\n calcStr += `${inputRank > 1 ? `dataIndices${x}[${i}]` : `dataIndices${x}`} = ${outputShape.length > 1 ? `outputIndices${x}[${j}]` : `outputIndices${x}`};`;\n j++;\n }\n }\n return calcStr;\n };\n let assignment;\n if (inputs[0].dataType === 9 /* bool */) {\n const singleAssignment = (resStr, x, typeCast = "") => `\n let outputIndices${x} = ${output.offsetToIndices(`outputOffset + ${x}u`)};\n ${calcDataIndices(x)};\n let offset${x} = ${data.indicesToOffset(`dataIndices${x}`)};\n let index${x} = offset${x} / 4u;\n let component${x} = offset${x} % 4u;\n ${resStr}[${x}] = ${typeCast}(${data.getByOffset(`index${x}`)}[component${x}]);\n `;\n assignment = `\n let outputOffset = global_idx * ${components};\n var value = vec4(0);\n ${singleAssignment("value", 0, "u32")}\n ${singleAssignment("value", 1, "u32")}\n ${singleAssignment("value", 2, "u32")}\n ${singleAssignment("value", 3, "u32")}\n ${output.setByOffset("global_idx", "value")}\n `;\n } else {\n assignment = `\n let outputIndices = ${output.offsetToIndices("global_idx")};\n ${calcDataIndices("")};\n let value = ${data.getByIndices("dataIndices")};\n ${output.setByOffset("global_idx", "value")};\n `;\n }\n return `\n ${shaderHelper.registerUniform("outputSize", "u32").registerUniform("axisDimLimit", "i32").registerUniform("axis", "u32").declareVariables(data, indices, output)}\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}\n ${assignment}\n }`;\n };\n return {\n name: "Gather",\n shaderCache: { hint: attributes.cacheKey, inputDependencies: ["rank", "rank"] },\n getRunData: () => ({\n outputs: [\n { dims: outputShape, dataType: inputs[0].dataType }\n ],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms\n }),\n getShaderSource\n };\n };\n parseGatherAttributes = (attributes) => createAttributeWithCacheKey({ axis: attributes.axis });\n gather = (context, attributes) => {\n const inputs = context.inputs;\n validateInputs13(inputs);\n context.compute(createGatherProgramInfo(context.inputs, attributes));\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/gather-elements.ts\n var validateInputs14, createGatherElementsProgramInfo, parseGatherElementsAttributes, gatherElements;\n var init_gather_elements = __esm({\n "web/lib/wasm/jsep/webgpu/ops/gather-elements.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_attribute_with_cache_key();\n init_common();\n validateInputs14 = (inputs) => {\n if (!inputs || inputs.length !== 2) {\n throw new Error("GatherElements requires 2 inputs.");\n }\n if (inputs[0].dims.length < 1) {\n throw new Error("GatherElements requires that the data input be rank >= 1.");\n }\n if (inputs[0].dims.length !== inputs[1].dims.length) {\n throw new Error(`GatherElements requires that the data input and\n indices input tensors be of same rank.`);\n }\n };\n createGatherElementsProgramInfo = (inputs, attributes) => {\n const inputShape = inputs[0].dims;\n const inputOutputDataType = inputs[0].dataType;\n const inputRank = inputShape.length;\n const indicesShape = inputs[1].dims;\n const indicesDataType = inputs[1].dataType;\n const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank);\n const axisDimLimit = inputShape[axis];\n const outputShape = indicesShape.slice(0);\n const outputSize = ShapeUtil.size(outputShape);\n const input = inputVariable("input", inputOutputDataType, inputRank);\n const indices = inputVariable("indicesInput", indicesDataType, indicesShape.length);\n const output = outputVariable("output", inputOutputDataType, outputShape.length);\n const programUniforms = [\n { type: 12 /* uint32 */, data: outputSize },\n { type: 6 /* int32 */, data: axisDimLimit },\n { type: 12 /* uint32 */, data: axis }\n ];\n programUniforms.push(...createTensorShapeVariables(inputShape, indicesShape, outputShape));\n const inputDependencies = ["rank", "rank"];\n const getShaderSource = (shaderHelper) => `\n ${shaderHelper.registerUniform("outputSize", "u32").registerUniform("axisDimLimit", "i32").registerUniform("axis", "u32").declareVariables(input, indices, output)}\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}\n\n let outputIndices = ${output.offsetToIndices("global_idx")};\n\n var idx = ${indices.getByOffset("global_idx")};\n if (idx < 0) {\n idx = idx + uniforms.axisDimLimit;\n }\n var inputIndices = ${input.type.indices}(outputIndices);\n ${input.indicesSet("inputIndices", "uniforms.axis", "u32(idx)")};\n let value = ${input.getByIndices("inputIndices")};\n\n ${output.setByOffset("global_idx", "value")};\n }`;\n return {\n name: "GatherElements",\n shaderCache: { inputDependencies },\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms\n }),\n getShaderSource\n };\n };\n parseGatherElementsAttributes = (attributes) => createAttributeWithCacheKey({ axis: attributes.axis });\n gatherElements = (context, attributes) => {\n const inputs = context.inputs;\n validateInputs14(inputs);\n context.compute(createGatherElementsProgramInfo(context.inputs, attributes));\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/gemm.ts\n var validateInputs15, createGemmProgramInfo, parseGemmAttributes, gemm;\n var init_gemm = __esm({\n "web/lib/wasm/jsep/webgpu/ops/gemm.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_common();\n validateInputs15 = (inputs) => {\n if (!inputs) {\n throw new Error("Input is missing");\n }\n if (inputs.length < 2 || inputs.length > 3) {\n throw new Error("Invaid input number.");\n }\n if (inputs.length === 3 && inputs[2].dims.length > 2) {\n throw new Error("Invalid input shape of C");\n }\n if (inputs[0].dataType !== inputs[1].dataType || inputs.length === 3 && inputs[0].dataType !== inputs[2].dataType) {\n throw new Error("Input types are mismatched");\n }\n };\n createGemmProgramInfo = (inputs, attributes) => {\n const aShape = inputs[0].dims.slice();\n const bShape = inputs[1].dims.slice();\n const [M, N, K] = GemmUtil.getShapeOfGemmResult(\n aShape,\n attributes.transA,\n bShape,\n attributes.transB,\n inputs.length === 3 ? inputs[2].dims : void 0\n );\n const outputShape = [M, N];\n if (!outputShape) {\n throw new Error("Can\'t use gemm on the given tensors");\n }\n const outputSize = ShapeUtil.size(outputShape);\n const programUniforms = [\n { type: 12 /* uint32 */, data: outputSize },\n { type: 12 /* uint32 */, data: M },\n { type: 12 /* uint32 */, data: N },\n { type: 12 /* uint32 */, data: K },\n { type: 1 /* float */, data: attributes.alpha },\n { type: 1 /* float */, data: attributes.beta }\n ];\n const inputDependencies = ["type", "type"];\n if (inputs.length === 3) {\n programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n inputDependencies.push("rank");\n }\n programUniforms.push(...createTensorShapeVariables(outputShape));\n const getShaderSource = (shaderHelper) => {\n let line = "";\n if (attributes.transA && attributes.transB) {\n line = "value += a[k * uniforms.M + m] * b[n * uniforms.K + k];";\n } else if (attributes.transA && !attributes.transB) {\n line = "value += a[k * uniforms.M + m] * b[k * uniforms.N + n];";\n } else if (!attributes.transA && attributes.transB) {\n line = "value += a[m * uniforms.K + k] * b[n * uniforms.K + k];";\n } else if (!attributes.transA && !attributes.transB) {\n line = "value += a[m * uniforms.K + k] * b[k * uniforms.N + n];";\n }\n const calculateAlpha = attributes.alpha === 1 ? "" : "value *= uniforms.alpha;";\n const a = inputVariable("a", inputs[0].dataType, inputs[0].dims);\n const b = inputVariable("b", inputs[1].dataType, inputs[1].dims);\n const dataType = a.type.value;\n let c = null;\n const variables = [a, b];\n if (inputs.length === 3) {\n c = inputVariable("c", inputs[2].dataType, inputs[2].dims.length);\n variables.push(c);\n }\n const output = outputVariable("output", inputs[0].dataType, outputShape.length);\n variables.push(output);\n const uniforms = [\n { name: "output_size", type: "u32" },\n { name: "M", type: "u32" },\n { name: "N", type: "u32" },\n { name: "K", type: "u32" },\n { name: "alpha", type: "f32" },\n { name: "beta", type: "f32" }\n ];\n return `\n ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}\n\n let m = global_idx / uniforms.N;\n let n = global_idx % uniforms.N;\n\n var value = ${dataType}(0);\n for (var k: u32 = 0u; k < uniforms.K; k++) {\n ${line}\n }\n\n ${calculateAlpha}\n ${(() => {\n if (c != null) {\n return `let cOffset = ${c.broadcastedIndicesToOffset("vec2(m, n)", output)}; value += ${dataType}(uniforms.beta) * ${c.getByOffset("cOffset")};`;\n }\n return "";\n })()}\n output[global_idx] = value;\n }`;\n };\n return {\n name: "Gemm",\n shaderCache: { hint: `${attributes.cacheKey}`, inputDependencies },\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms\n }),\n getShaderSource\n };\n };\n parseGemmAttributes = (attributes) => {\n const transA = attributes.transA;\n const transB = attributes.transB;\n const alpha = attributes.alpha;\n const beta = attributes.beta;\n return { transA, transB, alpha, beta, cacheKey: `${attributes.transA};${attributes.transB};${attributes.alpha === 1}` };\n };\n gemm = (context, attributes) => {\n validateInputs15(context.inputs);\n context.compute(createGemmProgramInfo(context.inputs, attributes));\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/instance-norm.ts\n var createInstanceNormProgramInfo, computeMean, createInstanceNormNHWCProgramInfo, instanceNorm;\n var init_instance_norm = __esm({\n "web/lib/wasm/jsep/webgpu/ops/instance-norm.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_common();\n createInstanceNormProgramInfo = (inputs, attributes) => {\n const xShape = inputs[0].dims;\n const outputShape = xShape;\n const axis = 2;\n const normCount = ShapeUtil.sizeToDimension(xShape, axis);\n const normSize = ShapeUtil.sizeFromDimension(xShape, axis);\n const components = getMaxComponents(normSize);\n const normPackedSize = normSize / components;\n const inputShape = [xShape[0], xShape[1], normPackedSize];\n const inputDependencies = ["rank", "type", "type"];\n const programUniforms = [{ type: 12 /* uint32 */, data: normSize }, { type: 12 /* uint32 */, data: normPackedSize }];\n programUniforms.push(...createTensorShapeVariables(inputShape, inputShape));\n const getShaderSource = (shaderHelper) => {\n const x = inputVariable("x", inputs[0].dataType, inputShape.length, components);\n const scale = inputVariable("scale", inputs[1].dataType, inputs[1].dims);\n const bias = inputVariable("bias", inputs[2].dataType, inputs[2].dims);\n const output = outputVariable("output", inputs[0].dataType, inputShape.length, components);\n const variables = [x, scale, bias, output];\n const dataType = x.type.value;\n const f32Type = components === 1 ? "f32" : `vec${components}`;\n const workgroupSize = 64;\n const uniforms = [{ name: "normSize", type: "u32" }, { name: "normPackedSize", type: "u32" }];\n return `\n var meanShared : f32;\n var squaredNormShared : f32;\n var workgroupShared : array<${f32Type}, ${workgroupSize}>;\n const workgroupSize = ${workgroupSize}u;\n ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n ${shaderHelper.mainStart(workgroupSize)}\n let norm = global_idx / workgroupSize;\n let batch = norm / uniforms.x_shape[1];\n let channel = norm % uniforms.x_shape[1];\n let localIndex = local_id.x;\n\n // initialize workgroup memory\n var initial = ${f32Type}(0);\n for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) {\n initial = initial + ${f32Type}(${x.get("batch", "channel", "h")});\n }\n workgroupShared[localIndex] = initial;\n workgroupBarrier();\n\n // Calculate the mean of current channel data.\n for (var currSize = workgroupSize >> 1; currSize > 0; currSize = currSize >> 1) {\n if (localIndex < currSize) {\n workgroupShared[localIndex] = workgroupShared[localIndex] + workgroupShared[localIndex + currSize];\n }\n workgroupBarrier();\n }\n if (localIndex == 0) {\n meanShared = ${sumVector("workgroupShared[0]", components)} / f32(uniforms.normSize);\n }\n workgroupBarrier();\n\n // reinitialize workgroup memory.\n initial = ${f32Type}(0);\n for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) {\n let deviation = ${f32Type}(${x.get("batch", "channel", "h")}) - ${f32Type}(meanShared);\n initial = initial + deviation * deviation;\n }\n workgroupShared[localIndex] = initial;\n workgroupBarrier();\n\n // Calculate the sum of square of deviation of current channel data.\n for (var currSize = workgroupSize >> 1; currSize > 0; currSize = currSize >> 1) {\n if (localIndex < currSize) {\n workgroupShared[localIndex] = workgroupShared[localIndex] + workgroupShared[localIndex + currSize];\n }\n workgroupBarrier();\n }\n if (localIndex == 0) {\n squaredNormShared = ${sumVector("workgroupShared[0]", components)};\n }\n workgroupBarrier();\n\n let invStdDev = inverseSqrt(squaredNormShared / f32(uniforms.normSize) + f32(${attributes.epsilon}));\n let channelScale = invStdDev * f32(${scale.getByOffset("channel")});\n let channelShift = f32(${bias.getByOffset("channel")}) - meanShared * channelScale;\n for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) {\n let value = ${x.get("batch", "channel", "h")} * ${dataType}(${f32Type}(channelScale)) + ${dataType}(${f32Type}(channelShift));\n ${output.set("batch", "channel", "h", "value")};\n }\n }`;\n };\n return {\n ...{ name: "InstanceNormalization" },\n // TODO: use epsilon as uniform. Currently epsilon as uniform fails test_instancenorm_epsilon.\n shaderCache: { hint: `${attributes.epsilon};${components}`, inputDependencies },\n getRunData: () => ({\n outputs: [\n { dims: outputShape, dataType: inputs[0].dataType }\n ],\n dispatchGroup: { x: normCount },\n programUniforms\n }),\n getShaderSource\n };\n };\n computeMean = (context, input, scale, bias, n, h, c, epsilon) => {\n const components = getMaxComponents(c);\n const WG = 64;\n const outputType = components === 1 ? "vec2f" : `mat2x${components}f`;\n const sumCastType = components === 1 ? "f32" : `vec${components}f`;\n const setOutputValue = (var1, var2) => `${outputType}(${var1}, ${var2})`;\n const unitsOfWork = n * c / components;\n const wgSize = Math.ceil(h / WG);\n const meanInputDependencies = ["type"];\n const meanProgramUniforms = [\n { type: 12 /* uint32 */, data: wgSize },\n { type: 12 /* uint32 */, data: h },\n { type: 12 /* uint32 */, data: Math.floor(c / components) },\n { type: 12 /* uint32 */, data: Math.floor(h * c / components) }\n ];\n const getMeanShaderSource = (shaderHelper) => {\n const inputHelper = inputVariable("input", input.dataType, input.dims, components);\n return `\n ${shaderHelper.declareVariables(inputHelper)}\n @group(0) @binding(1) var output : array<${outputType}>;\n struct Uniforms {wg_size:u32, H:u32, C:u32, image_size:u32};\n @group(0) @binding(2) var uniforms: Uniforms;\n\n ${shaderHelper.mainStart(WG)}\n let currentImageNumber = global_idx / ${WG} / uniforms.C;\n let currentChannelNumber = (global_idx / ${WG}) % uniforms.C;\n let wgOffset = local_id.x * uniforms.wg_size;\n if (wgOffset >= uniforms.H) {\n return;\n }\n let wgMax = min(wgOffset + uniforms.wg_size, uniforms.H);\n\n let offset = currentImageNumber * uniforms.image_size + currentChannelNumber;\n var sum = ${fillVector("f32", components)};\n var squaredSum = ${fillVector("f32", components)};\n for (var i: u32 = wgOffset; i < wgMax; i++) {\n let value = ${sumCastType}(input[offset + i * uniforms.C]);\n sum += value;\n squaredSum += value * value;\n }\n output[global_idx] = ${setOutputValue("sum", "squaredSum")};\n }`;\n };\n const meanValues = context.compute(\n {\n name: "InstanceNormComputeMean",\n shaderCache: { hint: `${components}`, inputDependencies: meanInputDependencies },\n getRunData: () => ({\n outputs: [\n { dims: [n, c, WG, 2], dataType: 1 /* float */ }\n ],\n dispatchGroup: { x: n * c / components },\n programUniforms: meanProgramUniforms\n }),\n getShaderSource: getMeanShaderSource\n },\n { inputs: [input], outputs: [-1] }\n )[0];\n const programUniforms = [\n { type: 12 /* uint32 */, data: unitsOfWork },\n { type: 12 /* uint32 */, data: h },\n { type: 12 /* uint32 */, data: Math.floor(c / components) },\n { type: 12 /* uint32 */, data: Math.floor(WG * c / components) }\n ];\n const inputDependencies = ["type", "type", "type"];\n const getShaderSource = (shaderHelper) => {\n const scaleHelper = inputVariable("scale", scale.dataType, scale.dims, components);\n const biasHelper = inputVariable("bias", bias.dataType, bias.dims, components);\n return `\n @group(0) @binding(0) var input : array<${outputType}>;\n @group(0) @binding(1) var scale : array<${scaleHelper.type.storage}>;\n @group(0) @binding(2) var bias : array<${biasHelper.type.storage}>;\n @group(0) @binding(3) var output : array<${outputType}>;\n struct Uniforms {units_of_work : u32, H: u32, C : u32, image_size : u32};\n @group(0) @binding(4) var uniforms: Uniforms;\n\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.units_of_work")}\n let currentImageNumber = global_idx / uniforms.C;\n let currentChannelNumber = global_idx % uniforms.C;\n\n let offset = currentImageNumber * uniforms.image_size;\n var sum = ${fillVector("f32", components)};\n var squaredSum = ${fillVector("f32", components)};\n for (var i: u32 = 0; i < min(${WG}, uniforms.H); i++) {\n let value = input[offset + i + currentChannelNumber * ${WG}];\n sum += value[0];\n squaredSum += value[1];\n }\n sum = sum / f32(uniforms.H);\n squaredSum = squaredSum / f32(uniforms.H);\n let invStdDev = inverseSqrt(squaredSum - sum * sum + f32(${epsilon}));\n let channelScale = invStdDev * ${sumCastType}(scale[currentChannelNumber]);\n let channelShift = ${sumCastType}(bias[currentChannelNumber]) - sum * channelScale;\n\n output[global_idx] = ${setOutputValue("channelScale", "channelShift")};\n }`;\n };\n return context.compute(\n {\n name: "InstanceNormComputeChannelScaleShift",\n // TODO: use epsilon as uniform. Currently epsilon as uniform fails test_instancenorm_epsilon.\n shaderCache: { hint: `${components};${epsilon}`, inputDependencies },\n getRunData: () => ({\n outputs: [\n { dims: [n, c, 2], dataType: 1 /* float */ }\n ],\n dispatchGroup: { x: Math.ceil(\n unitsOfWork / 64\n /* workgroup size */\n ) },\n programUniforms\n }),\n getShaderSource\n },\n { inputs: [meanValues, scale, bias], outputs: [-1] }\n )[0];\n };\n createInstanceNormNHWCProgramInfo = (context, inputs, attributes) => {\n const xShape = inputs[0].dims;\n const outputShape = xShape;\n const N = xShape[0];\n const C = xShape[xShape.length - 1];\n const H = ShapeUtil.sizeFromDimension(xShape, 1) / C;\n const components = getMaxComponents(C);\n const outputSize = ShapeUtil.size(outputShape) / components;\n const programUniforms = [{ type: 12 /* uint32 */, data: H }, { type: 12 /* uint32 */, data: Math.floor(C / components) }];\n const inputDependencies = ["type", "type"];\n const channelScaleShift = computeMean(context, inputs[0], inputs[1], inputs[2], N, H, C, attributes.epsilon);\n const getShaderSource = (shaderHelper) => {\n const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n const scaleType = components === 1 ? "vec2f" : `mat2x${components}f`;\n const scaleCastType = components === 1 ? dataType : `vec${components}<${dataType}>`;\n const inputHelper = inputVariable("input", inputs[0].dataType, inputs[0].dims, components);\n const outputHelper = outputVariable("output", inputs[0].dataType, outputShape, components);\n return `\n @group(0) @binding(0) var input : array<${inputHelper.type.storage}>;\n @group(0) @binding(1) var scaleInput : array<${scaleType}>;\n @group(0) @binding(2) var output : array<${outputHelper.type.storage}>;\n struct Uniforms {H: u32, C : u32};\n @group(0) @binding(3) var uniforms: Uniforms;\n\n ${shaderHelper.mainStart()}\n let currentImageNumber = global_idx / (uniforms.C * uniforms.H);\n let currentChannelNumber = global_idx % uniforms.C;\n\n let scaleOffset = currentImageNumber * uniforms.C + currentChannelNumber;\n let scale = scaleInput[scaleOffset];\n output[global_idx] = fma(input[global_idx], ${scaleCastType}(scale[0]), ${scaleCastType}(scale[1]));\n }`;\n };\n context.compute(\n {\n name: "InstanceNormalizationNHWC",\n shaderCache: { hint: `${components}`, inputDependencies },\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms\n }),\n getShaderSource\n },\n { inputs: [inputs[0], channelScaleShift] }\n );\n };\n instanceNorm = (context, attributes) => {\n if (attributes.format === "NHWC") {\n createInstanceNormNHWCProgramInfo(context, context.inputs, attributes);\n } else {\n context.compute(createInstanceNormProgramInfo(context.inputs, attributes));\n }\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/layer-norm.ts\n var validateInputs16, createLayerNormProgramInfo, layerNorm;\n var init_layer_norm = __esm({\n "web/lib/wasm/jsep/webgpu/ops/layer-norm.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_common();\n validateInputs16 = (inputs) => {\n if (!inputs || inputs.length < 2) {\n throw new Error("layerNorm requires at least 2 inputs.");\n }\n };\n createLayerNormProgramInfo = (inputs, attributes, outputCount) => {\n const simplified = attributes.simplified;\n const xShape = inputs[0].dims;\n const scale = inputs[1];\n const bias = !simplified && inputs[2];\n const outputShape = xShape;\n const axis = ShapeUtil.normalizeAxis(attributes.axis, xShape.length);\n const normCount = ShapeUtil.sizeToDimension(xShape, axis);\n const normSize = ShapeUtil.sizeFromDimension(xShape, axis);\n const scaleSize = ShapeUtil.size(scale.dims);\n const biasSize = bias ? ShapeUtil.size(bias.dims) : 0;\n if (scaleSize !== normSize || bias && biasSize !== normSize) {\n throw new Error(`Size of X.shape()[axis:] == ${normSize}.\n Size of scale and bias (if provided) must match this.\n Got scale size of ${scaleSize} and bias size of ${biasSize}`);\n }\n const meanInvStdDevDim = [];\n for (let i = 0; i < xShape.length; ++i) {\n if (i < axis) {\n meanInvStdDevDim.push(xShape[i]);\n } else {\n meanInvStdDevDim.push(1);\n }\n }\n const components = getMaxComponents(normSize);\n const inputDependencies = ["type", "type"];\n const programUniforms = [\n { type: 12 /* uint32 */, data: normCount },\n { type: 1 /* float */, data: normSize },\n { type: 12 /* uint32 */, data: Math.floor(normSize / components) },\n { type: 1 /* float */, data: attributes.epsilon }\n ];\n if (bias) {\n inputDependencies.push("type");\n }\n const hasMeanDataOutput = outputCount > 1;\n const hasInvStdOutput = outputCount > 2;\n const getShaderSource = (shaderHelper) => {\n const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n const variables = [\n inputVariable("x", inputs[0].dataType, inputs[0].dims, components),\n inputVariable("scale", scale.dataType, scale.dims, components)\n ];\n if (bias) {\n variables.push(inputVariable("bias", bias.dataType, bias.dims, components));\n }\n variables.push(outputVariable("output", inputs[0].dataType, outputShape, components));\n if (hasMeanDataOutput) {\n variables.push(outputVariable("mean_data_output", 1 /* float */, meanInvStdDevDim));\n }\n if (hasInvStdOutput) {\n variables.push(outputVariable("inv_std_output", 1 /* float */, meanInvStdDevDim));\n }\n const uniforms = [\n { name: "norm_count", type: "u32" },\n { name: "norm_size", type: "f32" },\n { name: "norm_size_vectorized", type: "u32" },\n { name: "epsilon", type: "f32" }\n ];\n return `\n ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.norm_count")}\n let offset = global_idx * uniforms.norm_size_vectorized;\n var mean_vector = ${fillVector("f32", components)};\n var mean_square_vector = ${fillVector("f32", components)};\n\n for (var h: u32 = 0u; h < uniforms.norm_size_vectorized; h++) {\n let value = ${castToF32(dataType, components, "x[h + offset]")};\n mean_vector += value;\n mean_square_vector += value * value;\n }\n let mean = ${sumVector("mean_vector", components)} / uniforms.norm_size;\n let inv_std_dev = inverseSqrt(${sumVector("mean_square_vector", components)} / uniforms.norm_size ${simplified ? "" : "- mean * mean"} + uniforms.epsilon);\n\n for (var j: u32 = 0; j < uniforms.norm_size_vectorized; j++) {\n let f32input = ${castToF32(dataType, components, "x[j + offset]")};\n let f32scale = ${castToF32(dataType, components, "scale[j]")};\n output[j + offset] = ${variables[0].type.value}((f32input ${simplified ? "" : "- mean"}) * inv_std_dev * f32scale\n ${bias ? `+ ${castToF32(dataType, components, "bias[j]")}` : ""}\n );\n }\n\n ${hasMeanDataOutput ? "mean_data_output[global_idx] = mean" : ""};\n ${hasInvStdOutput ? "inv_std_output[global_idx] = inv_std_dev" : ""};\n }`;\n };\n const outputs = [{ dims: outputShape, dataType: inputs[0].dataType }];\n if (hasMeanDataOutput) {\n outputs.push({ dims: meanInvStdDevDim, dataType: 1 /* float */ });\n }\n if (hasInvStdOutput) {\n outputs.push({ dims: meanInvStdDevDim, dataType: 1 /* float */ });\n }\n return {\n name: "LayerNormalization",\n shaderCache: { hint: `${components};${outputCount};${simplified}`, inputDependencies },\n getRunData: () => ({ outputs, dispatchGroup: { x: Math.ceil(\n normCount / 64\n /* workgroup size */\n ) }, programUniforms }),\n getShaderSource\n };\n };\n layerNorm = (context, attributes) => {\n validateInputs16(context.inputs);\n context.compute(createLayerNormProgramInfo(context.inputs, attributes, context.outputCount));\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/matmulnbits.ts\n var validateInputs17, createMatMulNBitsProgramInfo, matMulNBits, parseMatMulNBitsAttributes;\n var init_matmulnbits = __esm({\n "web/lib/wasm/jsep/webgpu/ops/matmulnbits.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_attribute_with_cache_key();\n init_common();\n validateInputs17 = (inputs, attributes) => {\n if (inputs.length < 3 || inputs.length > 4) {\n throw new Error("MatMulNBits requires 3 or 4 inputs");\n }\n const a = inputs[0];\n const aRank = a.dims.length;\n if (a.dims[aRank - 1] !== attributes.k) {\n throw new Error("The last dim of input shape does not match the k value");\n }\n const nBlocksPerCol = Math.floor((attributes.k + attributes.blockSize - 1) / attributes.blockSize);\n const blobSize = attributes.blockSize / 8 * attributes.bits;\n const b = inputs[1];\n if (!ShapeUtil.areEqual(b.dims, [attributes.n, nBlocksPerCol, blobSize])) {\n throw new Error("The second inputs must be 3D tensor with shape N X nBlocksPerCol X blobSize");\n }\n const scales = inputs[2];\n const scalesShape = scales.dims;\n if (ShapeUtil.size(scalesShape) !== attributes.n * nBlocksPerCol) {\n throw new Error("scales input size error.");\n }\n if (inputs.length === 4) {\n const zeroPoints = inputs[3];\n const zeroPointsShape = zeroPoints.dims;\n const expectedZeroPointsSize = attributes.bits > 4 ? attributes.n * nBlocksPerCol : attributes.n * Math.floor((nBlocksPerCol + 1) / 2);\n if (ShapeUtil.size(zeroPointsShape) !== expectedZeroPointsSize) {\n throw new Error("zeroPoints input size error.");\n }\n }\n };\n createMatMulNBitsProgramInfo = (inputs, attributes, maxComputeWorkgroupSizes, maxComputeWorkgroupStorageSize) => {\n const inputShape = inputs[0].dims;\n const aRank = inputShape.length;\n const nBlocksPerCol = Math.floor((attributes.k + attributes.blockSize - 1) / attributes.blockSize);\n const dimAOuter = inputShape[aRank - 2];\n const dimInner = attributes.k;\n const dimBOuter = attributes.n;\n const batchDims = inputShape.slice(0, aRank - 2);\n const batchSize = ShapeUtil.size(batchDims);\n const blobSize = attributes.blockSize / 8 * attributes.bits;\n const blobSizeInWords = blobSize / 4;\n const dataType = inputs[0].dataType;\n const outputNumber = getMaxComponents(dimAOuter);\n const aComponents = getMaxComponents(attributes.k);\n const bComponents = getMaxComponents(blobSizeInWords);\n const elementSize = getTensorElementSize(dataType);\n const workgroupOutputSize = dimAOuter * nBlocksPerCol * elementSize;\n const maxNumberOfComponents = Math.floor(maxComputeWorkgroupStorageSize / workgroupOutputSize);\n const useBlockwiseMatMulNBits = nBlocksPerCol <= maxComputeWorkgroupSizes[0] && maxNumberOfComponents > 0;\n const components = !useBlockwiseMatMulNBits || maxNumberOfComponents >= 4 ? getMaxComponents(dimBOuter) : maxNumberOfComponents >= 2 && getMaxComponents(dimBOuter) >= 2 ? 2 : 1;\n const outputShape = batchDims.concat([dimAOuter, dimBOuter]);\n const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;\n const programUniforms = useBlockwiseMatMulNBits ? [] : [{ type: 12 /* uint32 */, data: outputSize }, { type: 12 /* uint32 */, data: attributes.blockSize }];\n const inputShapeTemp = [batchSize, dimAOuter, dimInner / aComponents];\n const bShape = ShapeUtil.convertShape(inputs[1].dims).slice();\n bShape.splice(-1, 1, blobSizeInWords / bComponents);\n programUniforms.push(...createTensorShapeVariables(inputShapeTemp));\n programUniforms.push(...createTensorShapeVariables(bShape));\n programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n if (inputs.length === 4) {\n programUniforms.push(...createTensorShapeVariables(ShapeUtil.convertShape(inputs[3].dims)));\n }\n const outputShapeTemp = [batchSize, dimAOuter, dimBOuter / components];\n programUniforms.push(...createTensorShapeVariables(outputShapeTemp));\n const getShaderSource = (shaderHelper) => {\n const inputRank = inputShapeTemp.length;\n const a = inputVariable("a", inputs[0].dataType, inputRank, aComponents);\n const b = inputVariable("b", 12 /* uint32 */, bShape.length, bComponents);\n const scales = inputVariable("scales", inputs[2].dataType, inputs[2].dims.length);\n const inputVariables = [a, b, scales];\n const zeroPoints = inputs.length === 4 ? inputVariable("zero_points", 12 /* uint32 */, inputs[3].dims.length) : void 0;\n if (zeroPoints) {\n inputVariables.push(zeroPoints);\n }\n const outputRank = outputShapeTemp.length;\n const output = outputVariable("output", inputs[0].dataType, outputRank, components);\n const uniforms = [{ name: "output_size", type: "u32" }, { name: "block_size", type: "u32" }];\n const dataType2 = tensorTypeToWsglStorageType(inputs[0].dataType);\n const qDqDataType = (() => {\n switch (aComponents) {\n case 1:\n return `array<${dataType2}, 8>`;\n case 2:\n return `mat4x2<${dataType2}>`;\n case 4:\n return `mat2x4<${dataType2}>`;\n default:\n throw new Error(`${aComponents}-component is not supported.`);\n }\n })();\n const processOneBlock = `\n for (var word: u32 = 0; word < ${blobSizeInWords}; word += ${bComponents}) {\n ${b.indicesSet("b_indices", "2", "word")};\n let b_data = ${b.getByIndices("b_indices")};\n for (var i: u32 = 0; i < ${bComponents}; i++) {\n let b_value: u32 = ${bComponents === 1 ? "b_data" : "b_data[word + i]"};\n let b_mask: u32 = 0x0F0F0F0Fu;\n let b_value_lower: vec4 = unpack4xU8(b_value & b_mask);\n let b_value_upper: vec4 = unpack4xU8((b_value >> 4) & b_mask);\n let b_quantized_values = ${qDqDataType}(${Array.from({ length: 4 }, (_, i) => `${dataType2}(b_value_lower[${i}]), ${dataType2}(b_value_upper[${i}])`).join(", ")});\n let b_dequantized_values = ${(() => {\n if (aComponents === 1) {\n return `${qDqDataType}(${Array.from({ length: 8 }, (_, i) => `(b_quantized_values[${i}] - zero_point) * scale`).join(", ")});`;\n } else {\n return `(b_quantized_values - ${qDqDataType}(${Array(8).fill("zero_point").join(",")})) * scale;`;\n }\n })()};\n // Number of B elements per 32-bit word is 32/bits = 32/4 = 8\n for (var m: u32 = 0; m < ${useBlockwiseMatMulNBits ? dimAOuter : outputNumber}u; m++) {\n ${a.indicesSet("a_indices", inputRank - 2, useBlockwiseMatMulNBits ? "m" : `row * ${outputNumber} + m`)};\n ${a.indicesSet("a_indices", inputRank - 1, "word_offset")};\n var input_offset = ${a.indicesToOffset("a_indices")};\n var a_data: ${qDqDataType};\n for (var j: u32 = 0; j < ${8 / aComponents}; j++) {\n a_data[j] = ${a.getByOffset("input_offset")};\n input_offset++;\n }\n ${useBlockwiseMatMulNBits ? "workgroup_shared[workgroup_shared_offset + m]" : "output_values[m]"}${components > 1 ? "[c]" : ""} += ${Array.from(\n { length: 8 / aComponents },\n (_, i) => `${aComponents === 1 ? `a_data[${i}] * b_dequantized_values[${i}]` : `dot(a_data[${i}], b_dequantized_values[${i}])`}`\n ).join(" + ")};\n }\n word_offset += ${8 / aComponents};\n }\n }`;\n const updateZeroPointIndex = zeroPoints ? `\n zero_point_offset += 4;\n if (zero_point_offset == 32) {\n zero_point_offset = 0;\n zero_point_index++;\n zero_point_word = ${zeroPoints.getByOffset("zero_point_index")};\n }` : "";\n return useBlockwiseMatMulNBits ? `\n var workgroup_shared: array<${output.type.value}, ${dimAOuter * nBlocksPerCol}>;\n ${shaderHelper.declareVariables(...inputVariables, output)}\n ${shaderHelper.mainStart([\n nBlocksPerCol,\n 1,\n 1\n ])}\n var a_indices: ${a.type.indices};\n var block = local_id.x;\n var col = workgroup_id.y;\n var batch = workgroup_id.z;\n ${a.indicesSet("a_indices", "0", "batch")};\n // Two zero points are packed into one byte when uniforms.bits is 4.\n for (var c: u32 = 0; c < ${components}; c++) {\n let col_times_components_plus_c = col * ${components} + c;\n ${zeroPoints ? `\n var zero_point_bytes_per_col: u32 = (${nBlocksPerCol} + 1) / 2;\n var zero_point_byte_count: u32 = col_times_components_plus_c * zero_point_bytes_per_col + (block >> 0x1u);\n var zero_point_word_index: u32 = zero_point_byte_count >> 0x2u;\n var zero_point_byte_offset: u32 = zero_point_byte_count & 0x3u;\n var zero_point_nibble_offset: u32 = block & 0x1u;\n var zero_point_bits_offset: u32 = (zero_point_byte_offset << 3) + (zero_point_nibble_offset << 2);\n var zero_point_word: u32 = ${zeroPoints.getByOffset("zero_point_word_index")} >> zero_point_bits_offset;` : ""}\n var b_indices: ${b.type.indices};\n ${b.indicesSet("b_indices", "0", "col_times_components_plus_c")};\n // The scale and zero points are computed per block.\n var scales_index = col_times_components_plus_c * ${nBlocksPerCol} + block;\n let scale = ${scales.getByOffset("scales_index")};\n // The default zero point is 8 for unsigned 4-bit quantization.\n let zero_point = ${dataType2}(${zeroPoints ? "(zero_point_word) & 0xFu" : 8});\n ${b.indicesSet("b_indices", "1", "block")};\n var word_offset: u32 = block * ${attributes.blockSize / aComponents};\n var workgroup_shared_offset: u32 = block * ${dimAOuter};\n ${processOneBlock}\n }\n workgroupBarrier();\n if (local_id.x == 0u) {\n var output_indices: ${output.type.indices};\n ${output.indicesSet("output_indices", "0", "batch")};\n ${output.indicesSet("output_indices", outputRank - 1, "col")};\n ${output.indicesSet("output_indices", outputRank - 2, "0")};\n var output_offset = ${output.indicesToOffset("output_indices")};\n for (var m: u32 = 0u; m < ${dimAOuter}u; m++) {\n var output_value: ${output.type.value} = ${output.type.value}(0);\n var workgroup_shared_offset: u32 = m;\n for (var b: u32 = 0u; b < ${nBlocksPerCol}u; b++) {\n output_value += workgroup_shared[workgroup_shared_offset];\n workgroup_shared_offset += ${dimAOuter};\n }\n ${output.setByOffset("output_offset", "output_value")};\n output_offset += ${dimBOuter / components};\n }\n }\n }` : `\n ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}\n var output_values: array<${output.type.value}, ${outputNumber}>;\n var output_indices = ${output.offsetToIndices("global_idx")};\n var col = ${output.indicesGet("output_indices", outputRank - 1)};\n var row = ${output.indicesGet("output_indices", outputRank - 2)};\n var a_indices: ${a.type.indices} = output_indices;\n // Two zero points are packed into one byte because uniforms.bits <= 4.\n // zero_point_offset is either 0 or 4. It is bit offset within one byte.\n // TODO support zero_point_offset for bits > 4\n ${zeroPoints ? `\n var zero_point_abs_offset = col * ${components} * ((${nBlocksPerCol} + 1) / 2);\n var zero_point_index: u32 = zero_point_abs_offset / 4;\n var zero_point_word: u32 = ${zeroPoints.getByOffset("zero_point_index")};\n var zero_point_offset: u32 = (zero_point_abs_offset % 4) * 8;` : ""}\n var scale_index = col * ${nBlocksPerCol * components};\n var b_indices: ${b.type.indices};\n for (var c: u32 = 0; c < ${components}; c++) {\n ${b.indicesSet("b_indices", "0", `col * ${components} + c`)};\n var block_offset: u32 = 0;\n for (var block: u32 = 0; block < ${nBlocksPerCol}; block++) {\n // The scale and zero points are computed per block.\n let scale = ${scales.getByOffset("scale_index")};\n // The default zero point is 8 for unsigned 4-bit quantization.\n let zero_point = ${dataType2}(${zeroPoints ? "extractBits(zero_point_word, zero_point_offset, 4)" : 8});\n ${b.indicesSet("b_indices", "1", "block")};\n var word_offset: u32 = block_offset;\n ${processOneBlock}\n scale_index++;\n ${updateZeroPointIndex}\n block_offset += uniforms.block_size / ${aComponents};\n }\n // Drop the trailing 4 bits if the zero_poit_offset is not a byte boundary to align with the next byte.\n ${zeroPoints ? `if (zero_point_offset % 8 > 0) {\n ${updateZeroPointIndex}\n }` : ""}\n }\n for (var k: u32 = 0u; k < ${outputNumber}u; k++) {\n ${output.indicesSet("output_indices", outputRank - 2, `${outputNumber} * row + k`)};\n ${output.setByIndices("output_indices", "output_values[k]")}\n }\n }`;\n };\n return {\n name: useBlockwiseMatMulNBits ? "BlockwiseMatMulNBits" : "MatMulNBits",\n shaderCache: {\n hint: `${attributes.cacheKey};${dimAOuter};${dataType};${inputs.length}`,\n inputDependencies: Array(inputs.length).fill("rank")\n },\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType }],\n name: useBlockwiseMatMulNBits ? "BlockwiseMatMulNBits" : "MatMulNBits",\n dispatchGroup: useBlockwiseMatMulNBits ? { x: 1, y: Math.ceil(dimBOuter / components), z: batchSize } : { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms\n }),\n getShaderSource\n };\n };\n matMulNBits = (context, attributes) => {\n validateInputs17(context.inputs, attributes);\n const maxComputeWorkgroupSizes = context.getMaxComputeWorkgroupSizes();\n const maxComputeWorkgroupStorageSize = context.getMaxComputeWorkgroupStoragesize();\n context.compute(createMatMulNBitsProgramInfo(\n context.inputs,\n attributes,\n maxComputeWorkgroupSizes,\n maxComputeWorkgroupStorageSize\n ));\n };\n parseMatMulNBitsAttributes = (attributes) => createAttributeWithCacheKey(attributes);\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/multihead-attentiion.ts\n var getInput, validateInputs18, parseMultiHeadAttentionAttributes, weightTransposeAttribute2, addBiasTranspose, maybeTransposeToBNSHAndAddBias, multiHeadAttention;\n var init_multihead_attentiion = __esm({\n "web/lib/wasm/jsep/webgpu/ops/multihead-attentiion.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_attribute_with_cache_key();\n init_types();\n init_attention();\n init_common();\n init_transpose();\n getInput = (inputs, i) => inputs.length > i && inputs[i].dims.length > 0 && ShapeUtil.size(inputs[i].dims) > 0 ? inputs[i] : void 0;\n validateInputs18 = (inputs, attributes) => {\n const query = inputs[0];\n const key = getInput(inputs, 1);\n const value = getInput(inputs, 2);\n const bias = getInput(inputs, 3);\n const keyPaddingMask = getInput(inputs, 4);\n const relativePositionBias = getInput(inputs, 5);\n const pastKey = getInput(inputs, 6);\n const pastValue = getInput(inputs, 7);\n if (query.dims.length !== 3 && query.dims.length !== 5) {\n throw new Error("Input query is expected to have 3 or 5 dimensions");\n }\n const dmmhaPacking = false;\n const batchSize = query.dims[0];\n const sequenceLength = query.dims[1];\n const hiddenSize = query.dims.length === 3 ? dmmhaPacking ? query.dims[2] / 3 : query.dims[2] : attributes.numHeads * query.dims[4];\n let kvSequenceLength = sequenceLength;\n let pastSequenceLength = 0;\n let maxSequenceLength = 0;\n const headSize = Math.floor(hiddenSize / attributes.numHeads);\n if (pastKey && pastValue) {\n if (pastKey.dims.length !== 4) {\n throw new Error(\'Input "past_key" is expected to have 4 dimensions\');\n }\n if (pastKey.dims[0] !== batchSize || pastKey.dims[1] !== attributes.numHeads || pastKey.dims[3] !== headSize) {\n throw new Error(\'Input "past_key" shape (batch_size, num_heads, past_sequence_length, head_size)\');\n }\n if (pastValue.dims[0] !== batchSize || pastValue.dims[1] !== attributes.numHeads || pastValue.dims[3] !== headSize) {\n throw new Error(\'Input "past_value" shape (batch_size, num_heads, past_sequence_length, head_size)\');\n }\n if (pastKey.dims[2] !== pastValue.dims[2]) {\n throw new Error(\'Input "past_key" and "past_value" shall have same dim 2 (past_sequence_length)\');\n }\n if (pastValue.dims.length !== 4) {\n throw new Error(\'Input "past_value" is expected to have 4 dimensions\');\n }\n pastSequenceLength = pastKey.dims[2];\n maxSequenceLength = pastKey.dims[2];\n } else if (pastKey || pastValue) {\n throw new Error(\'Input "past_key" and "past_value" shall be both present or both absent\');\n }\n let qkvFormat;\n if (key) {\n if (query.dims.length !== 3) {\n throw new Error(\'Input "query" is expected to have 3 dimensions when key is given\');\n }\n if (key.dims.length < 3 || key.dims.length > 5) {\n throw new Error(\'Input "key" is expected to have 3, 4, or 5 dimensions\');\n }\n if (query.dims[0] !== key.dims[0]) {\n throw new Error(\'Input "query" and "key" shall have same dim 0 (batch size)\');\n }\n if (key.dims.length === 3) {\n if (key.dims[2] !== query.dims[2]) {\n throw new Error(\'Input "query" and "key" shall have same dim 2 (hidden_size)\');\n }\n qkvFormat = 2 /* qkvBSNH */;\n kvSequenceLength = key.dims[1];\n } else if (key.dims.length === 5) {\n if (key.dims[2] !== attributes.numHeads || key.dims[3] !== 2 || key.dims[4] !== headSize) {\n throw new Error(\'Expect "key" shape (batch_size, kv_sequence_length, num_heads, 2, head_size) for packed kv\');\n }\n if (value) {\n throw new Error(\'Expect "value" be none when "key" has packed kv format.\');\n }\n qkvFormat = 5 /* qKvBSNHxBSN2H */;\n kvSequenceLength = key.dims[1];\n } else {\n if (key.dims[1] !== attributes.numHeads || key.dims[3] !== headSize) {\n throw new Error(\'Expect "key" shape (batch_size, num_heads, kv_sequence_length, head_size) for past_key\');\n }\n qkvFormat = 0 /* unknown */;\n kvSequenceLength = key.dims[2];\n }\n } else {\n if (query.dims.length !== 3 && query.dims.length !== 5) {\n throw new Error(\'Input "query" is expected to have 3 or 5 dimensions when key is empty\');\n }\n if (query.dims.length === 5 && (query.dims[2] !== attributes.numHeads || query.dims[3] !== 3)) {\n throw new Error(\'Expect "query" shape (batch_size, kv_sequence_length, num_heads, 3, head_size) for packed kv\');\n }\n qkvFormat = 3 /* qkvBSN3H */;\n }\n if (bias) {\n if (bias.dims.length !== 1) {\n throw new Error(\'Input "bias" is expected to have 1 dimension\');\n }\n if (value) {\n if (query.dims.length === 5 && query.dims[3] === 2) {\n throw new Error("bias is not allowed for packed kv.");\n }\n }\n }\n let maskType = 0 /* none */;\n if (keyPaddingMask) {\n maskType = 8 /* maskUnknown */;\n const maskDims = keyPaddingMask.dims;\n if (maskDims.length === 1) {\n if (maskDims[0] === batchSize) {\n maskType = 1 /* mask1dKeySeqLen */;\n } else if (maskDims[0] === 3 * batchSize + 2) {\n maskType = 3 /* mask1DKeySeqLenStart */;\n }\n } else if (maskDims.length === 2 && maskDims[0] === batchSize && maskDims[1] === kvSequenceLength) {\n maskType = 5 /* mask2dKeyPadding */;\n }\n if (maskType === 8 /* maskUnknown */) {\n throw new Error(\'Input "key_padding_mask" shape shall be (batch_size) or (batch_size, kv_sequence_length)\');\n }\n throw new Error("Mask not supported");\n }\n let passPastInKv = false;\n let vHiddenSize = hiddenSize;\n if (value) {\n if (value.dims.length !== 3 && value.dims.length !== 4) {\n throw new Error(\'Input "value" is expected to have 3 or 4 dimensions\');\n }\n if (query.dims[0] !== value.dims[0]) {\n throw new Error(\'Input "query" and "value" shall have same dim 0 (batch_size)\');\n }\n if (value.dims.length === 3) {\n if (kvSequenceLength !== value.dims[1]) {\n throw new Error(\'Input "key" and "value" shall have the same dim 1 (kv_sequence_length)\');\n }\n vHiddenSize = value.dims[2];\n } else {\n if (kvSequenceLength !== value.dims[2]) {\n throw new Error(\'Input "past_key" and "past_value" shall have the same dim 2 (kv_sequence_length)\');\n }\n vHiddenSize = value.dims[1] * value.dims[3];\n passPastInKv = true;\n }\n }\n const totalSequenceLength = pastSequenceLength + kvSequenceLength;\n const broadcastResPosBias = false;\n if (keyPaddingMask) {\n throw new Error("Key padding mask is not supported");\n }\n if (relativePositionBias) {\n if (relativePositionBias.dims.length !== 4) {\n throw new Error(\'Input "relative_position_bias" is expected to have 4 dimensions\');\n }\n if (relativePositionBias.dims[0] !== batchSize && relativePositionBias.dims[0] !== 1 || relativePositionBias.dims[1] !== attributes.numHeads || relativePositionBias.dims[2] !== sequenceLength || relativePositionBias.dims[3] !== totalSequenceLength) {\n throw new Error(\'Input "relative_position_bias" shape (batch_size, 1, sequence_length, kv_sequence_length)\');\n }\n }\n return {\n batchSize,\n sequenceLength,\n pastSequenceLength,\n kvSequenceLength,\n totalSequenceLength,\n maxSequenceLength,\n inputHiddenSize: 0,\n hiddenSize,\n vHiddenSize,\n headSize,\n vHeadSize: Math.floor(vHiddenSize / attributes.numHeads),\n numHeads: attributes.numHeads,\n isUnidirectional: false,\n pastPresentShareBuffer: false,\n maskFilterValue: attributes.maskFilterValue,\n maskType,\n scale: attributes.scale,\n broadcastResPosBias,\n passPastInKv,\n qkvFormat\n };\n };\n parseMultiHeadAttentionAttributes = (attributes) => createAttributeWithCacheKey({ ...attributes });\n weightTransposeAttribute2 = createAttributeWithCacheKey({ perm: [0, 2, 1, 3] });\n addBiasTranspose = (context, qkv, bias, batchSize, sequenceLength, hiddenSize, biasOffset) => {\n const outputShape = [batchSize, sequenceLength, hiddenSize];\n const outputSize = ShapeUtil.size(outputShape);\n const programUniforms = [\n { type: 12 /* uint32 */, data: outputSize },\n { type: 12 /* uint32 */, data: biasOffset },\n { type: 12 /* uint32 */, data: hiddenSize }\n ];\n const getShaderSource = (shaderHelper) => {\n const output = outputVariable("qkv_with_bias", qkv.dataType, outputShape);\n const qkvInput = inputVariable("qkv", qkv.dataType, outputShape);\n const biasInput = inputVariable("bias", bias.dataType, outputShape);\n const uniforms = [\n { name: "output_size", type: "u32" },\n { name: "bias_offset", type: "u32" },\n { name: "hidden_size", type: "u32" }\n ];\n return `\n ${shaderHelper.registerUniforms(uniforms).declareVariables(qkvInput, biasInput, output)}\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}\n let bias_offset_idx = (global_idx % uniforms.hidden_size) + uniforms.bias_offset;\n\n qkv_with_bias[global_idx] = qkv[global_idx] + bias[bias_offset_idx];\n }`;\n };\n return context.compute(\n {\n name: "MultiHeadAttentionAddBias",\n shaderCache: { inputDependencies: ["type", "type"] },\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: qkv.dataType, gpuDataType: 0 /* default */ }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms\n }),\n getShaderSource\n },\n { inputs: [qkv, bias], outputs: [-1] }\n )[0];\n };\n maybeTransposeToBNSHAndAddBias = (context, batchSize, numHeads, sequenceLength, headSize, input, bias, biasOffset) => {\n let reshapedInput = input;\n if (!bias) {\n if (input.dims.length === 3) {\n reshapedInput = input.reshape([batchSize, sequenceLength, numHeads, headSize]);\n }\n return context.compute(\n createTransposeProgramInfo(reshapedInput, weightTransposeAttribute2.perm),\n { inputs: [reshapedInput], outputs: [-1] }\n )[0];\n } else {\n if (sequenceLength === 1) {\n throw new Error("AddBiasReshape is not implemented. Please export your model with packed QKV or KV");\n } else {\n reshapedInput = addBiasTranspose(context, input, bias, batchSize, sequenceLength, numHeads * headSize, biasOffset);\n reshapedInput = reshapedInput.reshape([batchSize, sequenceLength, numHeads, headSize]);\n return context.compute(\n createTransposeProgramInfo(reshapedInput, weightTransposeAttribute2.perm),\n { inputs: [reshapedInput], outputs: [-1] }\n )[0];\n }\n }\n };\n multiHeadAttention = (context, attributes) => {\n const params = validateInputs18(context.inputs, attributes);\n const query = context.inputs[0];\n const key = getInput(context.inputs, 1);\n const value = getInput(context.inputs, 2);\n const bias = getInput(context.inputs, 3);\n const keyPaddingMask = getInput(context.inputs, 4);\n const relativePositionBias = getInput(context.inputs, 5);\n const pastKey = getInput(context.inputs, 6);\n const pastValue = getInput(context.inputs, 7);\n if (query.dims.length === 5) {\n throw new Error("Packed QKV is not implemented");\n }\n if (key?.dims.length === 5) {\n throw new Error("Packed KV is not implemented");\n }\n const kvBNSH = key && value && key.dims.length === 4 && value.dims.length === 4;\n const Q = maybeTransposeToBNSHAndAddBias(\n context,\n params.batchSize,\n params.numHeads,\n params.sequenceLength,\n params.headSize,\n query,\n bias,\n 0\n );\n if (kvBNSH) {\n return applyAttention(\n context,\n Q,\n key,\n value,\n keyPaddingMask,\n void 0,\n pastKey,\n pastValue,\n relativePositionBias,\n params,\n attributes\n );\n }\n if (!key || !value) {\n throw new Error("key and value must be provided");\n }\n const K = maybeTransposeToBNSHAndAddBias(\n context,\n params.batchSize,\n params.numHeads,\n params.kvSequenceLength,\n params.headSize,\n key,\n bias,\n params.hiddenSize\n );\n const V = maybeTransposeToBNSHAndAddBias(\n context,\n params.batchSize,\n params.numHeads,\n params.kvSequenceLength,\n params.vHeadSize,\n value,\n bias,\n 2 * params.hiddenSize\n );\n applyAttention(\n context,\n Q,\n K,\n V,\n keyPaddingMask,\n void 0,\n pastKey,\n pastValue,\n relativePositionBias,\n params,\n attributes\n );\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/pad.ts\n var validateInputs19, getPadConstant, getPadReflect, getPadEdge, getPadWrap, getPadSnippet, createPadProgramInfo, createPadAttributesFromInputs, pad;\n var init_pad = __esm({\n "web/lib/wasm/jsep/webgpu/ops/pad.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_common();\n validateInputs19 = (inputs) => {\n if (!inputs || inputs.length < 1) {\n throw new Error("Too few inputs");\n }\n if (inputs[0].dataType !== 1 /* float */ && inputs[0].dataType !== 10 /* float16 */) {\n throw new Error("Input type must be float or float16.");\n }\n if (inputs.length >= 2) {\n let validPads = inputs[0].dims.length * 2 === inputs[1].dims[0];\n if (inputs.length === 4) {\n validPads = inputs[3].dims[0] * 2 === inputs[1].dims[0];\n }\n if (!validPads) {\n throw new Error("The pads should be a 1D tensor of shape [2 * input_rank] or [2 * num_axes].");\n }\n }\n };\n getPadConstant = (output, inputRank, padsLength) => {\n let block = "";\n for (let i = inputRank - 1; i >= 0; --i) {\n block += `\n k = i32(${output.indicesGet("indices", i)}) - ${getElementAt("uniforms.pads", i, padsLength)};\n if (k < 0) {\n break;\n }\n if (k >= i32(${getElementAt("uniforms.x_shape", i, inputRank)})) {\n break;\n }\n offset += k * i32(${getElementAt("uniforms.x_strides", i, inputRank)});\n `;\n }\n return `\n value = ${output.type.value}(uniforms.constant_value);\n for (var i = 0; i < 1; i++) {\n var offset = 0;\n var k = 0;\n ${block}\n value = x[offset];\n }\n `;\n };\n getPadReflect = (output, inputRank, padsLength) => {\n let block = "";\n for (let i = inputRank - 1; i >= 0; --i) {\n block += `\n k = i32(${output.indicesGet("indices", i)}) - ${getElementAt("uniforms.pads", i, padsLength)};\n if (k < 0) {\n k = -k;\n }\n {\n let _2n_1 = 2 * (i32(${getElementAt("uniforms.x_shape", i, inputRank)}) - 1);\n k = k % _2n_1;\n if(k >= i32(${getElementAt("uniforms.x_shape", i, inputRank)})) {\n k = _2n_1 - k;\n }\n }\n offset += k * i32(${getElementAt("uniforms.x_strides", i, inputRank)});\n `;\n }\n return `\n var offset = 0;\n var k = 0;\n ${block}\n value = x[offset];\n `;\n };\n getPadEdge = (output, inputRank, padsLength) => {\n let block = "";\n for (let i = inputRank - 1; i >= 0; --i) {\n block += `\n k = i32(${output.indicesGet("indices", i)}) - ${getElementAt("uniforms.pads", i, padsLength)};\n if (k < 0) {\n k = 0;\n }\n if (k >= i32(${getElementAt("uniforms.x_shape", i, inputRank)})) {\n k = i32(${getElementAt("uniforms.x_shape", i, inputRank)}) - 1;\n }\n offset += k * i32(${getElementAt("uniforms.x_strides", i, inputRank)});\n `;\n }\n return `\n var offset = 0;\n var k = 0;\n ${block}\n value = x[offset];\n `;\n };\n getPadWrap = (output, inputRank, padsLength) => {\n let block = "";\n for (let i = inputRank - 1; i >= 0; --i) {\n block += `\n k = i32(${output.indicesGet("indices", i)}) - ${getElementAt("uniforms.pads", i, padsLength)};\n if (k < 0) {\n k += i32(${getElementAt("uniforms.x_shape", i, inputRank)}]);\n }\n if (k >= i32(${getElementAt("uniforms.x_shape", i, inputRank)})) {\n k -= i32(${getElementAt("uniforms.x_shape", i, inputRank)});\n }\n offset += k * i32(${getElementAt("uniforms.x_strides", i, inputRank)});\n `;\n }\n return `\n var offset = 0;\n var k = 0;\n ${block}\n value = x[offset];\n `;\n };\n getPadSnippet = (output, inputRank, attributes) => {\n switch (attributes.mode) {\n case 0:\n return getPadConstant(output, inputRank, attributes.pads.length);\n case 1:\n return getPadReflect(output, inputRank, attributes.pads.length);\n case 2:\n return getPadEdge(output, inputRank, attributes.pads.length);\n case 3:\n return getPadWrap(output, inputRank, attributes.pads.length);\n default:\n throw new Error("Invalid mode");\n }\n };\n createPadProgramInfo = (inputs, attributes) => {\n const outputShape = ShapeUtil.padShape(inputs[0].dims.slice(), attributes.pads);\n const inputDims = inputs[0].dims;\n const outputSize = ShapeUtil.size(outputShape);\n const programUniforms = [{ type: 12 /* uint32 */, data: outputSize }, { type: 6 /* int32 */, data: attributes.pads }];\n if (attributes.mode === 0) {\n programUniforms.push({ type: inputs[0].dataType, data: attributes.value });\n }\n programUniforms.push(...createTensorShapeVariables(inputs[0].dims, outputShape));\n const inputDependencies = ["rank"];\n const getShaderSource = (shaderHelper) => {\n const output = outputVariable("output", inputs[0].dataType, outputShape.length);\n const input = inputVariable("x", inputs[0].dataType, inputDims.length);\n const dataType = input.type.value;\n const padSnippet = getPadSnippet(output, inputDims.length, attributes);\n const uniforms = [{ name: "output_size", type: "u32" }, { name: "pads", type: "i32", length: attributes.pads.length }];\n if (attributes.mode === 0) {\n uniforms.push({ name: "constant_value", type: dataType });\n }\n return `\n ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)}\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}\n\n let indices = ${output.offsetToIndices("global_idx")};\n\n var value = ${dataType}(0);\n ${padSnippet}\n output[global_idx] = value;\n }`;\n };\n return {\n name: "Pad",\n shaderCache: { hint: `${attributes.mode}`, inputDependencies },\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n dispatchGroup: { x: Math.ceil(\n ShapeUtil.size(outputShape) / 64\n /* workgroup size */\n ) },\n programUniforms\n }),\n getShaderSource\n };\n };\n createPadAttributesFromInputs = (inputs, attributes) => {\n if (inputs.length > 1) {\n const bigInt64Pads = inputs[1].getBigInt64Array();\n const value = inputs.length >= 3 && inputs[2].data ? inputs[2].getFloat32Array()[0] : 0;\n const inputRank = inputs[0].dims.length;\n const updatePads = new Int32Array(2 * inputRank).fill(0);\n if (inputs.length >= 4) {\n const axes = inputs[3].getBigInt64Array();\n for (let i = 0; i < axes.length; i++) {\n updatePads[Number(axes[i])] = Number(bigInt64Pads[i]);\n updatePads[Number(axes[i]) + inputRank] = Number(bigInt64Pads[i + axes.length]);\n }\n } else {\n bigInt64Pads.forEach((v, i) => updatePads[Number(i)] = Number(v));\n }\n const pads = [];\n updatePads.forEach((v) => pads.push(v));\n return { mode: attributes.mode, value, pads };\n } else {\n return attributes;\n }\n };\n pad = (context, attributes) => {\n validateInputs19(context.inputs);\n const updatedAttributes = createPadAttributesFromInputs(context.inputs, attributes);\n context.compute(createPadProgramInfo(context.inputs, updatedAttributes), { inputs: [0] });\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/pool.ts\n var validateInputs20, getAdjustedPoolAttributesAndOutputShape, getUniformAndPadInfo, generatePoolingCode, createShaderKeyFromAttributes, createAveragePoolShaderKeyFromAttributes, createMaxPoolShaderKeyFromAttributes, parsePoolCommonAttributes, createAveragePoolProgramInfo, parseAveragePoolAttributes, averagePool, globalPoolAttributes, parseGlobalAveragePoolAttributes, globalAveragePool, createMaxPoolProgramInfo, maxPool, parseMaxPoolAttributes, parseGlobalMaxPoolAttributes, globalMaxPool;\n var init_pool = __esm({\n "web/lib/wasm/jsep/webgpu/ops/pool.ts"() {\n "use strict";\n init_esm();\n init_wasm_common();\n init_util();\n init_common();\n validateInputs20 = (inputs) => {\n if (env2.webgpu.validateInputContent && (!inputs || inputs.length !== 1)) {\n throw new Error("Pool ops requires 1 input.");\n }\n };\n getAdjustedPoolAttributesAndOutputShape = (input, attributes, isGlobalOperator) => {\n const isChannelsLast = attributes.format === "NHWC";\n const inputShapeAsChannelFirst = input.dims.slice();\n if (isChannelsLast) {\n inputShapeAsChannelFirst.splice(1, 0, inputShapeAsChannelFirst.pop());\n }\n const hasDilations = Object.hasOwnProperty.call(attributes, "dilations");\n const kernelShape = attributes.kernelShape.slice();\n const strides = attributes.strides.slice();\n const dilations = hasDilations ? attributes.dilations.slice() : [];\n const pads = attributes.pads.slice();\n PoolConvUtil.adjustPoolAttributes(isGlobalOperator, inputShapeAsChannelFirst, kernelShape, strides, dilations, pads);\n const outputShapeAsChannelFirst = PoolConvUtil.computePoolOutputShape(\n isGlobalOperator,\n inputShapeAsChannelFirst,\n strides,\n dilations,\n kernelShape,\n pads,\n attributes.autoPad\n );\n const newAttributes = Object.assign({}, attributes);\n if (hasDilations) {\n Object.assign(newAttributes, { kernelShape, strides, pads, dilations, cacheKey: attributes.cacheKey });\n } else {\n Object.assign(newAttributes, { kernelShape, strides, pads, cacheKey: attributes.cacheKey });\n }\n const outputShapeAsChannelLast = outputShapeAsChannelFirst.slice();\n outputShapeAsChannelLast.push(outputShapeAsChannelLast.splice(1, 1)[0]);\n return [newAttributes, isChannelsLast ? outputShapeAsChannelLast : outputShapeAsChannelFirst];\n };\n getUniformAndPadInfo = (outputShape, attributes) => {\n const isChannelsLast = attributes.format === "NHWC";\n const outputSize = ShapeUtil.size(outputShape);\n const kernelSize = ShapeUtil.size(attributes.kernelShape);\n const programUniforms = [{ type: 12 /* uint32 */, data: outputSize }, { type: 12 /* uint32 */, data: kernelSize }];\n const uniforms = [{ name: "outputSize", type: "u32" }, { name: "kernelSize", type: "u32" }];\n if (attributes.kernelShape.length <= 2) {\n const kw = attributes.kernelShape[attributes.kernelShape.length - 1];\n const sw = attributes.strides[attributes.strides.length - 1];\n const pwStart = attributes.pads[attributes.pads.length / 2 - 1];\n const pwEnd = attributes.pads[attributes.pads.length - 1];\n const pwStartEndNotZero = !!(pwStart + pwEnd);\n programUniforms.push(\n { type: 12 /* uint32 */, data: kw },\n { type: 12 /* uint32 */, data: sw },\n { type: 12 /* uint32 */, data: pwStart },\n { type: 12 /* uint32 */, data: pwEnd }\n );\n uniforms.push(\n { name: "kw", type: "u32" },\n { name: "sw", type: "u32" },\n { name: "pwStart", type: "u32" },\n { name: "pwEnd", type: "u32" }\n );\n let phStartEndNotZero = false;\n if (attributes.kernelShape.length === 2) {\n const kh = attributes.kernelShape[attributes.kernelShape.length - 2];\n const sh = attributes.strides[attributes.strides.length - 2];\n const phStart = attributes.pads[attributes.pads.length / 2 - 2];\n const phEnd = attributes.pads[attributes.pads.length - 2];\n phStartEndNotZero = !!(phStart + phEnd);\n programUniforms.push(\n { type: 12 /* uint32 */, data: kh },\n { type: 12 /* uint32 */, data: sh },\n { type: 12 /* uint32 */, data: phStart },\n { type: 12 /* uint32 */, data: phEnd }\n );\n uniforms.push(\n { name: "kh", type: "u32" },\n { name: "sh", type: "u32" },\n { name: "phStart", type: "u32" },\n { name: "phEnd", type: "u32" }\n );\n }\n return [programUniforms, uniforms, true, pwStartEndNotZero, phStartEndNotZero];\n } else {\n if (isChannelsLast) {\n throw new Error("Pooling with kernelShape.length > 2 is not supported for NHWC format.");\n }\n const kernelStrides = ShapeUtil.computeStrides(attributes.kernelShape);\n programUniforms.push(\n { type: 12 /* uint32 */, data: kernelStrides },\n { type: 12 /* uint32 */, data: attributes.pads },\n { type: 12 /* uint32 */, data: attributes.strides }\n );\n uniforms.push(\n { name: "kernelStrides", type: "u32", length: kernelStrides.length },\n { name: "pads", type: "u32", length: attributes.pads.length },\n { name: "strides", type: "u32", length: attributes.strides.length }\n );\n const hasPads = attributes.pads.reduce((sum, cur) => sum + cur);\n return [programUniforms, uniforms, !!hasPads, false, false];\n }\n };\n generatePoolingCode = (shaderHelper, x, rank, outputShapeRank, attributes, op1, op2, start, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero) => {\n const isChannelsLast = attributes.format === "NHWC";\n const dataType = x.type.value;\n const output = outputVariable("output", x.type.tensor, outputShapeRank);\n if (attributes.kernelShape.length <= 2) {\n let codeW = "";\n let codeH = "";\n let codeHEnd = "";\n const dimIdxW = rank - (isChannelsLast ? 2 : 1);\n if (pwStartEndNotZero) {\n codeW = `\n for (var i: u32 = 0u; i < uniforms.kw; i++) {\n xIndices[${dimIdxW}] = indices[${dimIdxW}] * uniforms.sw - uniforms.pwStart + i;\n if (xIndices[${dimIdxW}] < 0 || xIndices[${dimIdxW}]\n >= uniforms.x_shape[${dimIdxW}]) {\n pad++;\n continue;\n }\n let x_val = x[${x.indicesToOffset("xIndices")}];\n ${op1}\n }`;\n } else {\n codeW = `\n for (var i: u32 = 0u; i < uniforms.kw; i++) {\n xIndices[${dimIdxW}] = indices[${dimIdxW}] * uniforms.sw - uniforms.pwStart + i;\n let x_val = x[${x.indicesToOffset("xIndices")}];\n ${op1}\n }`;\n }\n if (attributes.kernelShape.length === 2) {\n const dimIdxH = rank - (isChannelsLast ? 3 : 2);\n if (phStartEndNotZero) {\n codeH = `\n for (var j: u32 = 0u; j < uniforms.kh; j++) {\n xIndices[${dimIdxH}] = indices[${dimIdxH}] * uniforms.sh - uniforms.phStart + j;\n if (xIndices[${dimIdxH}] < 0 || xIndices[${dimIdxH}] >= uniforms.x_shape[${dimIdxH}]) {\n pad += i32(uniforms.kw);\n continue;\n }\n `;\n } else {\n codeH = `\n for (var j: u32 = 0u; j < uniforms.kh; j++) {\n xIndices[${dimIdxH}] = indices[${dimIdxH}] * uniforms.sh - uniforms.phStart + j;\n `;\n }\n codeHEnd = `\n }\n `;\n }\n const poolingCode = `\n ${shaderHelper.registerUniforms(uniforms).declareVariables(x, output)}\n\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}\n\n let indices = ${output.offsetToIndices("global_idx")};\n var xIndices = ${output.offsetToIndices("global_idx")};\n\n var value = ${dataType}(${start});\n var pad = 0;\n ${codeH}\n ${codeW}\n ${codeHEnd}\n ${op2}\n\n output[global_idx] = value;\n }`;\n return poolingCode;\n } else {\n if (isChannelsLast) {\n throw new Error("Pooling with kernelShape.length > 2 is not supported for NHWC format.");\n }\n const stridesRank = attributes.kernelShape.length;\n const padsRank = attributes.pads.length;\n let padCode = "";\n if (hasPads) {\n padCode = `\n if (xIndices[j] >= uniforms.x_shape[j]) {\n pad++;\n isPad = true;\n break;\n }\n }\n if (!isPad) {\n let x_val = x[${x.indicesToOffset("xIndices")}];\n ${op1}\n }`;\n } else {\n padCode = `\n }\n let x_val = x[${x.indicesToOffset("xIndices")}];\n ${op1}\n `;\n }\n const poolingCode = `\n ${shaderHelper.registerUniforms(uniforms).declareVariables(x, output)}\n\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}\n let indices = ${output.offsetToIndices("global_idx")};\n var xIndices = ${output.offsetToIndices("global_idx")};\n\n var offsets: array;\n\n var value = ${dataType}(${start});\n var pad = 0;\n var isPad = false;\n\n for (var i: u32 = 0u; i < uniforms.kernelSize; i++) {\n var offset = i;\n for (var j = 0u; j < ${stridesRank - 1}u; j++) {\n offsets[j] = offset / ${getElementAt("uniforms.kernelStrides", "j", stridesRank)};\n offset -= offsets[j] * ${getElementAt("uniforms.kernelStrides", "j", stridesRank)};\n }\n offsets[${stridesRank - 1}] = offset;\n\n isPad = false;\n for (var j = ${rank - stridesRank}u; j < ${rank}u; j++) {\n xIndices[j] = indices[j] * ${getElementAt("uniforms.strides", `j - ${rank - stridesRank}u`, stridesRank)}\n + offsets[j - ${rank - stridesRank}u] - ${getElementAt("uniforms.pads", "j - 2u", padsRank)};\n ${padCode}\n }\n ${op2}\n\n output[global_idx] = value;\n }`;\n return poolingCode;\n }\n };\n createShaderKeyFromAttributes = (attributes) => `${attributes.format};${attributes.ceilMode};${attributes.autoPad};${attributes.kernelShape.length}`;\n createAveragePoolShaderKeyFromAttributes = (attributes) => `${createShaderKeyFromAttributes(attributes)};${attributes.countIncludePad}`;\n createMaxPoolShaderKeyFromAttributes = (attributes) => `${createShaderKeyFromAttributes(attributes)};${attributes.storageOrder};${attributes.dilations}`;\n parsePoolCommonAttributes = (attributes) => ({\n format: attributes.format,\n autoPad: ["NOTSET", "VALID", "SAME_UPPER", "SAME_LOWER"][attributes.auto_pad],\n ceilMode: attributes.ceil_mode,\n kernelShape: attributes.kernel_shape,\n strides: attributes.strides,\n pads: attributes.pads\n });\n createAveragePoolProgramInfo = (name, input, isGlobalOperator, attributes) => {\n const [adjustedAttributes, outputShape] = getAdjustedPoolAttributesAndOutputShape(input, attributes, isGlobalOperator);\n const x = inputVariable("x", input.dataType, input.dims.length);\n const dataType = x.type.value;\n const op1 = "value += x_val;";\n let op2 = "";\n if (adjustedAttributes.countIncludePad) {\n op2 += `value /= ${dataType}(uniforms.kernelSize);`;\n } else {\n op2 += `value /= ${dataType}(i32(uniforms.kernelSize) - pad);`;\n }\n const [programUniforms, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero] = getUniformAndPadInfo(outputShape, adjustedAttributes);\n programUniforms.push(...createTensorShapeVariables(input.dims, outputShape));\n const inputDependencies = ["rank"];\n return {\n name,\n shaderCache: { hint: `${attributes.cacheKey};${hasPads};${pwStartEndNotZero};${phStartEndNotZero}`, inputDependencies },\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: input.dataType }],\n dispatchGroup: { x: Math.ceil(\n ShapeUtil.size(outputShape) / 64\n /* workgroup size */\n ) },\n programUniforms\n }),\n getShaderSource: (shaderHelper) => generatePoolingCode(\n shaderHelper,\n x,\n input.dims.length,\n outputShape.length,\n adjustedAttributes,\n op1,\n op2,\n 0,\n uniforms,\n hasPads,\n pwStartEndNotZero,\n phStartEndNotZero\n )\n };\n };\n parseAveragePoolAttributes = (attributes) => {\n const countIncludePad = attributes.count_include_pad === 0 ? false : true;\n const attr = parsePoolCommonAttributes(attributes);\n if (attr.ceilMode !== 0) {\n throw new Error("using ceil() in shape computation is not yet supported for AveragePool");\n }\n const averagePoolAttributes = { countIncludePad, ...attr, cacheKey: "" };\n return { ...averagePoolAttributes, cacheKey: createAveragePoolShaderKeyFromAttributes(averagePoolAttributes) };\n };\n averagePool = (context, attributes) => {\n validateInputs20(context.inputs);\n context.compute(createAveragePoolProgramInfo("AveragePool", context.inputs[0], false, attributes));\n };\n globalPoolAttributes = {\n autoPad: "",\n ceilMode: 0,\n countIncludePad: false,\n kernelShape: [],\n strides: [],\n pads: [],\n storageOrder: 0,\n dilations: []\n };\n parseGlobalAveragePoolAttributes = (attributes) => {\n const format = attributes.format;\n return { format, ...globalPoolAttributes, cacheKey: format };\n };\n globalAveragePool = (context, attributes) => {\n validateInputs20(context.inputs);\n context.compute(createAveragePoolProgramInfo("GlobalAveragePool", context.inputs[0], true, attributes));\n };\n createMaxPoolProgramInfo = (name, input, isGlobalOperator, attributes) => {\n const [adjustedAttributes, outputShape] = getAdjustedPoolAttributesAndOutputShape(input, attributes, isGlobalOperator);\n const op1 = `\n value = max(x_val, value);\n `;\n const op2 = "";\n const x = inputVariable("x", input.dataType, input.dims.length);\n const inputDependencies = ["rank"];\n const [programUniforms, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero] = getUniformAndPadInfo(outputShape, adjustedAttributes);\n programUniforms.push(...createTensorShapeVariables(input.dims, outputShape));\n return {\n name,\n shaderCache: { hint: `${attributes.cacheKey};${hasPads};${pwStartEndNotZero};${phStartEndNotZero}`, inputDependencies },\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: input.dataType }],\n dispatchGroup: { x: Math.ceil(\n ShapeUtil.size(outputShape) / 64\n /* workgroup size */\n ) },\n programUniforms\n }),\n getShaderSource: (shaderHelper) => generatePoolingCode(\n shaderHelper,\n x,\n input.dims.length,\n outputShape.length,\n adjustedAttributes,\n op1,\n op2,\n input.dataType === 10 /* float16 */ ? -65504 : -1e5,\n uniforms,\n hasPads,\n pwStartEndNotZero,\n phStartEndNotZero\n )\n };\n };\n maxPool = (context, attributes) => {\n validateInputs20(context.inputs);\n context.compute(createMaxPoolProgramInfo("MaxPool", context.inputs[0], false, attributes));\n };\n parseMaxPoolAttributes = (attributes) => {\n const storageOrder = attributes.storage_order;\n const dilations = attributes.dilations;\n const attr = parsePoolCommonAttributes(attributes);\n if (storageOrder !== 0) {\n throw new Error("column major storage order is not yet supported for MaxPool");\n }\n if (attr.ceilMode !== 0) {\n throw new Error("using ceil() in shape computation is not yet supported for MaxPool");\n }\n const maxPoolAttributes = { storageOrder, dilations, ...attr, cacheKey: "" };\n return { ...maxPoolAttributes, cacheKey: createMaxPoolShaderKeyFromAttributes(maxPoolAttributes) };\n };\n parseGlobalMaxPoolAttributes = (attributes) => {\n const format = attributes.format;\n return { format, ...globalPoolAttributes, cacheKey: format };\n };\n globalMaxPool = (context, attributes) => {\n validateInputs20(context.inputs);\n context.compute(createMaxPoolProgramInfo("GlobalMaxPool", context.inputs[0], true, attributes));\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/range.ts\n var validateInputsContent, createRangeProgramInfo, range;\n var init_range = __esm({\n "web/lib/wasm/jsep/webgpu/ops/range.ts"() {\n "use strict";\n init_esm();\n init_wasm_common();\n init_common();\n validateInputsContent = (start, limit, delta) => {\n const sameStartLimit = start === limit;\n const increasingRangeNegativeStep = start < limit && delta < 0;\n const decreasingRangePositiveStep = start > limit && delta > 0;\n if (sameStartLimit || increasingRangeNegativeStep || decreasingRangePositiveStep) {\n throw new Error("Range these inputs\' contents are invalid.");\n }\n };\n createRangeProgramInfo = (start, limit, delta, dataType) => {\n const numElements = Math.abs(Math.ceil((limit - start) / delta));\n const outputShape = [numElements];\n const outputSize = numElements;\n const programUniforms = [\n { type: 12 /* uint32 */, data: outputSize },\n { type: dataType, data: start },\n { type: dataType, data: delta },\n ...createTensorShapeVariables(outputShape)\n ];\n const getShaderSource = (shaderHelper) => {\n const output = outputVariable("output", dataType, outputShape.length);\n const wgslType = output.type.value;\n const uniforms = [\n { name: "outputSize", type: "u32" },\n { name: "start", type: wgslType },\n { name: "delta", type: wgslType }\n ];\n return `\n ${shaderHelper.registerUniforms(uniforms).declareVariables(output)}\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}\n output[global_idx] = uniforms.start + ${wgslType}(global_idx) * uniforms.delta;\n }`;\n };\n return {\n name: "Range",\n shaderCache: { hint: `${dataType}` },\n getShaderSource,\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms\n })\n };\n };\n range = (context) => {\n let start = 0;\n let limit = 0;\n let delta = 0;\n if (context.inputs[0].dataType === 6 /* int32 */) {\n start = context.inputs[0].getInt32Array()[0];\n limit = context.inputs[1].getInt32Array()[0];\n delta = context.inputs[2].getInt32Array()[0];\n } else if (context.inputs[0].dataType === 1 /* float */) {\n start = context.inputs[0].getFloat32Array()[0];\n limit = context.inputs[1].getFloat32Array()[0];\n delta = context.inputs[2].getFloat32Array()[0];\n }\n if (env2.webgpu.validateInputContent) {\n validateInputsContent(start, limit, delta);\n }\n context.compute(createRangeProgramInfo(start, limit, delta, context.inputs[0].dataType), { inputs: [] });\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/resize.ts\n var validateScales, updateScales, validateInputs21, getOriginalCoordinateFromResizedCoordinate, getNearestPixelFromOriginal, updateRoI, initOutputShape, adjustOutputShape, calculateOriginalIndicesFromOutputIndices, calculateInputIndicesFromOutputIndices, checkInputIndices, setChannelAndBatchIndices, bilinearInterpolation, bicubicInterpolation, trilinearInterpolation, createResizeProgramInfo, getOpsetVersionFromCustomDataBuffer, resize, parseResizeAttributes;\n var init_resize = __esm({\n "web/lib/wasm/jsep/webgpu/ops/resize.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_attribute_with_cache_key();\n init_common();\n validateScales = (scales, attributes) => {\n scales.every((value) => value > 0 || (() => {\n throw new Error("Resize requires scales input values to be positive");\n }));\n if (scales.length > 0) {\n if (attributes.mode === "linear") {\n if (!(scales.length === 2 || scales.length === 3 || scales.length === 4 && scales[0] === 1 && scales[1] === 1 || scales.length === 4 && scales[0] === 1 && scales[3] === 1 || scales.length === 5 && scales[0] === 1 && scales[1] === 1)) {\n throw new Error(\n `For linear mode, Resize requires scales to be 2D, 3D, 4D with either two outermost or one innermost and\n one outermost scale values equal to 1, or 5D with two outermost scale values equal to 1`\n );\n }\n } else if (attributes.mode === "cubic") {\n if (!(scales.length === 2 || scales.length === 4 && scales[0] === 1 && scales[1] === 1 || scales.length === 4 && scales[0] === 1 && scales[3] === 1)) {\n throw new Error("Resize requires scales input size to be 2 or 4 for cubic mode");\n }\n }\n }\n };\n updateScales = (scales, axes, rank) => {\n axes.every((value) => value >= 0 && value < rank || (() => {\n throw new Error("Resize requires axes input values to be positive and less than rank");\n }));\n const newScales = new Array(rank).fill(1);\n axes.forEach((value, index) => newScales[value] = scales[index]);\n return newScales;\n };\n validateInputs21 = (inputs, attributes, opsetVersion, scales, sizes, roi) => {\n const [roiInputIndex, scalesInputIndex, sizesInputIndex] = opsetVersion > 10 ? [1, 2, 3] : [-1, inputs.length > 1 ? 1 : -1, -1];\n const rank = inputs[0].dims.length;\n if (roiInputIndex > 0 && inputs.length > roiInputIndex && inputs[roiInputIndex].dims.length > 0) {\n inputs[roiInputIndex].getFloat32Array().forEach((value) => roi.push(value));\n } else if (attributes.coordinateTransformMode === "tf_crop_and_resize") {\n throw new Error("Resize requires RoI input to be specified when coordinateTransformMode is tfCropAndResize");\n }\n if (scalesInputIndex > 0 && inputs.length > scalesInputIndex && inputs[scalesInputIndex].dims.length > 0) {\n inputs[scalesInputIndex].getFloat32Array().forEach((value) => scales.push(value));\n if (scales.length !== 0 && (scales.length !== rank && (opsetVersion >= 18 && scales.length !== attributes.axes.length))) {\n throw new Error(\n "Resize requires scales input size to be same as input rank or axes size for opset 18 and up"\n );\n }\n validateScales(scales, attributes);\n if (attributes.axes.length > 0) {\n updateScales(scales, attributes.axes, rank).forEach((value, index) => scales[index] = value);\n }\n }\n if (sizesInputIndex > 0 && inputs.length > sizesInputIndex) {\n inputs[sizesInputIndex].getBigInt64Array().forEach((value) => sizes.push(Number(value)));\n if (sizes.length !== rank || opsetVersion >= 18 && sizes.length === attributes.axes.length) {\n throw new Error("Resize requires sizes input size to be same as input rank or axes size for opset 18 and up");\n }\n }\n if (attributes.axes.length > 0) {\n if (scales.length !== attributes.axes.length) {\n throw new Error(\'Resize requires "scales" input size to be of axes rank when axes attributes is specified\');\n }\n if (sizes.length !== attributes.axes.length) {\n throw new Error(\n \'Resize requires "sizes" input size to be of rank axes rank when axes attributes is specified\'\n );\n }\n }\n if (typeof scales !== "undefined" && typeof sizes !== "undefined" && scales.length > 0 && sizes.length > rank) {\n throw new Error("Resize requires only of scales or sizes to be specified");\n }\n };\n getOriginalCoordinateFromResizedCoordinate = (coordinateTransferMode, dType) => `fn getOriginalCoordinateFromResizedCoordinate(xResized: u32, xScale: f32, lengthResized: u32,\n lengthOriginal: u32, roiStart: f32, roiEnd: f32) -> ${dType} { ` + (() => {\n switch (coordinateTransferMode) {\n case "asymmetric":\n return `return ${dType}(xResized) / ${dType}(xScale);`;\n case "pytorch_half_pixel":\n return `if (lengthResized > 1) {\n return (${dType}(xResized) + 0.5) / ${dType}(xScale) - 0.5;\n } else {\n return 0.0;\n }`;\n case "tf_half_pixel_for_nn":\n return `return (${dType}(xResized) + 0.5) / ${dType}(xScale);`;\n case "align_corners":\n return `if (lengthResized == 1) {\n return 0.0;\n } else {\n // The whole part and the fractional part are calculated separately due to inaccuracy of floating\n // point division. As an example, f32(21) / f32(7) may evaluate to 2.99... instead of 3, causing an\n // offset-by-one error later in floor().\n let whole = ${dType}(xResized * (lengthOriginal - 1) / (lengthResized - 1));\n let fract =\n ${dType}(xResized * (lengthOriginal - 1) % (lengthResized - 1)) / ${dType}(lengthResized - 1);\n return whole + fract;\n }`;\n case "tf_crop_and_resize":\n return `if (lengthResized > 1) {\n return ${dType}(roiStart) * ${dType}(lengthOriginal - 1) +\n (${dType}(xResized) * ${dType}(roiEnd - roiStart) * ${dType}(lengthOriginal - 1)) /\n ${dType}(lengthResized - 1);\n } else {\n return 0.5 * ${dType}(roiStart + roiEnd) * ${dType}(lengthOriginal - 1);\n }`;\n case "half_pixel_symmetric":\n return `const outputWidth = ${dType}xScale * ${dType}(lengthResized);\n const adjustment = ${dType}(lengthResized) / outputWidth;\n const center = ${dType}(lengthOriginal) / 2;\n const offset = center * (1 - adjustment);\n return offset + ((${dType}(xResized) + 0.5) / ${dType}(xScale)) - 0.5;`;\n case "half_pixel":\n return `return ((${dType}(xResized) + 0.5) / ${dType}(xScale)) - 0.5;`;\n default:\n throw new Error(`Coordinate transform mode ${coordinateTransferMode} is not supported`);\n }\n })() + "}";\n getNearestPixelFromOriginal = (nearestMode, opsetVersion, dType) => `fn getNearestPixelFromOriginal(xOriginal: ${dType}, isDownSample: bool) -> ${dType} {` + (() => {\n switch (nearestMode) {\n case "round_prefer_ceil":\n return "if (fract(xOriginal) == 0.5) { return ceil(xOriginal); } else { return round(xOriginal); }";\n case "floor":\n return "return floor(xOriginal);";\n case "ceil":\n return "return ceil(xOriginal);";\n case "round_prefer_floor":\n return "if (fract(xOriginal) == 0.5) { return floor(xOriginal); } else { return round(xOriginal); }";\n case "simple":\n default:\n if (opsetVersion < 11) {\n return "if (isDownSample) { return ceil(xOriginal); } else { return xOriginal; }";\n }\n throw new Error(`Nearest mode ${nearestMode} is not supported`);\n }\n })() + "}";\n updateRoI = (roi, axes, rank) => {\n const roiTmp = new Array(rank).fill(0).concat(new Array(rank).fill(1));\n const roiLocal = roi.length === 0 ? roiTmp : roi.slice();\n if (axes.length > 0) {\n axes.forEach((v, i) => {\n roiTmp[v] = roiLocal[i];\n roiTmp[i + rank] = roiLocal[axes.length + i];\n });\n return roiTmp;\n }\n return roiLocal;\n };\n initOutputShape = (inputShape, scales, sizes, axes) => {\n let outputShape = [];\n if (sizes.length > 0) {\n if (axes.length > 0) {\n inputShape.forEach((v) => outputShape.push(v));\n if (Math.max(...axes) > inputShape.length) {\n throw new Error("axes is out of bound");\n }\n axes.forEach((v, i) => outputShape[v] = sizes[i]);\n } else {\n sizes.forEach((v) => outputShape.push(v));\n }\n } else {\n if (scales.length === 0) {\n throw new Error("Resize requires either scales or sizes.");\n } else {\n outputShape = inputShape.map((value, index) => Math.round(value * scales[index]));\n }\n }\n return outputShape;\n };\n adjustOutputShape = (inputShape, scales, attributes) => {\n const scaleInPolicy = (() => {\n switch (attributes.keepAspectRatioPolicy) {\n case "not_larger":\n return attributes.axes.length > 0 ? Math.min(...attributes.axes.map((i) => scales[i]), Number.MAX_VALUE) : Math.min(...scales, Number.MAX_VALUE);\n case "not_smaller":\n return attributes.axes.length > 0 ? Math.max(...attributes.axes.map((i) => scales[i]), Number.MIN_VALUE) : Math.max(...scales, Number.MIN_VALUE);\n default:\n throw new Error(`Keep aspect ratio policy ${attributes.keepAspectRatioPolicy} is not supported`);\n }\n })();\n scales.fill(1, 0, scales.length);\n const adjustedOutputShape = inputShape.slice();\n if (attributes.axes.length > 0) {\n attributes.axes.forEach((v) => scales[v] = scaleInPolicy);\n attributes.axes.forEach((v) => adjustedOutputShape[v] = Math.round(inputShape[v] * scales[v]));\n } else {\n scales.fill(scaleInPolicy, 0, scales.length);\n adjustedOutputShape.forEach((v, i) => adjustedOutputShape[i] = Math.round(v * scales[i]));\n }\n return adjustedOutputShape;\n };\n calculateOriginalIndicesFromOutputIndices = (output, inputShape, outputShape, scalesLength, roiLength) => `\n fn calculateOriginalIndicesFromOutputIndices(output_indices: ${output.type.indices}) -> array<${output.type.value}, ${outputShape.length}> {\n var original_indices: array<${output.type.value}, ${outputShape.length}>;\n for (var i:u32 = 0; i < ${outputShape.length}; i++) {\n var output_index = ${output.indicesGet("output_indices", "i")};\n var scale = ${getElementAt("uniforms.scales", "i", scalesLength)};\n var roi_low = ${getElementAt("uniforms.roi", "i", roiLength)};\n var roi_hi = ${getElementAt("uniforms.roi", `i + ${inputShape.length}`, roiLength)};\n if (scale == 1.0) {\n original_indices[i] = ${output.type.value}(output_index);\n } else {\n var input_shape_i = ${getElementAt("uniforms.input_shape", "i", inputShape.length)};\n var output_shape_i = ${getElementAt("uniforms.output_shape", "i", outputShape.length)};\n original_indices[i] = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i,\n input_shape_i, roi_low, roi_hi);\n }\n }\n return original_indices;\n }`;\n calculateInputIndicesFromOutputIndices = (input, output, inputShape, outputShape, scalesLength, roiLength, useExtrapolation) => `\n fn calculateInputIndicesFromOutputIndices(output_indices: ${output.type.indices}) -> ${input.type.indices} {\n var input_indices: ${input.type.indices};\n for (var i:u32 = 0; i < ${outputShape.length}; i++) {\n var output_index = ${output.indicesGet("output_indices", "i")};\n var input_index: u32;\n var scale = ${getElementAt("uniforms.scales", "i", scalesLength)};\n if (scale == 1.0) {\n input_index = output_index;\n } else {\n var roi_low = ${getElementAt("uniforms.roi", "i", roiLength)};\n var roi_hi = ${getElementAt("uniforms.roi", `i + ${inputShape.length}`, roiLength)};\n var input_shape_i = ${getElementAt("uniforms.input_shape", "i", inputShape.length)};\n var output_shape_i = ${getElementAt("uniforms.output_shape", "i", outputShape.length)};\n var original_idx = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i,\n input_shape_i, roi_low, roi_hi);\n if (!${useExtrapolation} || (original_idx >= 0 && original_idx < ${output.type.value}(input_shape_i))) {\n if (original_idx < 0) {\n input_index = 0;\n } else if (original_idx > ${output.type.value}(input_shape_i - 1)) {\n input_index = input_shape_i - 1;\n } else {\n input_index = u32(getNearestPixelFromOriginal(original_idx, scale < 1));\n }\n } else {\n input_index = u32(original_idx);\n }\n }\n ${input.indicesSet("input_indices", "i", " input_index")}\n }\n return input_indices;\n }`;\n checkInputIndices = (input, inputShape) => `\n fn checkInputIndices(input_indices: ${input.type.indices}) -> bool {\n for (var i:u32 = 0; i < ${inputShape.length}; i++) {\n var input_index = ${input.indicesGet("input_indices", "i")};\n if (input_index < 0 || input_index >= ${getElementAt("uniforms.input_shape", "i", inputShape.length)}) {\n return false;\n }\n }\n return true;\n }`;\n setChannelAndBatchIndices = (input, channelIdx, batchIdx, spacialDims) => input.rank > spacialDims ? `\n ${input.indicesSet("input_indices", channelIdx, "channel")};\n ${input.indicesSet("input_indices", batchIdx, "batch")};\n` : "";\n bilinearInterpolation = (input, output, inputShape, useExtrapolation, extrapolationValue) => {\n const isNchw = true;\n const [batchIdx, heightIdx, widthIdx, channelIdx] = inputShape.length === 2 ? [-1, 0, 1, -1] : isNchw ? [0, 2, 3, 1] : [0, 1, 2, 3];\n const dType = input.type.value;\n return `\n fn getInputValue(batch: u32, channel: u32, row: u32, col: u32) -> ${dType} {\n var input_indices: ${input.type.indices};\n ${input.indicesSet("input_indices", heightIdx, `max(0, min(row, ${inputShape[heightIdx]} - 1))`)};\n ${input.indicesSet("input_indices", widthIdx, `max(0, min(col, ${inputShape[widthIdx]} - 1))`)};\n ${setChannelAndBatchIndices(input, channelIdx, batchIdx, 2)}\n return ${input.getByIndices("input_indices")};\n }\n\n fn bilinearInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices);\n var row:${dType} = originalIndices[${heightIdx}];\n var col:${dType} = originalIndices[${widthIdx}];\n ${useExtrapolation ? `if (row < 0 || row > (${inputShape[heightIdx]} - 1) || col < 0 || col > (${inputShape[widthIdx]} - 1)) {\n return ${extrapolationValue};\n }` : ""};\n row = max(0, min(row, ${inputShape[heightIdx]} - 1));\n col = max(0, min(col, ${inputShape[widthIdx]} - 1));\n var row1: u32 = u32(row);\n var col1: u32 = u32(col);\n var row2: u32 = u32(row + 1);\n var col2: u32 = u32(col + 1);\n var channel: u32 = ${inputShape.length > 2 ? `u32(originalIndices[${channelIdx}])` : "0"};\n var batch: u32 = ${inputShape.length > 2 ? `u32(originalIndices[${batchIdx}])` : "0"};\n var x11: ${dType} = getInputValue(batch, channel, row1, col1);\n var x12: ${dType} = getInputValue(batch, channel, row1, col2);\n var x21: ${dType} = getInputValue(batch, channel, row2, col1);\n var x22: ${dType} = getInputValue(batch, channel, row2, col2);\n var dx1: ${dType} = abs(row - ${dType}(row1));\n var dx2: ${dType} = abs(${dType}(row2) - row);\n var dy1: ${dType} = abs(col - ${dType}(col1));\n var dy2: ${dType} = abs(${dType}(col2) - col);\n if (row1 == row2) {\n dx1 = 0.5;\n dx2 = 0.5;\n }\n if (col1 == col2) {\n dy1 = 0.5;\n dy2 = 0.5;\n }\n return (x11 * dx2 * dy2 + x12 * dx2 * dy1 + x21 * dx1 * dy2 + x22 * dx1 * dy1);\n }`;\n };\n bicubicInterpolation = (input, output, inputShape, outputShape, scales, roi, cubicCoeffA, useExtrapolation, extrapolationValue, excludeOutside) => {\n const is2D = inputShape.length === 2;\n const isNchw = true;\n const [heightIdx, widthIdx] = is2D ? [0, 1] : isNchw ? [2, 3] : [1, 2];\n const dType = input.type.value;\n const createCubicInterpolationFunction = (idx) => {\n const direction = idx === heightIdx ? "row" : "col";\n return `\n fn ${direction}CubicInterpolation(input_indices: ${input.type.indices}, output_indices: ${output.type.indices}) -> ${dType} {\n var output_index = ${output.indicesGet("output_indices", idx)};\n var originalIdx: ${dType} = getOriginalCoordinateFromResizedCoordinate(output_index, ${scales[idx]},\n ${outputShape[idx]}, ${inputShape[idx]}, ${roi[idx]}, ${roi[idx]} + ${inputShape.length});\n var fractOriginalIdx: ${dType} = originalIdx - floor(originalIdx);\n var coefs = getCubicInterpolationCoefs(fractOriginalIdx);\n\n if (${useExtrapolation} && (originalIdx < 0 || originalIdx > (${inputShape[idx]} - 1))) {\n return ${extrapolationValue};\n }\n var data: array<${dType}, 4> = array<${dType}, 4>(0.0, 0.0, 0.0, 0.0);\n for (var i: i32 = -1; i < 3; i++) {\n var ${direction}: ${dType} = originalIdx + ${dType}(i);\n if (${direction} < 0 || ${direction} >= ${inputShape[idx]}) {\n ${(() => {\n if (excludeOutside) {\n return `coefs[i + 1] = 0.0;\n continue;`;\n } else if (useExtrapolation) {\n return `return ${extrapolationValue};`;\n } else {\n return `${direction} = max(0, min(${direction}, ${inputShape[idx]} - 1));`;\n }\n })()};\n }\n var input_indices_copy: ${input.type.indices} = input_indices;\n ${input.indicesSet("input_indices_copy", idx, `u32(${direction})`)};\n data[i + 1] = ${idx === heightIdx ? input.getByIndices("input_indices_copy") : "rowCubicInterpolation(input_indices_copy, output_indices)"};\n }\n return cubicInterpolation1D(data, coefs);\n }`;\n };\n return `\n ${createCubicInterpolationFunction(heightIdx)};\n ${createCubicInterpolationFunction(widthIdx)};\n fn getCubicInterpolationCoefs(s: ${dType}) -> array<${dType}, 4> {\n var absS = abs(s);\n var coeffs: array<${dType}, 4> = array<${dType}, 4>(0.0, 0.0, 0.0, 0.0);\n var oneMinusAbsS: ${dType} = 1.0 - absS;\n var twoMinusAbsS: ${dType} = 2.0 - absS;\n var onePlusAbsS: ${dType} = 1.0 + absS;\n coeffs[0] = ((${cubicCoeffA} * onePlusAbsS - 5 * ${cubicCoeffA}) * onePlusAbsS + 8 * ${cubicCoeffA}) * onePlusAbsS - 4 * ${cubicCoeffA};\n coeffs[1] = ((${cubicCoeffA} + 2) * absS - (${cubicCoeffA} + 3)) * absS * absS + 1;\n coeffs[2] = ((${cubicCoeffA} + 2) * oneMinusAbsS - (${cubicCoeffA} + 3)) * oneMinusAbsS * oneMinusAbsS + 1;\n coeffs[3] = ((${cubicCoeffA} * twoMinusAbsS - 5 * ${cubicCoeffA}) * twoMinusAbsS + 8 * ${cubicCoeffA}) * twoMinusAbsS - 4 * ${cubicCoeffA};\n return coeffs;\n }\n\n fn cubicInterpolation1D(x: array<${dType}, 4>, coefs: array<${dType}, 4>) -> ${dType} {\n var coefsSum: ${dType} = coefs[0] + coefs[1] + coefs[2] + coefs[3];\n return (x[0] * coefs[0] + x[1] * coefs[1]+ x[2] * coefs[2]+ x[3] * coefs[3]) / coefsSum;\n }\n\n fn bicubicInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n var input_indices: ${input.type.indices} = output_indices;\n return colCubicInterpolation(input_indices, output_indices);\n }\n `;\n };\n trilinearInterpolation = (input, output, inputShape, useExtrapolation, extrapolationValue) => {\n const isNchw = true;\n const [batchIdx, depthIdx, heightIdx, widthIdx, channelIdx] = inputShape.length === 3 ? [-1, 0, 1, 2, -1] : isNchw ? [0, 2, 3, 4, 1] : [0, 1, 2, 3, 4];\n const dType = input.type.value;\n return `\n fn getInputValue(batch: u32, channel: u32, depth:u32, height: u32, width: u32) -> ${dType} {\n var input_indices: ${input.type.indices};\n ${input.indicesSet("input_indices", depthIdx, `max(0, min(depth, ${inputShape[depthIdx]} - 1))`)};\n ${input.indicesSet("input_indices", heightIdx, `max(0, min(height, ${inputShape[heightIdx]} - 1))`)};\n ${input.indicesSet("input_indices", widthIdx, `max(0, min(width, ${inputShape[widthIdx]} - 1))`)};\n ${setChannelAndBatchIndices(input, channelIdx, batchIdx, 3)}\n return ${input.getByIndices("input_indices")};\n }\n\n fn trilinearInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices);\n var depth:${dType} = originalIndices[${depthIdx}];\n var height:${dType} = originalIndices[${heightIdx}];\n var width:${dType} = originalIndices[${widthIdx}];\n ${useExtrapolation ? `if (depth < 0 || depth > (${inputShape[depthIdx]} - 1) || height < 0 || height > (${inputShape[heightIdx]} - 1) || width < 0 || (width > ${inputShape[widthIdx]} - 1)) {\n return ${extrapolationValue};\n }` : ""};\n\n depth = max(0, min(depth, ${inputShape[depthIdx]} - 1));\n height = max(0, min(height, ${inputShape[heightIdx]} - 1));\n width = max(0, min(width, ${inputShape[widthIdx]} - 1));\n var depth1: u32 = u32(depth);\n var height1: u32 = u32(height);\n var width1: u32 = u32(width);\n var depth2: u32 = u32(depth + 1);\n var height2: u32 = u32(height + 1);\n var width2: u32 = u32(width + 1);\n var channel: u32 = ${inputShape.length > 3 ? `u32(originalIndices[${channelIdx}])` : "0"};\n var batch: u32 = ${inputShape.length > 3 ? `u32(originalIndices[${batchIdx}])` : "0"};\n\n var x111: ${dType} = getInputValue(batch, channel, depth1, height1, width1);\n var x112: ${dType} = getInputValue(batch, channel, depth1, height1, width2);\n var x121: ${dType} = getInputValue(batch, channel, depth1, height2, width1);\n var x122: ${dType} = getInputValue(batch, channel, depth1, height2, width2);\n var x211: ${dType} = getInputValue(batch, channel, depth2, height1, width1);\n var x212: ${dType} = getInputValue(batch, channel, depth2, height1, width2);\n var x221: ${dType} = getInputValue(batch, channel, depth2, height2, width1);\n var x222: ${dType} = getInputValue(batch, channel, depth2, height2, width2);\n var dx1: ${dType} = abs(depth - ${dType}(depth1));\n var dx2: ${dType} = abs(${dType}(depth2) - depth);\n var dy1: ${dType} = abs(height - ${dType}(height1));\n var dy2: ${dType} = abs(${dType}(height2) - height);\n var dz1: ${dType} = abs(width - ${dType}(width1));\n var dz2: ${dType} = abs(${dType}(width2) - width);\n if (depth1 == depth2) {\n dx1 = 0.5;\n dx2 = 0.5;\n }\n if (height1 == height2) {\n dy1 = 0.5;\n dy2 = 0.5;\n }\n if (width1 == width2) {\n dz1 = 0.5;\n dz2 = 0.5;\n }\n return (x111 * dx2 * dy2 * dz2 + x112 * dx2 * dy2 * dz1 + x121 * dx2 * dy1 *dz2 + x122 * dx2 * dy1 * dz1 +\n x211 * dx1 * dy2 * dz2 + x212 * dx1 * dy2 * dz1 + x221 * dx1 * dy1 *dz2 + x222 * dx1 * dy1 * dz1);\n }`;\n };\n createResizeProgramInfo = (inputTensor, attributes, opsetVersion, scalesInput, sizes, roiInput) => {\n const inputShape = inputTensor.dims;\n const roi = updateRoI(roiInput, attributes.axes, inputShape.length);\n let outputShape = initOutputShape(inputShape, scalesInput, sizes, attributes.axes);\n let scales = scalesInput.slice();\n if (scalesInput.length === 0) {\n scales = inputShape.map((value, index) => value === 0 ? 1 : outputShape[index] / value);\n if (attributes.keepAspectRatioPolicy !== "stretch") {\n outputShape = adjustOutputShape(inputShape, scales, attributes);\n }\n }\n const output = outputVariable("output", inputTensor.dataType, outputShape.length);\n const input = inputVariable("input", inputTensor.dataType, inputShape.length);\n const outputSize = ShapeUtil.size(outputShape);\n const noScale = inputShape.length === outputShape.length && inputShape.every((d, i) => d === outputShape[i]);\n const useExtrapolation = attributes.coordinateTransformMode === "tf_crop_and_resize";\n const extrapolationValue = attributes.extrapolationValue;\n const dataType = input.type.value;\n const getShaderSource = (shaderHelper) => `\n ${noScale ? "" : `\n ${getOriginalCoordinateFromResizedCoordinate(attributes.coordinateTransformMode, dataType)};\n ${(() => {\n switch (attributes.mode) {\n case "nearest":\n return `\n ${checkInputIndices(input, inputShape)};\n ${getNearestPixelFromOriginal(attributes.nearestMode, opsetVersion, dataType)};\n ${calculateInputIndicesFromOutputIndices(\n input,\n output,\n inputShape,\n outputShape,\n scales.length,\n roi.length,\n useExtrapolation\n )};\n `;\n case "linear":\n return `\n ${calculateOriginalIndicesFromOutputIndices(output, inputShape, outputShape, scales.length, roi.length)};\n ${(() => {\n if (inputShape.length === 2 || inputShape.length === 4) {\n return `${bilinearInterpolation(input, output, inputShape, useExtrapolation, extrapolationValue)}`;\n } else if (inputShape.length === 3 || inputShape.length === 5) {\n return `${trilinearInterpolation(input, output, inputShape, useExtrapolation, extrapolationValue)}`;\n } else {\n throw Error("Linear mode only supports input dims 2, 3, 4 and 5 are supported in linear mode.");\n }\n })()};\n `;\n case "cubic":\n return `\n ${(() => {\n if (inputShape.length === 2 || inputShape.length === 4) {\n return `${bicubicInterpolation(\n input,\n output,\n inputShape,\n outputShape,\n scales,\n roi,\n attributes.cubicCoeffA,\n useExtrapolation,\n attributes.extrapolationValue,\n attributes.excludeOutside\n )}`;\n } else {\n throw Error("Cubic mode only supports input dims 2 and 4 are supported in linear mode.");\n }\n })()};\n `;\n default:\n throw Error("Invalid resize mode");\n }\n })()};\n `}\n ${shaderHelper.registerUniform("output_size", "u32").registerUniform("scales", "f32", scales.length).registerUniform("roi", "f32", roi.length).declareVariables(input, output)}\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}\n ${noScale ? "output[global_idx] = input[global_idx];" : `\n let output_indices = ${output.offsetToIndices("global_idx")};\n var input_indices: ${input.type.indices};\n ${(() => {\n switch (attributes.mode) {\n case "nearest":\n return `input_indices = calculateInputIndicesFromOutputIndices(output_indices);\n if (checkInputIndices(input_indices)) {\n output[global_idx] = ${input.getByIndices("input_indices")};\n } else {\n output[global_idx] = ${attributes.extrapolationValue};\n }`;\n case "linear":\n return `output[global_idx] = ${inputShape.length === 2 || inputShape.length === 4 ? "bilinearInterpolation" : "trilinearInterpolation"}(output_indices);`;\n case "cubic":\n return "output[global_idx] = bicubicInterpolation(output_indices);";\n default:\n throw Error(`Unsupported resize mode: ${attributes.mode}`);\n }\n })()};\n`}\n }`;\n return {\n name: "Resize",\n shaderCache: {\n hint: `${attributes.cacheKey}|${opsetVersion}|${scales.length > 0 ? scales : ""}|${sizes.length > 0 ? sizes : ""}|${roi.length > 0 ? roi : ""}|${noScale}|${inputShape}`,\n inputDependencies: ["rank"]\n },\n getShaderSource,\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: inputTensor.dataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms: [\n { type: 12 /* uint32 */, data: outputSize },\n { type: 1 /* float */, data: scales },\n { type: 1 /* float */, data: roi },\n ...createTensorShapeVariables(inputShape, outputShape)\n ]\n })\n };\n };\n getOpsetVersionFromCustomDataBuffer = (context) => {\n const customDataBuffer = context.customDataBuffer;\n const customDataBuffer32 = new Uint32Array(customDataBuffer, customDataBuffer.byteOffset, 1);\n const opsetVersion = customDataBuffer32[0];\n return opsetVersion;\n };\n resize = (context, attributes) => {\n const scales = [];\n const sizes = [];\n const roi = [];\n const opsetVersion = getOpsetVersionFromCustomDataBuffer(context);\n if (attributes.antialias !== 0) {\n throw Error("Only default value (0) for Antialias attribute is supported");\n }\n validateInputs21(context.inputs, attributes, opsetVersion, scales, sizes, roi);\n context.compute(\n createResizeProgramInfo(context.inputs[0], attributes, opsetVersion, scales, sizes, roi),\n { inputs: [0] }\n );\n };\n parseResizeAttributes = (attributes) => {\n const antialias = attributes.antialias;\n const axes = attributes.axes;\n const coordinateTransformMode = attributes.coordinateTransformMode;\n const cubicCoeffA = attributes.cubicCoeffA;\n const excludeOutside = attributes.excludeOutside !== 0;\n const extrapolationValue = attributes.extrapolationValue;\n const keepAspectRatioPolicy = attributes.keepAspectRatioPolicy;\n const mode = attributes.mode;\n const nearestMode = attributes.nearestMode === "" ? "simple" : attributes.nearestMode;\n return createAttributeWithCacheKey({\n antialias,\n axes,\n coordinateTransformMode,\n cubicCoeffA,\n excludeOutside,\n extrapolationValue,\n keepAspectRatioPolicy,\n mode,\n nearestMode\n });\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/rotary-embedding.ts\n var validateInputs22, createRotaryEmbeddingProgramInfo, rotaryEmbedding;\n var init_rotary_embedding = __esm({\n "web/lib/wasm/jsep/webgpu/ops/rotary-embedding.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_attribute_with_cache_key();\n init_common();\n validateInputs22 = (inputs, attributes) => {\n const [input, positionIds, cosCache, sinCache] = inputs;\n const { numHeads, rotaryEmbeddingDim } = attributes;\n if (input.dims.length !== 3 && input.dims.length !== 4) {\n throw new Error(`Input \'x\' is expected to have 3 or 4 dimensions, got ${input.dims.length}`);\n }\n if (!ShapeUtil.areEqual(positionIds.dims, []) && !ShapeUtil.areEqual(positionIds.dims, [1]) && positionIds.dims.length !== 2) {\n throw new Error(`Input \'position_ids\' is expected to have 0, 1, or 2 dimensions, got ${positionIds.dims.length}`);\n }\n if (cosCache.dims.length !== 2) {\n throw new Error(`Input \'cos_cache\' is expected to have 2 dimensions, got ${cosCache.dims.length}`);\n }\n if (sinCache.dims.length !== 2) {\n throw new Error(`Input \'sin_cache\' is expected to have 2 dimensions, got ${sinCache.dims.length}`);\n }\n if (!ShapeUtil.areEqual(cosCache.dims, sinCache.dims)) {\n throw new Error("Inputs \'cos_cache\' and \'sin_cache\' are expected to have the same shape");\n }\n if (rotaryEmbeddingDim > 0 && numHeads === 0) {\n throw new Error("num_heads must be provided if rotary_embedding_dim is specified");\n }\n const batchSize = input.dims[0];\n const sequenceLength = input.dims[input.dims.length - 2];\n const maxSequenceLength = cosCache.dims[0];\n const hiddenSize = ShapeUtil.sizeFromDimension(input.dims, 1) / sequenceLength;\n const headSize = rotaryEmbeddingDim === 0 ? cosCache.dims[1] * 2 : hiddenSize / numHeads;\n if (rotaryEmbeddingDim > headSize) {\n throw new Error("rotary_embedding_dim must be less than or equal to head_size");\n }\n if (positionIds.dims.length === 2) {\n if (batchSize !== positionIds.dims[0]) {\n throw new Error(`Input \'position_ids\' dimension 0 should be of size batch_size, got ${positionIds.dims[0]}`);\n }\n if (sequenceLength !== positionIds.dims[1]) {\n throw new Error(`Input \'position_ids\' dimension 1 should be of size sequence_length, got ${positionIds.dims[1]}`);\n }\n }\n if (headSize / 2 !== cosCache.dims[1] && rotaryEmbeddingDim / 2 !== cosCache.dims[1]) {\n throw new Error(`Input \'cos_cache\' dimension 1 should be same as head_size / 2 or rotary_embedding_dim / 2, got ${cosCache.dims[1]}`);\n }\n if (sequenceLength > maxSequenceLength) {\n throw new Error("Updating cos_cache and sin_cache in RotaryEmbedding is not currently supported");\n }\n };\n createRotaryEmbeddingProgramInfo = (inputs, attributes) => {\n const { interleaved, numHeads, rotaryEmbeddingDim, scale } = attributes;\n const batchSize = inputs[0].dims[0];\n const batchStride = ShapeUtil.sizeFromDimension(inputs[0].dims, 1);\n const sequenceLength = inputs[0].dims[inputs[0].dims.length - 2];\n const hiddenSize = batchStride / sequenceLength;\n const halfRotaryEmbeddingDim = inputs[2].dims[1];\n const headSize = rotaryEmbeddingDim === 0 ? halfRotaryEmbeddingDim * 2 : hiddenSize / numHeads;\n const globalShape = new Array(batchSize, sequenceLength, hiddenSize / headSize, headSize - halfRotaryEmbeddingDim);\n const globalStrides = ShapeUtil.computeStrides(globalShape);\n const programUniforms = [\n { type: 1 /* float */, data: scale },\n { type: 12 /* uint32 */, data: globalShape },\n { type: 12 /* uint32 */, data: globalStrides },\n // strides for addressing the input/output tensor, in permutated order to align with the unfolded global index,\n // i.e. BSNH\n ...inputs[0].dims.length === 3 ? new Array({ type: 12 /* uint32 */, data: [batchStride, hiddenSize, headSize, 1] }) : [],\n ...inputs[0].dims.length === 4 ? new Array(\n { type: 12 /* uint32 */, data: [batchStride, headSize, sequenceLength * headSize, 1] }\n ) : [],\n ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims, inputs[2].dims, inputs[3].dims, inputs[0].dims)\n ];\n const getShaderSource = (shaderHelper) => {\n const input = inputVariable("input", inputs[0].dataType, inputs[0].dims.length);\n const positionIds = inputVariable("position_ids", inputs[1].dataType, inputs[1].dims.length);\n const cosCache = inputVariable("cos_cache", inputs[2].dataType, inputs[2].dims.length);\n const sinCache = inputVariable("sin_cache", inputs[3].dataType, inputs[3].dims.length);\n const output = outputVariable("output", inputs[0].dataType, inputs[0].dims.length);\n shaderHelper.registerUniforms([\n { name: "scale", type: "f32" },\n { name: "global_shape", type: "u32", length: globalShape.length },\n { name: "global_strides", type: "u32", length: globalStrides.length },\n { name: "input_output_strides", type: "u32", length: globalStrides.length }\n ]);\n return `\n ${shaderHelper.declareVariables(input, positionIds, cosCache, sinCache, output)}\n\n ${shaderHelper.mainStart(WORKGROUP_SIZE)}\n let half_rotary_emb_dim = uniforms.${cosCache.name}_shape[1];\n let bsnh = global_idx / uniforms.global_strides % uniforms.global_shape;\n let size = uniforms.global_shape[0] * uniforms.global_strides[0];\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("size")}\n\n if (bsnh[3] < half_rotary_emb_dim) {\n let position_ids_idx =\n ${positionIds.broadcastedIndicesToOffset("bsnh.xy", outputVariable("", positionIds.type.tensor, 2))};\n let position_id =\n u32(${positionIds.getByOffset("position_ids_idx")}) + select(0, bsnh[1], position_ids_idx == 0);\n let i = dot(bsnh, uniforms.input_output_strides) + select(0, bsnh[3], ${interleaved});\n let j = i + select(half_rotary_emb_dim, 1, ${interleaved});\n let re = ${input.getByOffset("i")} * ${cosCache.get("position_id", "bsnh[3]")} -\n ${input.getByOffset("j")} * ${sinCache.get("position_id", "bsnh[3]")};\n ${output.setByOffset("i", "re")}\n let im = ${input.getByOffset("i")} * ${sinCache.get("position_id", "bsnh[3]")} +\n ${input.getByOffset("j")} * ${cosCache.get("position_id", "bsnh[3]")};\n ${output.setByOffset("j", "im")}\n } else {\n let k = dot(bsnh, uniforms.input_output_strides) + half_rotary_emb_dim;\n ${output.setByOffset("k", input.getByOffset("k"))}\n }\n }`;\n };\n return {\n name: "RotaryEmbedding",\n shaderCache: {\n hint: createAttributeWithCacheKey({\n interleaved\n }).cacheKey,\n inputDependencies: ["rank", "rank", "rank", "rank"]\n },\n getShaderSource,\n getRunData: () => ({\n outputs: [{ dims: inputs[0].dims, dataType: inputs[0].dataType }],\n dispatchGroup: { x: Math.ceil(ShapeUtil.size(globalShape) / WORKGROUP_SIZE) },\n programUniforms\n })\n };\n };\n rotaryEmbedding = (context, attributes) => {\n validateInputs22(context.inputs, attributes);\n context.compute(createRotaryEmbeddingProgramInfo(context.inputs, attributes));\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/skip-layer-norm.ts\n var validateInputs23, createSkipLayerNormProgramInfo, skipLayerNorm;\n var init_skip_layer_norm = __esm({\n "web/lib/wasm/jsep/webgpu/ops/skip-layer-norm.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_common();\n validateInputs23 = (inputs) => {\n if (!inputs || inputs.length < 3) {\n throw new Error("layerNorm requires at least 3 inputs.");\n }\n const input = inputs[0];\n const skip = inputs[1];\n const gamma = inputs[2];\n if (input.dataType !== skip.dataType || input.dataType !== gamma.dataType) {\n throw new Error("All inputs must have the same data type");\n }\n if (input.dims.length !== 3 && input.dims.length !== 2) {\n throw new Error("Input must be 2D or 3D");\n }\n if (skip.dims.length !== 3 && skip.dims.length !== 2) {\n throw new Error("Skip must be 2D or 3D");\n }\n const hiddenSize = input.dims[input.dims.length - 1];\n const sequenceLength = input.dims[input.dims.length - 2];\n if (skip.dims[skip.dims.length - 1] !== hiddenSize) {\n throw new Error("Skip must have the same hidden size as input");\n }\n if (skip.dims[skip.dims.length - 2] !== sequenceLength) {\n throw new Error("Skip must have the same sequence length as input");\n }\n if (gamma.dims.length !== 1) {\n throw new Error("Gamma must be 1D");\n }\n if (gamma.dims[gamma.dims.length - 1] !== hiddenSize) {\n throw new Error("Gamma must have the same hidden size as input");\n }\n if (inputs.length > 3) {\n const beta = inputs[3];\n if (beta.dims.length !== 1) {\n throw new Error("Beta must be 1D");\n }\n if (beta.dims[beta.dims.length - 1] !== hiddenSize) {\n throw new Error("Beta must have the same hidden size as input");\n }\n }\n if (inputs.length > 4) {\n const bias = inputs[4];\n if (bias.dims.length !== 1) {\n throw new Error("Bias must be 1D");\n }\n if (bias.dims[bias.dims.length - 1] !== hiddenSize) {\n throw new Error("Bias must have the same hidden size as input");\n }\n }\n };\n createSkipLayerNormProgramInfo = (inputs, attributes, outputCount, isTraining) => {\n const simplified = attributes.simplified;\n const inputShape = inputs[0].dims;\n const inputSize = ShapeUtil.size(inputShape);\n const outputShape = inputShape;\n const outputSize = inputSize;\n const hiddenSize = inputShape.slice(-1)[0];\n const meanInvStdDevDim = isTraining ? inputShape.slice(0, -1).concat(1) : [];\n const hasBetaInput = !simplified && inputs.length > 3;\n const hasBiasInput = inputs.length > 4;\n const hasMeanOutput = isTraining && outputCount > 1;\n const hasInvStdDevOutput = isTraining && outputCount > 2;\n const hasInputSkipBiasSumOutput = outputCount > 3;\n const components = getMaxComponents(hiddenSize);\n const programUniforms = [\n { type: 12 /* uint32 */, data: outputSize },\n { type: 12 /* uint32 */, data: components },\n { type: 12 /* uint32 */, data: hiddenSize },\n { type: 1 /* float */, data: attributes.epsilon }\n ];\n const getShaderSource = (shaderHelper) => {\n const uniformsArray = [\n { name: "output_size", type: "u32" },\n { name: "components", type: "u32" },\n { name: "hidden_size", type: "u32" },\n { name: "epsilon", type: "f32" }\n ];\n const variables = [\n inputVariable("x", inputs[0].dataType, inputs[0].dims, components),\n inputVariable("skip", inputs[1].dataType, inputs[1].dims, components),\n inputVariable("gamma", inputs[2].dataType, inputs[2].dims, components)\n ];\n if (hasBetaInput) {\n variables.push(inputVariable("beta", inputs[3].dataType, inputs[3].dims, components));\n }\n if (hasBiasInput) {\n variables.push(inputVariable("bias", inputs[4].dataType, inputs[4].dims, components));\n }\n variables.push(outputVariable("output", inputs[0].dataType, outputShape, components));\n if (hasMeanOutput) {\n variables.push(outputVariable("mean_output", 1 /* float */, meanInvStdDevDim));\n }\n if (hasInvStdDevOutput) {\n variables.push(outputVariable("inv_std_output", 1 /* float */, meanInvStdDevDim));\n }\n if (hasInputSkipBiasSumOutput) {\n variables.push(outputVariable("input_skip_bias_sum", inputs[0].dataType, outputShape, components));\n }\n const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n return `\n\n ${shaderHelper.registerUniforms(uniformsArray).declareVariables(...variables)}\n\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size / uniforms.hidden_size")}\n let hidden_size_vectorized: u32 = uniforms.hidden_size / uniforms.components;\n let offset = global_idx * hidden_size_vectorized;\n var sum = ${fillVector("f32", components)};\n var squareSum = ${fillVector("f32", components)};\n for (var i: u32 = 0; i < hidden_size_vectorized; i++) {\n let skip_value = skip[offset + i];\n let bias_value = ${hasBiasInput ? "bias[i]" : dataType + "(0.0)"};\n let input_value = x[offset + i];\n let value = input_value + skip_value + bias_value;\n ${hasInputSkipBiasSumOutput ? "input_skip_bias_sum[offset + i] = value;" : ""}\n output[offset + i] = value;\n let f32_value = ${castToF32(dataType, components, "value")};\n sum += f32_value;\n squareSum += f32_value * f32_value;\n }\n let mean = ${sumVector("sum", components)} / f32(uniforms.hidden_size);\n let inv_std_dev = inverseSqrt(${sumVector("squareSum", components)} / f32(uniforms.hidden_size) ${simplified ? "" : "- mean * mean"} + uniforms.epsilon);\n ${hasMeanOutput ? "mean_output[global_idx] = mean;" : ""}\n ${hasInvStdDevOutput ? "inv_std_output[global_idx] = inv_std_dev;" : ""}\n for (var i: u32 = 0; i < hidden_size_vectorized; i++) {\n output[offset + i] = (output[offset + i] ${simplified ? "" : `- ${dataType}(mean)`}) * ${dataType}(inv_std_dev) * gamma[i] ${hasBetaInput ? "+ beta[i]" : ""};\n }\n }`;\n };\n const outputs = [{ dims: outputShape, dataType: inputs[0].dataType }];\n if (outputCount > 1) {\n outputs.push({ dims: meanInvStdDevDim, dataType: 1 /* float */ });\n }\n if (outputCount > 2) {\n outputs.push({ dims: meanInvStdDevDim, dataType: 1 /* float */ });\n }\n if (outputCount > 3) {\n outputs.push({ dims: inputShape, dataType: inputs[0].dataType });\n }\n return {\n name: "SkipLayerNormalization",\n shaderCache: {\n hint: `${components};${hasMeanOutput};${hasInvStdDevOutput};${hasInputSkipBiasSumOutput}`,\n inputDependencies: inputs.map((_input, _index) => "type")\n },\n getShaderSource,\n getRunData: () => ({ outputs, dispatchGroup: { x: Math.ceil(outputSize / hiddenSize / 64) }, programUniforms })\n };\n };\n skipLayerNorm = (context, attributes) => {\n const isTraining = false;\n validateInputs23(context.inputs);\n const outputs = [0];\n if (context.outputCount > 1) {\n outputs.push(isTraining ? 1 : -3);\n }\n if (context.outputCount > 2) {\n outputs.push(isTraining ? 2 : -3);\n }\n if (context.outputCount > 3) {\n outputs.push(3);\n }\n context.compute(\n createSkipLayerNormProgramInfo(context.inputs, attributes, context.outputCount, isTraining),\n { outputs }\n );\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/slice.ts\n var validateInputs24, readInput, createSliceAttributesFromInputs, fixStartEndValues, calculateInputIndicesImpl, createSliceProgramInfo, slice, parseSliceAttributes;\n var init_slice = __esm({\n "web/lib/wasm/jsep/webgpu/ops/slice.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_attribute_with_cache_key();\n init_common();\n validateInputs24 = (inputs, attributes) => {\n if (!inputs || inputs.length < 1) {\n throw new Error("too few inputs");\n }\n if (attributes.axes.length !== 0) {\n if (attributes.axes.length !== attributes.starts.length || attributes.axes.length !== attributes.ends.length) {\n throw new Error("axes, starts and ends must have the same length");\n }\n } else if (attributes.starts.length !== attributes.ends.length) {\n throw new Error("starts and ends must have the same length");\n }\n inputs.slice(1).forEach((_, idx) => {\n if (inputs[idx + 1].dataType !== 6 /* int32 */ && inputs[idx + 1].dataType !== 7 /* int64 */) {\n throw new Error(`Input ${idx} must be an array of int32 or int64`);\n }\n });\n };\n readInput = (inputs, idx) => {\n const input = [];\n if (inputs.length > idx) {\n if (inputs[idx].dataType === 7 /* int64 */) {\n inputs[idx].getBigInt64Array().forEach((v) => input.push(Number(v)));\n } else if (inputs[idx].dataType === 6 /* int32 */) {\n inputs[idx].getInt32Array().forEach((v) => input.push(Number(v)));\n } else {\n throw new Error(`Input ${idx} must be an array of int32 or int64`);\n }\n }\n return input;\n };\n createSliceAttributesFromInputs = (inputs, attributes) => {\n if (inputs.length > 1) {\n const starts = readInput(inputs, 1);\n const ends = readInput(inputs, 2);\n let axes = readInput(inputs, 3);\n if (axes.length === 0) {\n axes = [...Array(inputs[0].dims.length).keys()];\n }\n return createAttributeWithCacheKey({ starts, ends, axes });\n } else {\n return attributes;\n }\n };\n fixStartEndValues = (value, index, inputShape, axes, steps) => {\n let newValue = value;\n if (value < 0) {\n newValue += inputShape[axes[index]];\n }\n if (steps[index] < 0) {\n return Math.max(0, Math.min(newValue, inputShape[axes[index]] - 1));\n } else {\n return Math.max(0, Math.min(newValue, inputShape[axes[index]]));\n }\n };\n calculateInputIndicesImpl = (input, output, inputShape) => `fn calculateInputIndices(output_indices: ${output.type.indices}) -> ${input.type.indices} {\n var input_indices: ${input.type.indices};\n var carry = 0u;\n for (var i = ${inputShape.length}; i >= 0; i--) {\n let input_shape_i = ${getElementAt("uniforms.input_shape", "i", inputShape.length)};\n let steps_i = ${getElementAt("uniforms.steps", "i", inputShape.length)};\n let signs_i = ${getElementAt("uniforms.signs", "i", inputShape.length)};\n let starts_i = ${getElementAt("uniforms.starts", "i", inputShape.length)};\n var output_index = ${output.indicesGet("output_indices", "i")};\n var input_index = output_index * steps_i + starts_i + carry;\n carry = input_index / input_shape_i;\n input_index = input_index % input_shape_i;\n if (signs_i < 0) {\n input_index = input_shape_i - input_index - 1u + starts_i;\n }\n ${input.indicesSet("input_indices", "i", "input_index")};\n }\n return input_indices;\n }`;\n createSliceProgramInfo = (inputs, attributes) => {\n const inputShape = inputs[0].dims;\n const inputSize = ShapeUtil.size(inputShape);\n const axes = attributes.axes.length > 0 ? ShapeUtil.normalizeAxes(attributes.axes, inputShape.length) : [...Array(inputShape.length).keys()];\n let steps = readInput(inputs, 4);\n steps.forEach((step) => step !== 0 || (() => {\n throw new Error("step cannot be 0");\n }));\n if (steps.length === 0) {\n steps = Array(axes.length).fill(1);\n }\n const starts = attributes.starts.map((start, i) => fixStartEndValues(start, i, inputShape, axes, steps));\n const ends = attributes.ends.map((end, i) => fixStartEndValues(end, i, inputShape, axes, steps));\n if (axes.length !== starts.length || axes.length !== ends.length) {\n throw new Error("start, ends and axes should have the same number of elements");\n }\n if (axes.length !== inputShape.length) {\n for (let i = 0; i < inputShape.length; ++i) {\n if (!axes.includes(i)) {\n starts.splice(i, 0, 0);\n ends.splice(i, 0, inputShape[i]);\n steps.splice(i, 0, 1);\n }\n }\n }\n const signs = steps.map((step) => Math.sign(step));\n steps.forEach((step, i, array) => {\n if (step < 0) {\n const numSteps = (ends[i] - starts[i]) / step;\n const newEnd = starts[i];\n const newStart = newEnd + numSteps * steps[i];\n starts[i] = newStart;\n ends[i] = newEnd;\n array[i] = -step;\n }\n });\n const outputShape = inputShape.slice(0);\n axes.forEach((axis, _) => {\n outputShape[axis] = Math.ceil((ends[axis] - starts[axis]) / steps[axis]);\n });\n const outputTensorInfo = { dims: outputShape, dataType: inputs[0].dataType };\n const output = outputVariable("output", inputs[0].dataType, outputShape.length);\n const input = inputVariable("input", inputs[0].dataType, inputs[0].dims.length);\n const outputSize = ShapeUtil.size(outputShape);\n const uniforms = [\n { name: "outputSize", type: "u32" },\n { name: "starts", type: "u32", length: starts.length },\n { name: "signs", type: "i32", length: signs.length },\n { name: "steps", type: "u32", length: steps.length }\n ];\n const programUniforms = [\n { type: 12 /* uint32 */, data: outputSize },\n { type: 12 /* uint32 */, data: starts },\n { type: 6 /* int32 */, data: signs },\n { type: 12 /* uint32 */, data: steps },\n ...createTensorShapeVariables(inputs[0].dims, outputShape)\n ];\n const getShaderSource = (shaderHelper) => `\n ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)}\n ${calculateInputIndicesImpl(input, output, inputShape)}\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}\n let output_indices = ${output.offsetToIndices("global_idx")};\n let input_indices = calculateInputIndices(output_indices);\n ${output.setByOffset("global_idx", input.getByIndices("input_indices"))}\n }`;\n return {\n name: "Slice",\n shaderCache: { hint: `${signs.length}_${starts.length}_${steps.length}`, inputDependencies: ["rank"] },\n getShaderSource,\n getRunData: () => ({\n outputs: [outputTensorInfo],\n dispatchGroup: { x: Math.ceil(\n inputSize / 64\n /* workgroup size */\n ) },\n programUniforms\n })\n };\n };\n slice = (context, attributes) => {\n validateInputs24(context.inputs, attributes);\n const updatedAttributes = createSliceAttributesFromInputs(context.inputs, attributes);\n context.compute(createSliceProgramInfo(context.inputs, updatedAttributes), { inputs: [0] });\n };\n parseSliceAttributes = (attributes) => {\n const starts = attributes.starts;\n const ends = attributes.ends;\n const axes = attributes.axes;\n return createAttributeWithCacheKey({ starts, ends, axes });\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/softmax.ts\n var validateInputs25, createSoftmaxProgramInfo, softmax, parseSoftmaxAttributes;\n var init_softmax = __esm({\n "web/lib/wasm/jsep/webgpu/ops/softmax.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_attribute_with_cache_key();\n init_common();\n validateInputs25 = (inputs) => {\n if (!inputs || inputs.length !== 1) {\n throw new Error("Softmax op requires 1 input.");\n }\n };\n createSoftmaxProgramInfo = (input, attributes) => {\n const shape = input.dims;\n const outputSize = ShapeUtil.size(shape);\n const WG = 64;\n let axis = attributes.axis;\n if (axis < 0) {\n axis = shape.length + axis;\n }\n if (axis < shape.length - 1) {\n throw new Error("softmax only supports last axis for now.");\n }\n const cols = shape[axis];\n const rows = outputSize / cols;\n const components = getMaxComponents(cols);\n const packedCols = cols / components;\n const maxVector = (name, components2) => {\n if (components2 === 4) {\n return `max(max(${name}.x, ${name}.y), max(${name}.z, ${name}.w))`;\n } else if (components2 === 2) {\n return `max(${name}.x, ${name}.y)`;\n } else if (components2 === 3) {\n return `max(max(${name}.x, ${name}.y), ${name}.z)`;\n }\n return name;\n };\n const x = inputVariable("x", input.dataType, input.dims, components);\n const output = outputVariable("result", input.dataType, input.dims, components);\n const valueType = x.type.value;\n const threadMaxDecl = tensorTypeToWsglStorageType(input.dataType) === "f32" ? `var threadMax = ${valueType}(-3.402823e+38f);` : `var threadMax = ${valueType}(-65504.0h);`;\n const getShaderSource = (shaderHelper) => `\n var rowMaxShared : ${valueType};\n var rowSumShared : ${valueType};\n var threadShared : array<${valueType}, ${WG}>;\n\n fn getValue(row: i32, col: i32, row_stride: i32) -> ${valueType} {\n let index = row * row_stride + col;\n return x[index];\n }\n\n fn setValue(row: i32, col: i32, row_stride: i32, value: ${valueType}) {\n let index = row * row_stride + col;\n result[index] = value;\n }\n ${shaderHelper.registerUniform("packedCols", "i32").declareVariables(x, output)}\n ${shaderHelper.mainStart()}\n let gindex = i32(global_idx);\n let lindex = i32(local_idx);\n const wg = ${WG};\n let row = gindex / wg;\n let cols = uniforms.packedCols;\n let row_stride : i32 = uniforms.packedCols;\n\n // find the rows max\n ${threadMaxDecl}\n for (var col = lindex; col < cols; col += wg) {\n let value = getValue(row, col, row_stride);\n threadMax = max(threadMax, value);\n }\n if (lindex < cols) {\n threadShared[lindex] = threadMax;\n }\n workgroupBarrier();\n\n var reduceSize = min(cols, wg);\n for (var currSize = reduceSize >> 1; currSize > 0; currSize = reduceSize >> 1) {\n reduceSize = currSize + (reduceSize & 1);\n if (lindex < currSize) {\n threadShared[lindex] = max(threadShared[lindex], threadShared[lindex + reduceSize]);\n }\n workgroupBarrier();\n }\n if (lindex == 0) {\n rowMaxShared = ${valueType}(${maxVector("threadShared[0]", components)});\n }\n workgroupBarrier();\n\n // find the rows sum\n var threadSum = ${valueType}(0.0);\n for (var col = lindex; col < cols; col += wg) {\n let subExp = exp(getValue(row, col, row_stride) - rowMaxShared);\n threadSum += subExp;\n }\n threadShared[lindex] = threadSum;\n workgroupBarrier();\n\n for (var currSize = wg >> 1; currSize > 0; currSize = currSize >> 1) {\n if (lindex < currSize) {\n threadShared[lindex] = threadShared[lindex] + threadShared[lindex + currSize];\n }\n workgroupBarrier();\n }\n if (lindex == 0) {\n rowSumShared = ${valueType}(${sumVector("threadShared[0]", components)});\n }\n workgroupBarrier();\n\n // calculate final value for each element in the row\n for (var col = lindex; col < cols; col += wg) {\n let value = exp(getValue(row, col, row_stride) - rowMaxShared) / rowSumShared;\n setValue(row, col, row_stride, value);\n }\n }`;\n return {\n name: "Softmax",\n shaderCache: { hint: `${components}`, inputDependencies: ["type"] },\n getRunData: () => ({\n outputs: [{ dims: shape, dataType: input.dataType }],\n dispatchGroup: { x: rows },\n programUniforms: [{ type: 6 /* int32 */, data: packedCols }]\n }),\n getShaderSource\n };\n };\n softmax = (context, attributes) => {\n validateInputs25(context.inputs);\n context.compute(createSoftmaxProgramInfo(context.inputs[0], attributes));\n };\n parseSoftmaxAttributes = (attributes) => createAttributeWithCacheKey({ axis: attributes.axis });\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/split.ts\n var validateInputs26, createSplitAttributesFromInputs, calculateOutputIndexImpl, writeBufferDataImpl, createSplitProgramInfo, split, parseSplitAttributes;\n var init_split = __esm({\n "web/lib/wasm/jsep/webgpu/ops/split.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_attribute_with_cache_key();\n init_common();\n validateInputs26 = (inputs) => {\n if (!inputs || inputs.length < 1) {\n throw new Error("too few inputs");\n }\n };\n createSplitAttributesFromInputs = (inputs, attributes) => {\n const splitSizes = [];\n let numOutputs = attributes.numOutputs;\n if (inputs[1].dims[0] > 0) {\n inputs[1].getBigInt64Array().forEach((v) => splitSizes.push(Number(v)));\n numOutputs = splitSizes.length;\n }\n return createAttributeWithCacheKey({ numOutputs, axis: attributes.axis, splitSizes });\n };\n calculateOutputIndexImpl = (numberOfTensors) => `\nfn calculateOutputIndex(index: u32) -> u32 {\n for (var i: u32 = 0u; i < ${numberOfTensors}u; i += 1u ) {\n if (index < ${getElementAt("uniforms.size_in_split_axis", "i", numberOfTensors)}) {\n return i;\n }\n }\n return ${numberOfTensors}u;\n}`;\n writeBufferDataImpl = (outputs) => {\n const numberOfTensors = outputs.length;\n const codeLines = [];\n for (let i = 0; i < numberOfTensors; ++i) {\n const returnSnippet = outputs[i].setByIndices("indices", "input[global_idx]");\n if (numberOfTensors === 1) {\n codeLines.push(returnSnippet);\n } else if (i === 0) {\n codeLines.push(`if (output_number == ${i}u) { ${returnSnippet} }`);\n } else if (i === numberOfTensors - 1) {\n codeLines.push(`else { ${returnSnippet} }`);\n } else {\n codeLines.push(`else if (output_number == ${i}) { ${returnSnippet} }`);\n }\n }\n return `\n fn writeBufferData(output_number: u32, indices: ${outputs[0].type.indices}, global_idx: u32) {\n ${codeLines.join("\\n")}\n }`;\n };\n createSplitProgramInfo = (inputs, attributes) => {\n const inputShape = inputs[0].dims;\n const inputSize = ShapeUtil.size(inputShape);\n const dataType = inputs[0].dataType;\n const axis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);\n const outputs = new Array(attributes.numOutputs);\n const input = inputVariable("input", dataType, inputShape.length);\n const sizeInSplitAxis = new Array(attributes.numOutputs);\n const outputsTensorInfo = [];\n const outputShapes = [];\n let previousSum = 0;\n const programUniforms = [{ type: 12 /* uint32 */, data: inputSize }];\n for (let i = 0; i < attributes.numOutputs; i++) {\n previousSum += attributes.splitSizes[i];\n sizeInSplitAxis[i] = previousSum;\n const outputShape = inputShape.slice();\n outputShape[attributes.axis] = attributes.splitSizes[i];\n outputShapes.push(outputShape);\n outputs[i] = outputVariable(`output${i}`, dataType, outputShape.length);\n outputsTensorInfo.push({ dims: outputShapes[i], dataType: inputs[0].dataType });\n }\n programUniforms.push(\n { type: 12 /* uint32 */, data: sizeInSplitAxis },\n ...createTensorShapeVariables(inputShape, ...outputShapes)\n );\n const getShaderSource = (shaderHelper) => `\n ${shaderHelper.registerUniform("input_size", "u32").registerUniform("size_in_split_axis", "u32", sizeInSplitAxis.length).declareVariables(input, ...outputs)}\n ${calculateOutputIndexImpl(sizeInSplitAxis.length)}\n ${writeBufferDataImpl(outputs)}\n\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.input_size")}\n\n var indices = ${input.offsetToIndices("global_idx")};\n var index = ${input.indicesGet("indices", axis)};\n let output_number = calculateOutputIndex(index);\n if (output_number != 0) {\n index -= ${getElementAt("uniforms.size_in_split_axis", "output_number - 1u", sizeInSplitAxis.length)};\n ${input.indicesSet("indices", axis, "index")};\n }\n writeBufferData(output_number, indices, global_idx);\n }`;\n return {\n name: "Split",\n shaderCache: { hint: attributes.cacheKey, inputDependencies: ["rank"] },\n getShaderSource,\n getRunData: () => ({\n outputs: outputsTensorInfo,\n dispatchGroup: { x: Math.ceil(\n inputSize / 64\n /* workgroup size */\n ) },\n programUniforms\n })\n };\n };\n split = (context, attributes) => {\n validateInputs26(context.inputs);\n const updatedAttributes = context.inputs.length === 1 ? attributes : createSplitAttributesFromInputs(context.inputs, attributes);\n context.compute(createSplitProgramInfo(context.inputs, updatedAttributes), { inputs: [0] });\n };\n parseSplitAttributes = (attributes) => {\n const axis = attributes.axis;\n const splitSizes = attributes.splitSizes;\n const numOutputs = attributes.numOutputs < 0 ? splitSizes.length : attributes.numOutputs;\n if (numOutputs !== splitSizes.length) {\n throw new Error("numOutputs and splitSizes lengh must be equal");\n }\n return createAttributeWithCacheKey({ axis, numOutputs, splitSizes });\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/tile.ts\n var getRepeats, validateInputs27, getOutputShape2, createTileProgramInfo, tile;\n var init_tile = __esm({\n "web/lib/wasm/jsep/webgpu/ops/tile.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_common();\n getRepeats = (repeatsTensorView) => Array.from(repeatsTensorView.getBigInt64Array(), Number);\n validateInputs27 = (inputs) => {\n if (!inputs || inputs.length !== 2) {\n throw new Error("Tile requires 2 inputs.");\n }\n if (inputs[0].dataType !== 1 /* float */ && inputs[0].dataType !== 6 /* int32 */ && inputs[0].dataType !== 12 /* uint32 */) {\n throw new Error("Tile only support float, int32, and uint32 data types");\n }\n if (inputs[1].dataType !== 7 /* int64 */) {\n throw new Error("Tile `repeats` input should be of int64 data type");\n }\n if (inputs[1].dims.length !== 1) {\n throw new Error("Tile `repeats` input should be 1-D");\n }\n const repeats = getRepeats(inputs[1]);\n if (repeats.length !== inputs[0].dims.length) {\n throw new Error("Tile `repeats` input should have same number of elements as rank of input data tensor");\n }\n };\n getOutputShape2 = (inputShape, repeats) => {\n const outputShape = [];\n for (let i = 0; i < inputShape.length; ++i) {\n outputShape.push(inputShape[i] * repeats[i]);\n }\n return outputShape;\n };\n createTileProgramInfo = (inputs) => {\n const inputShape = inputs[0].dims;\n const repeats = getRepeats(inputs[1]);\n const outputShape = getOutputShape2(inputShape, repeats);\n const outputSize = ShapeUtil.size(outputShape);\n const dataType = inputs[0].dataType;\n const input = inputVariable("input", dataType, inputShape.length);\n const output = outputVariable("output", dataType, outputShape.length);\n const getShaderSource = (shaderHelper) => `\n const inputShape = ${input.indices(...inputShape)};\n ${shaderHelper.registerUniform("output_size", "u32").declareVariables(input, output)}\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}\n let output_indices = ${output.offsetToIndices("global_idx")};\n var input_indices: ${input.type.indices};\n for (var i = 0; i < ${inputShape.length}; i++) {\n let input_dim_i = ${input.indicesGet("uniforms.input_shape", "i")};\n let input_dim_value = ${output.indicesGet("output_indices", "i")} % input_dim_i;\n\n ${input.indicesSet("input_indices", "i", "input_dim_value")}\n }\n ${output.setByOffset("global_idx", input.getByIndices("input_indices"))}\n }`;\n return {\n name: "Tile",\n shaderCache: { hint: `${repeats}`, inputDependencies: ["rank"] },\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64\n /* workgroup size */\n ) },\n programUniforms: [{ type: 12 /* uint32 */, data: outputSize }, ...createTensorShapeVariables(inputs[0].dims, outputShape)]\n }),\n getShaderSource\n };\n };\n tile = (context) => {\n validateInputs27(context.inputs);\n context.compute(createTileProgramInfo(context.inputs), { inputs: [0] });\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/ops/where.ts\n var createWhereOpProgramShader, createWhereOpProgramInfo, where;\n var init_where = __esm({\n "web/lib/wasm/jsep/webgpu/ops/where.ts"() {\n "use strict";\n init_wasm_common();\n init_util();\n init_common();\n createWhereOpProgramShader = (shaderHelper, inputs, dimsOutput, isBroadcast, typeOutput) => {\n const output = outputVariable("output_data", typeOutput, dimsOutput.length, 4);\n const a = inputVariable("a_data", inputs[1].dataType, inputs[1].dims.length, 4);\n const b = inputVariable("b_data", inputs[2].dataType, inputs[2].dims.length, 4);\n const c = inputVariable("c_data", inputs[0].dataType, inputs[0].dims.length, 4);\n let assignment;\n const expression = (a2, b2, c2) => `select(${b2}, ${a2}, ${c2})`;\n if (!isBroadcast) {\n assignment = output.setByOffset(\n "global_idx",\n expression(a.getByOffset("global_idx"), b.getByOffset("global_idx"), c.getByOffset("global_idx"))\n );\n } else {\n const singleAssignment = (resStr, x, typeCast = "") => {\n const expressionA = `a_data[index_a${x}][component_a${x}]`;\n const expressionB = `b_data[index_b${x}][component_b${x}]`;\n const expressionC = `bool(c_data[index_c${x}] & (0xffu << (component_c${x} * 8)))`;\n return `\n let output_indices${x} = ${output.offsetToIndices(`global_idx * 4u + ${x}u`)};\n let offset_a${x} = ${a.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n let offset_b${x} = ${b.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n let offset_c${x} = ${c.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n let index_a${x} = offset_a${x} / 4u;\n let index_b${x} = offset_b${x} / 4u;\n let index_c${x} = offset_c${x} / 4u;\n let component_a${x} = offset_a${x} % 4u;\n let component_b${x} = offset_b${x} % 4u;\n let component_c${x} = offset_c${x} % 4u;\n ${resStr}[${x}] = ${typeCast}(${expression(expressionA, expressionB, expressionC)});\n `;\n };\n if (typeOutput === 9 /* bool */) {\n assignment = `\n var data = vec4(0);\n ${singleAssignment("data", 0, "u32")}\n ${singleAssignment("data", 1, "u32")}\n ${singleAssignment("data", 2, "u32")}\n ${singleAssignment("data", 3, "u32")}\n output_data[global_idx] = dot(vec4(0x1, 0x100, 0x10000, 0x1000000), vec4(data));`;\n } else {\n assignment = `\n ${singleAssignment("output_data[global_idx]", 0)}\n ${singleAssignment("output_data[global_idx]", 1)}\n ${singleAssignment("output_data[global_idx]", 2)}\n ${singleAssignment("output_data[global_idx]", 3)}\n `;\n }\n }\n return `\n ${shaderHelper.registerUniform("vec_size", "u32").declareVariables(c, a, b, output)}\n ${shaderHelper.mainStart()}\n ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.vec_size")}\n ${assignment}\n }`;\n };\n createWhereOpProgramInfo = (inputs) => {\n const dimsA = inputs[1].dims;\n const dimsB = inputs[2].dims;\n const dimsC = inputs[0].dims;\n const outputDataType = inputs[1].dataType;\n const isBroadcast = !(ShapeUtil.areEqual(dimsA, dimsB) && ShapeUtil.areEqual(dimsB, dimsC));\n let outputShape = dimsA;\n let outputSize = ShapeUtil.size(dimsA);\n if (isBroadcast) {\n const calculatedShape = BroadcastUtil.calcShape(BroadcastUtil.calcShape(dimsA, dimsB, false), dimsC, false);\n if (!calculatedShape) {\n throw new Error("Can\'t perform where op on the given tensors");\n }\n outputShape = calculatedShape;\n outputSize = ShapeUtil.size(outputShape);\n }\n const vecSize = Math.ceil(outputSize / 4);\n return {\n name: "Where",\n shaderCache: { inputDependencies: ["rank", "rank", "rank"] },\n getShaderSource: (shaderHelper) => createWhereOpProgramShader(shaderHelper, inputs, outputShape, isBroadcast, outputDataType),\n getRunData: () => ({\n outputs: [{ dims: outputShape, dataType: outputDataType }],\n dispatchGroup: { x: Math.ceil(\n outputSize / 64 / 4\n /* vec size */\n ) },\n programUniforms: [{ type: 12 /* uint32 */, data: vecSize }, ...createTensorShapeVariables(dimsC, dimsA, dimsB, outputShape)]\n })\n };\n };\n where = (context) => {\n context.compute(createWhereOpProgramInfo(context.inputs));\n };\n }\n });\n\n // web/lib/wasm/jsep/webgpu/op-resolve-rules.ts\n var WEBGPU_OP_RESOLVE_RULES;\n var init_op_resolve_rules = __esm({\n "web/lib/wasm/jsep/webgpu/op-resolve-rules.ts"() {\n "use strict";\n init_argminmax();\n init_attention();\n init_batch_norm();\n init_bias_add();\n init_bias_split_gelu();\n init_binary_op();\n init_concat();\n init_conv();\n init_conv_transpose();\n init_cumsum();\n init_depth_to_space();\n init_einsum();\n init_expand();\n init_fast_gelu();\n init_gather();\n init_gather_elements();\n init_gemm();\n init_instance_norm();\n init_layer_norm();\n init_matmul();\n init_matmulnbits();\n init_multihead_attentiion();\n init_pad();\n init_pool();\n init_range();\n init_reduce();\n init_resize();\n init_rotary_embedding();\n init_skip_layer_norm();\n init_slice();\n init_softmax();\n init_split();\n init_tile();\n init_transpose();\n init_unary_op();\n init_where();\n WEBGPU_OP_RESOLVE_RULES = /* @__PURE__ */ new Map([\n ["Abs", [abs]],\n ["Acos", [acos]],\n ["Acosh", [acosh]],\n ["Add", [add]],\n ["ArgMax", [argMax, parseArgMinMaxAttributes]],\n ["ArgMin", [argMin, parseArgMinMaxAttributes]],\n ["Asin", [asin]],\n ["Asinh", [asinh]],\n ["Atan", [atan]],\n ["Atanh", [atanh]],\n ["Attention", [attention]],\n // TODO: support new attributes for AveragePool-10\n ["AveragePool", [averagePool, parseAveragePoolAttributes]],\n ["BatchNormalization", [batchNorm]],\n ["BiasAdd", [biasAdd]],\n ["BiasSplitGelu", [biasSplitGelu]],\n ["Cast", [cast, parseCastAttributes]],\n ["Ceil", [ceil]],\n ["Clip", [clip]],\n ["Concat", [concat, parseConcatAttributes]],\n ["Conv", [conv, parseConvAttributes]],\n ["ConvTranspose", [convTranspose, parseConvTransposeAttributes]],\n ["Cos", [cos]],\n ["Cosh", [cosh]],\n ["CumSum", [cumsum, parseCumSumAttributes]],\n ["DepthToSpace", [depthToSpace, parseDepthToSpaceAttributes]],\n ["Div", [div]],\n ["Einsum", [einsum, parseEinsumAttributes]],\n ["Elu", [elu, parseAlphaAttributes]],\n ["Equal", [equal]],\n ["Erf", [erf]],\n ["Exp", [exp]],\n ["Expand", [expand]],\n ["FastGelu", [fastGelu2]],\n ["Floor", [floor]],\n ["FusedConv", [conv, parseConvAttributes]],\n ["Gather", [gather, parseGatherAttributes]],\n ["GatherElements", [gatherElements, parseGatherElementsAttributes]],\n ["Gelu", [gelu]],\n ["Gemm", [gemm, parseGemmAttributes]],\n ["GlobalAveragePool", [globalAveragePool, parseGlobalAveragePoolAttributes]],\n ["GlobalMaxPool", [globalMaxPool, parseGlobalMaxPoolAttributes]],\n ["Greater", [greater]],\n ["GreaterOrEqual", [greaterOrEqual]],\n ["HardSigmoid", [hardSigmoid, parseHardSigmoidAttributes]],\n ["InstanceNormalization", [instanceNorm]],\n ["LayerNormalization", [layerNorm]],\n ["LeakyRelu", [leakyRelu, parseAlphaAttributes]],\n ["Less", [less]],\n ["LessOrEqual", [lessOrEqual]],\n ["Log", [log]],\n ["MatMul", [matMul]],\n ["MatMulNBits", [matMulNBits, parseMatMulNBitsAttributes]],\n // TODO: support new attributes for MaxPool-8 and MaxPool-10\n ["MaxPool", [maxPool, parseMaxPoolAttributes]],\n ["Mul", [mul]],\n ["MultiHeadAttention", [multiHeadAttention, parseMultiHeadAttentionAttributes]],\n ["Neg", [neg]],\n ["Not", [not]],\n ["Pad", [pad]],\n ["Pow", [pow]],\n ["Range", [range]],\n ["Reciprocal", [reciprocal]],\n ["ReduceMin", [reduceMin]],\n ["ReduceMean", [reduceMean]],\n ["ReduceMax", [reduceMax]],\n ["ReduceSum", [reduceSum]],\n ["ReduceProd", [reduceProd]],\n ["ReduceL1", [reduceL1]],\n ["ReduceL2", [reduceL2]],\n ["ReduceLogSum", [reduceLogSum]],\n ["ReduceLogSumExp", [reduceLogSumExp]],\n ["ReduceSumSquare", [reduceSumSquare]],\n ["Relu", [relu]],\n ["Resize", [resize, parseResizeAttributes]],\n ["RotaryEmbedding", [rotaryEmbedding]],\n ["Sigmoid", [sigmoid]],\n ["Sin", [sin]],\n ["Sinh", [sinh]],\n ["Slice", [slice, parseSliceAttributes]],\n ["SkipLayerNormalization", [skipLayerNorm]],\n ["Split", [split, parseSplitAttributes]],\n ["Sqrt", [sqrt]],\n ["Softmax", [softmax, parseSoftmaxAttributes]],\n ["Sub", [sub]],\n ["Tan", [tan]],\n ["Tanh", [tanh]],\n ["ThresholdedRelu", [thresholdedRelu, parseAlphaAttributes]],\n ["Tile", [tile]],\n ["Transpose", [transpose, parseTransposeAttributes]],\n ["Where", [where]]\n ]);\n }\n });\n\n // web/lib/wasm/jsep/webgpu/program-manager.ts\n var ProgramManager;\n var init_program_manager = __esm({\n "web/lib/wasm/jsep/webgpu/program-manager.ts"() {\n "use strict";\n init_esm();\n init_log();\n init_common();\n ProgramManager = class {\n constructor(backend) {\n this.backend = backend;\n this.repo = /* @__PURE__ */ new Map();\n this.attributesBound = false;\n }\n getArtifact(key) {\n return this.repo.get(key);\n }\n setArtifact(key, artifact) {\n this.repo.set(key, artifact);\n }\n run(buildArtifact, inputs, outputs, dispatchGroup, uniformBufferBinding) {\n TRACE_FUNC_BEGIN(buildArtifact.programInfo.name);\n const device = this.backend.device;\n const computePassEncoder = this.backend.getComputePassEncoder();\n this.backend.writeTimestamp(this.backend.pendingDispatchNumber * 2);\n const entries = [];\n for (const input of inputs) {\n entries.push({ binding: entries.length, resource: { buffer: input.buffer } });\n }\n for (const output of outputs) {\n entries.push({ binding: entries.length, resource: { buffer: output.buffer } });\n }\n if (uniformBufferBinding) {\n entries.push({ binding: entries.length, resource: uniformBufferBinding });\n }\n const bindGroup = device.createBindGroup(\n { layout: buildArtifact.computePipeline.getBindGroupLayout(0), entries, label: buildArtifact.programInfo.name }\n );\n if (this.backend.sessionStatus === "capturing") {\n const commandInfo = {\n kernelId: this.backend.currentKernelId,\n computePipeline: buildArtifact.computePipeline,\n bindGroup,\n dispatchGroup\n };\n const sessionCommandList = this.backend.capturedCommandList.get(this.backend.currentSessionId);\n sessionCommandList.push(commandInfo);\n }\n computePassEncoder.setPipeline(buildArtifact.computePipeline);\n computePassEncoder.setBindGroup(0, bindGroup);\n computePassEncoder.dispatchWorkgroups(...dispatchGroup);\n this.backend.writeTimestamp(this.backend.pendingDispatchNumber * 2 + 1);\n this.backend.pendingDispatchNumber++;\n if (this.backend.pendingDispatchNumber >= this.backend.maxDispatchNumber || this.backend.queryType === "at-passes") {\n this.backend.endComputePass();\n }\n if (this.backend.pendingDispatchNumber >= this.backend.maxDispatchNumber) {\n this.backend.flush();\n }\n TRACE_FUNC_END(buildArtifact.programInfo.name);\n }\n dispose() {\n }\n build(programInfo, normalizedDispatchGroupSize) {\n TRACE_FUNC_BEGIN(programInfo.name);\n const device = this.backend.device;\n const extensions = [];\n if (device.features.has("shader-f16")) {\n extensions.push("enable f16;");\n }\n const shaderHelper = createShaderHelper(normalizedDispatchGroupSize, this.backend.device.limits);\n const userCode = programInfo.getShaderSource(shaderHelper);\n const code = `${extensions.join("\\n")}\n${shaderHelper.additionalImplementations}\n${userCode}`;\n const shaderModule = device.createShaderModule({ code, label: programInfo.name });\n LOG_DEBUG("verbose", () => `[WebGPU] ${programInfo.name} shader code: ${code}`);\n const computePipeline = device.createComputePipeline(\n { compute: { module: shaderModule, entryPoint: "main" }, layout: "auto", label: programInfo.name }\n );\n TRACE_FUNC_END(programInfo.name);\n return { programInfo, computePipeline, uniformVariablesInfo: shaderHelper.variablesInfo };\n }\n normalizeDispatchGroupSize(dispatchGroup) {\n const x = typeof dispatchGroup === "number" ? dispatchGroup : dispatchGroup.x;\n const y = typeof dispatchGroup === "number" ? 1 : dispatchGroup.y || 1;\n const z = typeof dispatchGroup === "number" ? 1 : dispatchGroup.z || 1;\n const limitPerDimension = this.backend.device.limits.maxComputeWorkgroupsPerDimension;\n if (x <= limitPerDimension && y <= limitPerDimension && z <= limitPerDimension) {\n return [x, y, z];\n }\n const size = x * y * z;\n let dispatchAverage = Math.ceil(Math.sqrt(size));\n if (dispatchAverage > limitPerDimension) {\n dispatchAverage = Math.ceil(Math.cbrt(size));\n if (dispatchAverage > limitPerDimension) {\n throw new Error("Total dispatch size exceeds WebGPU maximum.");\n }\n return [dispatchAverage, dispatchAverage, dispatchAverage];\n } else {\n return [dispatchAverage, dispatchAverage, 1];\n }\n }\n };\n }\n });\n\n // web/lib/wasm/jsep/backend-webgpu.ts\n var getProgramInputTensorInfoDependencyKey, getProgramInfoUniqueKey, AdapterInfoImpl, WebGpuBackend;\n var init_backend_webgpu = __esm({\n "web/lib/wasm/jsep/backend-webgpu.ts"() {\n "use strict";\n init_esm();\n init_wasm_common();\n init_log();\n init_tensor_view();\n init_gpu_data_manager();\n init_op_resolve_rules();\n init_program_manager();\n getProgramInputTensorInfoDependencyKey = (inputTensors, inputDependencies) => {\n if (inputDependencies.length !== inputTensors.length) {\n throw new Error(`inputDependencies length ${inputDependencies.length} is not equal to inputTensors length ${inputTensors.length}.`);\n }\n const inputInfos = [];\n for (let i = 0; i < inputTensors.length; ++i) {\n const type = inputTensors[i].dataType;\n switch (inputDependencies[i]) {\n case "none": {\n inputInfos.push("");\n break;\n }\n case "type": {\n inputInfos.push(`${type}`);\n break;\n }\n case "rank": {\n const rank = inputTensors[i].dims.length;\n inputInfos.push(`${type};${rank}`);\n break;\n }\n case "dims": {\n const dims = inputTensors[i].dims.join(",");\n inputInfos.push(`${type};${dims}`);\n break;\n }\n default:\n throw new Error(`unsupported input dependency: ${inputDependencies[i]}`);\n }\n }\n return inputInfos.join("|");\n };\n getProgramInfoUniqueKey = (programInfo, inputTensors, is1DimensionDispatch) => {\n let key = programInfo.name;\n if (programInfo.shaderCache?.hint) {\n key += "[" + programInfo.shaderCache.hint + "]";\n }\n key += ":" + is1DimensionDispatch + `:${getProgramInputTensorInfoDependencyKey(\n inputTensors,\n programInfo.shaderCache?.inputDependencies ?? new Array(inputTensors.length).fill("dims")\n )}`;\n return key;\n };\n AdapterInfoImpl = class {\n constructor(adapterInfo) {\n if (adapterInfo) {\n this.architecture = adapterInfo.architecture;\n this.vendor = adapterInfo.vendor;\n }\n }\n isArchitecture(architecture) {\n return this.architecture === architecture;\n }\n isVendor(vendor) {\n return this.vendor === vendor;\n }\n };\n WebGpuBackend = class {\n constructor() {\n /**\n * representing the session ID of which is currently being run.\n * `null` means no session is being run.\n * only valid when session.run is executed.\n */\n this.currentSessionId = null;\n /**\n * representing the kernel ID of which is currently being computed (CPU code perspective).\n * `null` means no kernel is being computed.\n * only one kernel can be computed at a moment.\n */\n this.currentKernelId = null;\n this.commandEncoder = null;\n this.computePassEncoder = null;\n this.maxDispatchNumber = 16;\n this.pendingDispatchNumber = 0;\n // info of kernels pending submission for a single batch\n this.pendingKernels = [];\n // queryReadBuffer -> pendingKernels mapping for all the batches\n this.pendingQueries = /* @__PURE__ */ new Map();\n this.sessionStatus = "default";\n /**\n * a SessionID -> CommandInfo[] mapping. It\'s used to record all GPU commands for corresponding session.\n */\n this.capturedCommandList = /* @__PURE__ */ new Map();\n /**\n * a SessionID -> PendingKernelInfo[] mapping for profiling.\n */\n this.capturedPendingKernels = /* @__PURE__ */ new Map();\n /**\n * a SessionID -> a Map of (InputOutputIndex -> [ID, GPUBuffer]) mapping.\n */\n this.sessionExternalDataMapping = /* @__PURE__ */ new Map();\n }\n /**\n * get the custom data of the current kernel\n */\n get currentKernelCustomData() {\n if (this.currentKernelId === null) {\n throw new Error("currentKernelCustomData(): currentKernelId is null. (should not happen)");\n }\n let data = this.kernelCustomData.get(this.currentKernelId);\n if (!data) {\n data = {};\n this.kernelCustomData.set(this.currentKernelId, data);\n }\n return data;\n }\n async initialize(env3, adapter) {\n this.env = env3;\n const requiredFeatures = [];\n const deviceDescriptor = {\n requiredLimits: {\n maxComputeWorkgroupStorageSize: adapter.limits.maxComputeWorkgroupStorageSize,\n maxComputeWorkgroupsPerDimension: adapter.limits.maxComputeWorkgroupsPerDimension,\n maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,\n maxBufferSize: adapter.limits.maxBufferSize,\n maxComputeInvocationsPerWorkgroup: adapter.limits.maxComputeInvocationsPerWorkgroup,\n maxComputeWorkgroupSizeX: adapter.limits.maxComputeWorkgroupSizeX,\n maxComputeWorkgroupSizeY: adapter.limits.maxComputeWorkgroupSizeY,\n maxComputeWorkgroupSizeZ: adapter.limits.maxComputeWorkgroupSizeZ\n },\n requiredFeatures\n };\n if (adapter.features.has("chromium-experimental-timestamp-query-inside-passes")) {\n requiredFeatures.push("chromium-experimental-timestamp-query-inside-passes");\n } else if (adapter.features.has("timestamp-query")) {\n requiredFeatures.push("timestamp-query");\n }\n if (adapter.features.has("shader-f16")) {\n requiredFeatures.push("shader-f16");\n }\n this.device = await adapter.requestDevice(deviceDescriptor);\n this.adapterInfo = new AdapterInfoImpl(await adapter.requestAdapterInfo());\n this.gpuDataManager = createGpuDataManager(this);\n this.programManager = new ProgramManager(this);\n this.kernels = /* @__PURE__ */ new Map();\n this.kernelPersistentData = /* @__PURE__ */ new Map();\n this.kernelCustomData = /* @__PURE__ */ new Map();\n configureLogger(env3.logLevel, !!env3.debug);\n this.device.onuncapturederror = (ev) => {\n if (ev.error instanceof GPUValidationError) {\n console.error(`An uncaught WebGPU validation error was raised: ${ev.error.message}`);\n }\n };\n Object.defineProperty(\n this.env.webgpu,\n "device",\n { value: this.device, writable: false, enumerable: true, configurable: false }\n );\n Object.defineProperty(\n this.env.webgpu,\n "adapter",\n { value: adapter, writable: false, enumerable: true, configurable: false }\n );\n this.setQueryType();\n }\n dispose() {\n if (typeof this.querySet !== "undefined") {\n this.querySet.destroy();\n }\n this.gpuDataManager.dispose();\n }\n getCommandEncoder() {\n if (!this.commandEncoder) {\n this.commandEncoder = this.device.createCommandEncoder();\n }\n return this.commandEncoder;\n }\n getComputePassEncoder() {\n if (!this.computePassEncoder) {\n const commandEncoder = this.getCommandEncoder();\n const computePassDescriptor = {};\n if (this.queryType === "at-passes") {\n computePassDescriptor.timestampWrites = {\n querySet: this.querySet,\n beginningOfPassWriteIndex: this.pendingDispatchNumber * 2,\n endOfPassWriteIndex: this.pendingDispatchNumber * 2 + 1\n };\n }\n this.computePassEncoder = commandEncoder.beginComputePass(computePassDescriptor);\n }\n return this.computePassEncoder;\n }\n endComputePass() {\n if (this.computePassEncoder) {\n this.computePassEncoder.end();\n this.computePassEncoder = null;\n }\n }\n flush() {\n if (!this.commandEncoder) {\n return;\n }\n TRACE_FUNC_BEGIN();\n this.endComputePass();\n let queryReadBuffer;\n if (this.queryType !== "none") {\n this.commandEncoder.resolveQuerySet(\n this.querySet,\n 0,\n this.pendingDispatchNumber * 2,\n this.queryResolveBuffer,\n 0\n );\n queryReadBuffer = this.device.createBuffer(\n // eslint-disable-next-line no-bitwise\n { size: this.pendingDispatchNumber * 2 * 8, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST }\n );\n this.pendingQueries.set(queryReadBuffer, this.pendingKernels);\n this.pendingKernels = [];\n this.commandEncoder.copyBufferToBuffer(\n this.queryResolveBuffer,\n 0,\n queryReadBuffer,\n 0,\n this.pendingDispatchNumber * 2 * 8\n );\n }\n this.device.queue.submit([this.commandEncoder.finish()]);\n this.gpuDataManager.refreshPendingBuffers();\n this.commandEncoder = null;\n this.pendingDispatchNumber = 0;\n if (this.queryType !== "none") {\n void queryReadBuffer.mapAsync(GPUMapMode.READ).then(() => {\n const mappedData = new BigUint64Array(queryReadBuffer.getMappedRange());\n const pendingKernels = this.pendingQueries.get(queryReadBuffer);\n for (let i = 0; i < mappedData.length / 2; i++) {\n const pendingKernelInfo = pendingKernels[i];\n const kernelId = pendingKernelInfo.kernelId;\n const kernelInfo = this.kernels.get(kernelId);\n const kernelType = kernelInfo.kernelType;\n const kernelName = kernelInfo.kernelName;\n const programName = pendingKernelInfo.programName;\n const inputTensorViews = pendingKernelInfo.inputTensorViews;\n const outputTensorViews = pendingKernelInfo.outputTensorViews;\n const startTimeU64 = mappedData[i * 2];\n const endTimeU64 = mappedData[i * 2 + 1];\n if (typeof this.queryTimeBase === "undefined") {\n this.queryTimeBase = startTimeU64;\n }\n const startTime = Number(startTimeU64 - this.queryTimeBase);\n const endTime = Number(endTimeU64 - this.queryTimeBase);\n if (!Number.isSafeInteger(startTime) || !Number.isSafeInteger(endTime)) {\n throw new RangeError("incorrect timestamp range");\n }\n if (this.env.webgpu.profiling?.ondata) {\n this.env.webgpu.profiling.ondata({\n version: 1,\n inputsMetadata: inputTensorViews.map(\n (value) => ({ dims: value.dims, dataType: tensorDataTypeEnumToString(value.dataType) })\n ),\n outputsMetadata: outputTensorViews.map(\n (value) => ({ dims: value.dims, dataType: tensorDataTypeEnumToString(value.dataType) })\n ),\n kernelId,\n kernelType,\n kernelName,\n programName,\n startTime,\n endTime\n });\n } else {\n let inputShapes = "";\n inputTensorViews.forEach((value, i2) => {\n inputShapes += `input[${i2}]: [${value.dims}] | ${tensorDataTypeEnumToString(value.dataType)}, `;\n });\n let outputShapes = "";\n outputTensorViews.forEach((value, i2) => {\n outputShapes += `output[${i2}]: [${value.dims}] | ${tensorDataTypeEnumToString(value.dataType)}, `;\n });\n console.log(`[profiling] kernel "${kernelId}|${kernelType}|${kernelName}|${programName}" ${inputShapes}${outputShapes}execution time: ${endTime - startTime} ns`);\n }\n TRACE("GPU", `${programName}::${startTimeU64}::${endTimeU64}`);\n }\n queryReadBuffer.unmap();\n this.pendingQueries.delete(queryReadBuffer);\n });\n }\n TRACE_FUNC_END();\n }\n /**\n * run a WebGPU program.\n * @param program a ProgramInfo instance\n * @param inputTensorViews a TensorView array. each element represents a value already exists in GPU.\n * @param outputIndices an indices array. each element can be either -1 (temporary data), -2 (persistent data) or an\n * index to the kernel\'s output.\n * @param createKernelOutput a callback function that create a value to kernel\'s output with the given index\n * @param createIntermediateOutput a callback function that create a value as a intermediate value, either temporary\n * or persistent (owned by the current kernel)\n * @returns a TensorView array representing the result.\n */\n run(program, inputTensorViews, outputIndices, createKernelOutput, createIntermediateOutput, outputCount) {\n TRACE_FUNC_BEGIN(program.name);\n const inputDatas = [];\n for (let i = 0; i < inputTensorViews.length; ++i) {\n const data = inputTensorViews[i].data;\n if (data === 0) {\n continue;\n }\n const gpuData = this.gpuDataManager.get(data);\n if (!gpuData) {\n throw new Error(`no GPU data for input: ${data}`);\n }\n inputDatas.push(gpuData);\n }\n const { outputs, dispatchGroup, programUniforms } = program.getRunData(inputTensorViews);\n const validatedOutputIndices = outputIndices.length === 0 ? outputs.map((_, i) => i) : outputIndices;\n if (validatedOutputIndices.length !== outputs.length) {\n throw new Error(`Output size ${validatedOutputIndices.length} must be equal to ${outputs.length}.`);\n }\n const outputTensorViews = [];\n const outputDatas = [];\n for (let i = 0; i < outputs.length; ++i) {\n if (!Number.isInteger(validatedOutputIndices[i]) || validatedOutputIndices[i] < -3 || validatedOutputIndices[i] >= outputCount) {\n throw new Error(`Invalid output index: ${validatedOutputIndices[i]}`);\n }\n if (validatedOutputIndices[i] === -3) {\n continue;\n }\n const isTemporary = validatedOutputIndices[i] === -1;\n const isPersistent = validatedOutputIndices[i] === -2;\n const tensorView = isTemporary || isPersistent ? createIntermediateOutput(outputs[i].dataType, outputs[i].dims) : createKernelOutput(validatedOutputIndices[i], outputs[i].dataType, outputs[i].dims);\n outputTensorViews.push(tensorView);\n if (tensorView.data === 0) {\n continue;\n }\n const gpuData = this.gpuDataManager.get(tensorView.data);\n if (!gpuData) {\n throw new Error(`no GPU data for output: ${tensorView.data}`);\n }\n if (isTemporary) {\n this.temporaryData.push(gpuData);\n }\n if (isPersistent) {\n let persistentData = this.kernelPersistentData.get(this.currentKernelId);\n if (!persistentData) {\n persistentData = [];\n this.kernelPersistentData.set(this.currentKernelId, persistentData);\n }\n persistentData.push(gpuData);\n }\n outputDatas.push(gpuData);\n }\n if (inputDatas.length !== inputTensorViews.length || outputDatas.length !== outputTensorViews.length) {\n if (outputDatas.length === 0) {\n TRACE_FUNC_END(program.name);\n return outputTensorViews;\n }\n throw new Error(\n `Program ${program.name} has zero-sized tensor(s) in inputs or outputs. This is not supported now.`\n );\n }\n let uniformBufferBinding;\n if (programUniforms) {\n let currentOffset = 0;\n const offsets = [];\n programUniforms.forEach((v) => {\n const data = typeof v.data === "number" ? [v.data] : v.data;\n if (data.length === 0) {\n return;\n }\n const sizeOfElement = v.type === 10 /* float16 */ ? 2 : 4;\n let sizeOfVecOrMat;\n let baseAlignment;\n if (v.type === 10 /* float16 */) {\n baseAlignment = data.length > 4 ? 16 : data.length > 2 ? 8 : data.length * sizeOfElement;\n sizeOfVecOrMat = data.length > 4 ? 16 : sizeOfElement * data.length;\n } else {\n baseAlignment = data.length <= 2 ? data.length * sizeOfElement : 16;\n sizeOfVecOrMat = 16;\n }\n currentOffset = Math.ceil(currentOffset / baseAlignment) * baseAlignment;\n offsets.push(currentOffset);\n const elementPerVecOrMat = v.type === 10 /* float16 */ ? 8 : 4;\n currentOffset += data.length > 4 ? Math.ceil(data.length / elementPerVecOrMat) * sizeOfVecOrMat : data.length * sizeOfElement;\n });\n const maxAlignmentOfField = 16;\n currentOffset = Math.ceil(currentOffset / maxAlignmentOfField) * maxAlignmentOfField;\n const arrayBuffer = new ArrayBuffer(currentOffset);\n programUniforms.forEach((v, i) => {\n const offset = offsets[i];\n const data = typeof v.data === "number" ? [v.data] : v.data;\n if (v.type === 6 /* int32 */) {\n new Int32Array(arrayBuffer, offset, data.length).set(data);\n } else if (v.type === 12 /* uint32 */) {\n new Uint32Array(arrayBuffer, offset, data.length).set(data);\n } else if (v.type === 10 /* float16 */) {\n new Uint16Array(arrayBuffer, offset, data.length).set(data);\n } else if (v.type === 1 /* float */) {\n new Float32Array(arrayBuffer, offset, data.length).set(data);\n } else {\n throw new Error(`Unsupported uniform type: ${tensorDataTypeEnumToString(v.type)}`);\n }\n });\n const uniformBufferData = (\n // eslint-disable-next-line no-bitwise\n this.gpuDataManager.create(currentOffset, GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM)\n );\n this.device.queue.writeBuffer(uniformBufferData.buffer, 0, arrayBuffer, 0, currentOffset);\n this.gpuDataManager.release(uniformBufferData.id);\n uniformBufferBinding = { offset: 0, size: currentOffset, buffer: uniformBufferData.buffer };\n }\n const normalizedDispatchGroup = this.programManager.normalizeDispatchGroupSize(dispatchGroup);\n const is1DimensionDispatch = normalizedDispatchGroup[1] === 1 && normalizedDispatchGroup[2] === 1;\n const key = getProgramInfoUniqueKey(program, inputTensorViews, is1DimensionDispatch);\n let artifact = this.programManager.getArtifact(key);\n if (!artifact) {\n artifact = this.programManager.build(program, normalizedDispatchGroup);\n this.programManager.setArtifact(key, artifact);\n LOG_DEBUG("info", () => `[artifact] key: ${key}, programName: ${program.name}`);\n }\n if (programUniforms && artifact.uniformVariablesInfo) {\n if (programUniforms.length !== artifact.uniformVariablesInfo.length) {\n throw new Error(`Uniform variables count mismatch: expect ${artifact.uniformVariablesInfo.length}, got ${programUniforms.length} in program "${artifact.programInfo.name}".`);\n }\n for (let i = 0; i < programUniforms.length; i++) {\n const uniform = programUniforms[i];\n const actualType = uniform.type;\n const actualLength = typeof uniform.data === "number" ? 1 : uniform.data.length;\n const [type, length] = artifact.uniformVariablesInfo[i];\n if (actualType !== type || actualLength !== length) {\n throw new Error(`Uniform variable ${i} mismatch: expect type ${type} with size ${length}, got type ${actualType} with size ${actualLength} in program "${artifact.programInfo.name}".`);\n }\n }\n }\n LOG_DEBUG(\n "info",\n () => `[ProgramManager] run "${program.name}" (key=${key}) with ${normalizedDispatchGroup[0]}x${normalizedDispatchGroup[1]}x${normalizedDispatchGroup[2]}`\n );\n if (this.queryType !== "none" || this.sessionStatus === "capturing") {\n const pendingKernelInfo = {\n kernelId: this.currentKernelId,\n programName: artifact.programInfo.name,\n inputTensorViews,\n outputTensorViews\n };\n this.pendingKernels.push(pendingKernelInfo);\n if (this.sessionStatus === "capturing") {\n const sessionPendingKernels = this.capturedPendingKernels.get(this.currentSessionId);\n sessionPendingKernels.push(pendingKernelInfo);\n }\n }\n this.programManager.run(artifact, inputDatas, outputDatas, normalizedDispatchGroup, uniformBufferBinding);\n TRACE_FUNC_END(program.name);\n return outputTensorViews;\n }\n upload(gpuDataId, data) {\n this.gpuDataManager.upload(gpuDataId, data);\n }\n memcpy(src, dst) {\n this.gpuDataManager.memcpy(src, dst);\n }\n async download(gpuDataId, getTargetBuffer) {\n await this.gpuDataManager.download(gpuDataId, getTargetBuffer);\n }\n alloc(size) {\n return this.gpuDataManager.create(size).id;\n }\n free(ptr) {\n return this.gpuDataManager.release(ptr);\n }\n createKernel(kernelType, kernelId, attribute, kernelName) {\n const op = WEBGPU_OP_RESOLVE_RULES.get(kernelType);\n if (!op) {\n throw new Error(`kernel not implemented: ${kernelType}`);\n }\n const kernelInfo = {\n kernelType,\n kernelName,\n kernelEntry: op[0],\n attributes: [op[1], attribute]\n };\n this.kernels.set(kernelId, kernelInfo);\n }\n releaseKernel(kernelId) {\n const persistentData = this.kernelPersistentData.get(kernelId);\n if (persistentData) {\n for (const data of persistentData) {\n this.gpuDataManager.release(data.id);\n }\n this.kernelPersistentData.delete(kernelId);\n }\n this.kernelCustomData.delete(kernelId);\n this.kernels.delete(kernelId);\n }\n computeKernel(kernelId, context, errors) {\n const kernel = this.kernels.get(kernelId);\n if (!kernel) {\n throw new Error(`kernel not created: ${kernelId}`);\n }\n const kernelType = kernel.kernelType;\n const kernelName = kernel.kernelName;\n const kernelEntry = kernel.kernelEntry;\n const attributes = kernel.attributes;\n if (this.currentKernelId !== null) {\n throw new Error(`kernel "[${kernelType}] ${kernelName}" is not allowed to be called recursively`);\n }\n this.currentKernelId = kernelId;\n if (attributes[0]) {\n attributes[1] = attributes[0](attributes[1]);\n attributes[0] = void 0;\n }\n LOG_DEBUG("info", () => `[WebGPU] Start to run kernel "[${kernelType}] ${kernelName}"...`);\n const useErrorScope = this.env.debug;\n this.temporaryData = [];\n try {\n if (useErrorScope) {\n this.device.pushErrorScope("validation");\n }\n kernelEntry(context, attributes[1]);\n return 0;\n } catch (e) {\n errors.push(Promise.resolve(`[WebGPU] Kernel "[${kernelType}] ${kernelName}" failed. ${e}`));\n return 1;\n } finally {\n if (useErrorScope) {\n errors.push(this.device.popErrorScope().then(\n (err) => err ? `GPU validation error for kernel "[${kernelType}] ${kernelName}": ${err.message}` : null\n ));\n }\n for (const data of this.temporaryData) {\n this.gpuDataManager.release(data.id);\n }\n this.temporaryData = [];\n this.currentKernelId = null;\n }\n }\n // #region external buffer\n registerBuffer(sessionId, index, buffer, size) {\n let sessionInputOutputMapping = this.sessionExternalDataMapping.get(sessionId);\n if (!sessionInputOutputMapping) {\n sessionInputOutputMapping = /* @__PURE__ */ new Map();\n this.sessionExternalDataMapping.set(sessionId, sessionInputOutputMapping);\n }\n const previousBuffer = sessionInputOutputMapping.get(index);\n const id = this.gpuDataManager.registerExternalBuffer(buffer, size, previousBuffer?.[1]);\n sessionInputOutputMapping.set(index, [id, buffer]);\n return id;\n }\n unregisterBuffers(sessionId) {\n const sessionInputOutputMapping = this.sessionExternalDataMapping.get(sessionId);\n if (sessionInputOutputMapping) {\n sessionInputOutputMapping.forEach((bufferInfo) => this.gpuDataManager.unregisterExternalBuffer(bufferInfo[1]));\n this.sessionExternalDataMapping.delete(sessionId);\n }\n }\n getBuffer(gpuDataId) {\n const gpuData = this.gpuDataManager.get(gpuDataId);\n if (!gpuData) {\n throw new Error(`no GPU data for buffer: ${gpuDataId}`);\n }\n return gpuData.buffer;\n }\n createDownloader(gpuBuffer, size, type) {\n return async () => {\n const data = await downloadGpuData(this, gpuBuffer, size);\n return createView(data.buffer, type);\n };\n }\n // #endregion\n writeTimestamp(index) {\n if (this.queryType !== "inside-passes") {\n return;\n }\n this.computePassEncoder.writeTimestamp(this.querySet, index);\n }\n setQueryType() {\n this.queryType = "none";\n if (this.env.webgpu.profiling?.mode === "default" || (typeof this.env.trace === "undefined" ? this.env.wasm.trace : this.env.trace)) {\n if (this.device.features.has("chromium-experimental-timestamp-query-inside-passes")) {\n this.queryType = "inside-passes";\n } else if (this.device.features.has("timestamp-query")) {\n this.queryType = "at-passes";\n }\n if (this.queryType !== "none" && typeof this.querySet === "undefined") {\n this.querySet = this.device.createQuerySet({\n type: "timestamp",\n count: this.maxDispatchNumber * 2\n });\n this.queryResolveBuffer = this.device.createBuffer(\n // eslint-disable-next-line no-bitwise\n { size: this.maxDispatchNumber * 2 * 8, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE }\n );\n }\n }\n }\n captureBegin() {\n LOG_DEBUG("info", "captureBegin");\n if (!this.capturedCommandList.get(this.currentSessionId)) {\n this.capturedCommandList.set(this.currentSessionId, []);\n }\n if (!this.capturedPendingKernels.get(this.currentSessionId)) {\n this.capturedPendingKernels.set(this.currentSessionId, []);\n }\n this.flush();\n this.sessionStatus = "capturing";\n }\n captureEnd() {\n LOG_DEBUG("info", "captureEnd");\n this.flush();\n this.sessionStatus = "default";\n }\n replay() {\n LOG_DEBUG("info", "replay");\n this.sessionStatus = "replaying";\n const sessionCommandList = this.capturedCommandList.get(this.currentSessionId);\n const sessionPendingKernels = this.capturedPendingKernels.get(this.currentSessionId);\n const length = sessionCommandList.length;\n this.pendingKernels = [];\n for (let i = 0; i < length; i++) {\n const computePassEncoder = this.getComputePassEncoder();\n const command = sessionCommandList[i];\n this.writeTimestamp(this.pendingDispatchNumber * 2);\n computePassEncoder.setPipeline(command.computePipeline);\n computePassEncoder.setBindGroup(0, command.bindGroup);\n computePassEncoder.dispatchWorkgroups(...command.dispatchGroup);\n this.writeTimestamp(this.pendingDispatchNumber * 2 + 1);\n this.pendingDispatchNumber++;\n if (this.queryType !== "none") {\n this.pendingKernels.push(sessionPendingKernels[i]);\n }\n if (this.pendingDispatchNumber >= this.maxDispatchNumber || this.queryType === "at-passes") {\n this.endComputePass();\n }\n if (this.pendingDispatchNumber >= this.maxDispatchNumber) {\n this.flush();\n }\n }\n this.flush();\n this.sessionStatus = "default";\n }\n onReleaseSession(sessionId) {\n this.unregisterBuffers(sessionId);\n if (this.capturedCommandList.has(sessionId)) {\n this.capturedCommandList.delete(sessionId);\n }\n if (this.capturedPendingKernels.has(sessionId)) {\n this.capturedPendingKernels.delete(sessionId);\n }\n this.gpuDataManager.onReleaseSession(sessionId);\n }\n onRunStart(sessionId) {\n this.currentSessionId = sessionId;\n this.setQueryType();\n }\n };\n }\n });\n\n // web/lib/wasm/jsep/init.ts\n var init_exports = {};\n __export(init_exports, {\n init: () => init\n });\n var TensorViewImpl, ComputeContextImpl, init;\n var init_init = __esm({\n "web/lib/wasm/jsep/init.ts"() {\n "use strict";\n init_wasm_common();\n init_backend_webgpu();\n init_log();\n init_util();\n TensorViewImpl = class _TensorViewImpl {\n constructor(module, dataType, data, dims) {\n this.module = module;\n this.dataType = dataType;\n this.data = data;\n this.dims = dims;\n }\n getFloat32Array() {\n if (this.dataType !== 1 /* float */) {\n throw new Error("Invalid data type");\n }\n const elementCount = ShapeUtil.size(this.dims);\n return elementCount === 0 ? new Float32Array() : new Float32Array(this.module.HEAP8.buffer, this.data, elementCount);\n }\n getBigInt64Array() {\n if (this.dataType !== 7 /* int64 */) {\n throw new Error("Invalid data type");\n }\n const elementCount = ShapeUtil.size(this.dims);\n return elementCount === 0 ? new BigInt64Array() : new BigInt64Array(this.module.HEAP8.buffer, this.data, elementCount);\n }\n getInt32Array() {\n if (this.dataType !== 6 /* int32 */) {\n throw new Error("Invalid data type");\n }\n const elementCount = ShapeUtil.size(this.dims);\n return elementCount === 0 ? new Int32Array() : new Int32Array(this.module.HEAP8.buffer, this.data, elementCount);\n }\n reshape(newDims) {\n if (ShapeUtil.size(newDims) !== ShapeUtil.size(this.dims)) {\n throw new Error("Invalid new shape");\n }\n return new _TensorViewImpl(this.module, this.dataType, this.data, newDims);\n }\n };\n ComputeContextImpl = class {\n constructor(module, backend, contextDataOffset) {\n this.module = module;\n this.backend = backend;\n this.customDataOffset = 0;\n this.customDataSize = 0;\n this.adapterInfo = backend.adapterInfo;\n const heapU32 = module.HEAPU32;\n let dataIndex = contextDataOffset >>> 2;\n this.opKernelContext = heapU32[dataIndex++];\n const inputCount = heapU32[dataIndex++];\n this.outputCount = heapU32[dataIndex++];\n this.customDataOffset = heapU32[dataIndex++];\n this.customDataSize = heapU32[dataIndex++];\n const inputs = [];\n for (let i = 0; i < inputCount; i++) {\n const dataType = heapU32[dataIndex++];\n const data = heapU32[dataIndex++];\n const dim = heapU32[dataIndex++];\n const dims = [];\n for (let d = 0; d < dim; d++) {\n dims.push(heapU32[dataIndex++]);\n }\n inputs.push(new TensorViewImpl(module, dataType, data, dims));\n }\n this.inputs = inputs;\n }\n get kernelCustomData() {\n return this.backend.currentKernelCustomData;\n }\n get customDataBuffer() {\n return this.module.HEAPU8.subarray(this.customDataOffset, this.customDataOffset + this.customDataSize);\n }\n getMaxComputeWorkgroupSizes() {\n return [\n this.backend.device.limits.maxComputeWorkgroupSizeX,\n this.backend.device.limits.maxComputeWorkgroupSizeY,\n this.backend.device.limits.maxComputeWorkgroupSizeZ\n ];\n }\n getMaxComputeWorkgroupStoragesize() {\n return this.backend.device.limits.maxComputeWorkgroupStorageSize;\n }\n compute(program, inputsOutputsMapping) {\n const mappedInputs = inputsOutputsMapping?.inputs?.map((i) => typeof i === "number" ? this.inputs[i] : i) ?? this.inputs;\n const outputIndices = inputsOutputsMapping?.outputs ?? [];\n const createKernelOutput = (index, dataType, dims) => new TensorViewImpl(this.module, dataType, this.output(index, dims), dims);\n const createTemporaryOutput = (dataType, dims) => {\n const elementSize = getTensorElementSize(dataType);\n if (!elementSize) {\n throw new Error(`Unsupported data type: ${dataType}`);\n }\n const bufferSize = elementSize * ShapeUtil.size(dims);\n const gpuDataId = bufferSize > 0 ? this.backend.gpuDataManager.create(bufferSize).id : 0;\n return new TensorViewImpl(this.module, dataType, gpuDataId, dims);\n };\n return this.backend.run(\n program,\n mappedInputs,\n outputIndices,\n createKernelOutput,\n createTemporaryOutput,\n this.outputCount\n );\n }\n output(index, dims) {\n const stack = this.module.stackSave();\n try {\n const data = this.module.stackAlloc(\n (1 + dims.length) * 4\n /* sizeof(size_t) */\n );\n let offset = data >> 2;\n this.module.HEAPU32[offset++] = dims.length;\n for (let i = 0; i < dims.length; i++) {\n this.module.HEAPU32[offset++] = dims[i];\n }\n return this.module._JsepOutput(this.opKernelContext, index, data);\n } catch (e) {\n throw new Error(\n `Failed to generate kernel\'s output[${index}] with dims [${dims}]. If you are running with pre-allocated output, please make sure the output type/dims are correct. Error: ${e}`\n );\n } finally {\n this.module.stackRestore(stack);\n }\n }\n };\n init = async (name, module, env3, gpuAdapter) => {\n const jsepInit = module.jsepInit;\n if (!jsepInit) {\n throw new Error("Failed to initialize JSEP. The WebAssembly module is not built with JSEP support.");\n }\n if (name === "webgpu") {\n const backend = new WebGpuBackend();\n await backend.initialize(env3, gpuAdapter);\n jsepInit("webgpu", [\n // backend\n backend,\n // jsepAlloc()\n (size) => backend.alloc(size),\n // jsepFree()\n (ptr) => backend.free(ptr),\n // jsepCopy(src, dst, size, isSourceGpu)\n (src, dst, size, isSourceGpu = false) => {\n if (isSourceGpu) {\n LOG_DEBUG("verbose", () => `[WebGPU] jsepCopyGpuToGpu: src=${src}, dst=${dst}, size=${size}`);\n backend.memcpy(src, dst);\n } else {\n LOG_DEBUG("verbose", () => `[WebGPU] jsepCopyCpuToGpu: dataOffset=${src}, gpuDataId=${dst}, size=${size}`);\n const data = module.HEAPU8.subarray(src >>> 0, (src >>> 0) + size);\n backend.upload(dst, data);\n }\n },\n // jsepCopyAsync(src, dst, size)\n async (gpuDataId, dataOffset, size) => {\n LOG_DEBUG(\n "verbose",\n () => `[WebGPU] jsepCopyGpuToCpu: gpuDataId=${gpuDataId}, dataOffset=${dataOffset}, size=${size}`\n );\n await backend.download(\n gpuDataId,\n () => module.HEAPU8.subarray(dataOffset >>> 0, (dataOffset >>> 0) + size)\n );\n },\n // jsepCreateKernel\n (kernelType, kernelId, attribute) => backend.createKernel(\n kernelType,\n kernelId,\n attribute,\n module.UTF8ToString(module._JsepGetNodeName(kernelId))\n ),\n // jsepReleaseKernel\n (kernel) => backend.releaseKernel(kernel),\n // jsepRun\n (kernel, contextDataOffset, sessionHandle, errors) => {\n LOG_DEBUG(\n "verbose",\n () => `[WebGPU] jsepRun: sessionHandle=${sessionHandle}, kernel=${kernel}, contextDataOffset=${contextDataOffset}`\n );\n const context = new ComputeContextImpl(module, backend, contextDataOffset);\n return backend.computeKernel(kernel, context, errors);\n },\n // jsepCaptureBegin\n () => backend.captureBegin(),\n // jsepCaptureEnd\n () => backend.captureEnd(),\n // jsepReplay\n () => backend.replay()\n ]);\n } else {\n jsepInit("webnn");\n }\n };\n }\n });\n\n // nodejs-ignore:node:path\n var join = void 0;\n\n // web/lib/wasm/wasm-factory.ts\n var ortWasmFactory;\n if (false) {\n ortWasmFactory = null;\n } else {\n ortWasmFactory = false ? null : require_ort_wasm_simd_jsep();\n }\n var ortWasmFactoryThreaded = true ? false ? null : require_ort_wasm_simd_threaded_jsep() : ortWasmFactory;\n var wasm;\n var initialized = false;\n var initializing = false;\n var aborted = false;\n var isMultiThreadSupported = (numThreads) => {\n if (numThreads === 1) {\n return false;\n }\n if (typeof SharedArrayBuffer === "undefined") {\n if (typeof self !== "undefined" && !self.crossOriginIsolated) {\n console.warn(\n "env.wasm.numThreads is set to " + numThreads + ", but this will not work unless you enable crossOriginIsolated mode. See https://web.dev/cross-origin-isolation-guide/ for more info."\n );\n }\n return false;\n }\n if (typeof process !== "undefined" && process.versions && process.versions.node) {\n console.warn(\n "env.wasm.numThreads is set to " + numThreads + ", however, currently onnxruntime-web does not support multi-threads in Node.js. Please consider using onnxruntime-node for performance critical scenarios."\n );\n }\n try {\n if (typeof MessageChannel !== "undefined") {\n new MessageChannel().port1.postMessage(new SharedArrayBuffer(1));\n }\n return WebAssembly.validate(new Uint8Array([\n 0,\n 97,\n 115,\n 109,\n 1,\n 0,\n 0,\n 0,\n 1,\n 4,\n 1,\n 96,\n 0,\n 0,\n 3,\n 2,\n 1,\n 0,\n 5,\n 4,\n 1,\n 3,\n 1,\n 1,\n 10,\n 11,\n 1,\n 9,\n 0,\n 65,\n 0,\n 254,\n 16,\n 2,\n 0,\n 26,\n 11\n ]));\n } catch (e) {\n return false;\n }\n };\n var isSimdSupported = () => {\n try {\n return WebAssembly.validate(new Uint8Array([\n 0,\n 97,\n 115,\n 109,\n 1,\n 0,\n 0,\n 0,\n 1,\n 4,\n 1,\n 96,\n 0,\n 0,\n 3,\n 2,\n 1,\n 0,\n 10,\n 30,\n 1,\n 28,\n 0,\n 65,\n 0,\n 253,\n 15,\n 253,\n 12,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 253,\n 186,\n 1,\n 26,\n 11\n ]));\n } catch (e) {\n return false;\n }\n };\n var getWasmFileName = (useSimd, useThreads) => {\n if (useSimd) {\n if (false) {\n return "ort-training-wasm-simd.wasm";\n }\n return useThreads ? "ort-wasm-simd-threaded.wasm" : "ort-wasm-simd.wasm";\n } else {\n return useThreads ? "ort-wasm-threaded.wasm" : "ort-wasm.wasm";\n }\n };\n var initializeWebAssembly = async (flags) => {\n if (initialized) {\n return Promise.resolve();\n }\n if (initializing) {\n throw new Error("multiple calls to \'initializeWebAssembly()\' detected.");\n }\n if (aborted) {\n throw new Error("previous call to \'initializeWebAssembly()\' failed.");\n }\n initializing = true;\n const timeout = flags.initTimeout;\n const numThreads = flags.numThreads;\n const simd = flags.simd;\n const useThreads = isMultiThreadSupported(numThreads);\n const useSimd = simd && isSimdSupported();\n const wasmPaths = flags.wasmPaths;\n const wasmPrefixOverride = typeof wasmPaths === "string" ? wasmPaths : void 0;\n const wasmFileName = getWasmFileName(useSimd, useThreads);\n const wasmPathOverride = typeof wasmPaths === "object" ? wasmPaths[wasmFileName] : void 0;\n let isTimeout = false;\n const tasks = [];\n if (timeout > 0) {\n tasks.push(new Promise((resolve) => {\n setTimeout(() => {\n isTimeout = true;\n resolve();\n }, timeout);\n }));\n }\n tasks.push(new Promise((resolve, reject) => {\n const factory = useThreads ? ortWasmFactoryThreaded : ortWasmFactory;\n const config = {\n locateFile: (fileName, scriptDirectory) => {\n if (useThreads && fileName.endsWith(".worker.js") && typeof Blob !== "undefined") {\n return URL.createObjectURL(new Blob(\n [\n // This require() function is handled by esbuild plugin to load file content as string.\n // eslint-disable-next-line @typescript-eslint/no-require-imports\n require_ort_wasm_threaded_worker()\n ],\n { type: "text/javascript" }\n ));\n }\n if (fileName.endsWith(".wasm")) {\n if (wasmPathOverride) {\n return wasmPathOverride;\n }\n const prefix = wasmPrefixOverride ?? scriptDirectory;\n if (true) {\n if (wasmFileName === "ort-wasm-simd.wasm") {\n return prefix + "ort-wasm-simd.jsep.wasm";\n } else if (wasmFileName === "ort-wasm-simd-threaded.wasm") {\n return prefix + "ort-wasm-simd-threaded.jsep.wasm";\n }\n }\n return prefix + wasmFileName;\n }\n return scriptDirectory + fileName;\n }\n };\n if (useThreads) {\n config.numThreads = numThreads;\n if (typeof Blob === "undefined") {\n config.mainScriptUrlOrBlob = join(__dirname, "ort-wasm-threaded.js");\n } else {\n const scriptSourceCode = `var ortWasmThreaded=${factory.toString()};`;\n config.mainScriptUrlOrBlob = new Blob([scriptSourceCode], { type: "text/javascript" });\n }\n }\n factory(config).then(\n // wasm module initialized successfully\n (module) => {\n initializing = false;\n initialized = true;\n wasm = module;\n resolve();\n },\n // wasm module failed to initialize\n (what) => {\n initializing = false;\n aborted = true;\n reject(what);\n }\n );\n }));\n await Promise.race(tasks);\n if (isTimeout) {\n throw new Error(`WebAssembly backend initializing failed due to timeout: ${timeout}ms`);\n }\n };\n var getInstance = () => {\n if (initialized && wasm) {\n return wasm;\n }\n throw new Error("WebAssembly is not initialized yet.");\n };\n\n // web/lib/wasm/wasm-utils.ts\n var allocWasmString = (data, allocs) => {\n const wasm2 = getInstance();\n const dataLength = wasm2.lengthBytesUTF8(data) + 1;\n const dataOffset = wasm2._malloc(dataLength);\n wasm2.stringToUTF8(data, dataOffset, dataLength);\n allocs.push(dataOffset);\n return dataOffset;\n };\n var iterateExtraOptions = (options, prefix, seen, handler) => {\n if (typeof options == "object" && options !== null) {\n if (seen.has(options)) {\n throw new Error("Circular reference in options");\n } else {\n seen.add(options);\n }\n }\n Object.entries(options).forEach(([key, value]) => {\n const name = prefix ? prefix + key : key;\n if (typeof value === "object") {\n iterateExtraOptions(value, name + ".", seen, handler);\n } else if (typeof value === "string" || typeof value === "number") {\n handler(name, value.toString());\n } else if (typeof value === "boolean") {\n handler(name, value ? "1" : "0");\n } else {\n throw new Error(`Can\'t handle extra config type: ${typeof value}`);\n }\n });\n };\n var checkLastError = (message) => {\n const wasm2 = getInstance();\n const stack = wasm2.stackSave();\n try {\n const paramsOffset = wasm2.stackAlloc(8);\n wasm2._OrtGetLastError(paramsOffset, paramsOffset + 4);\n const errorCode = wasm2.HEAP32[paramsOffset / 4];\n const errorMessagePointer = wasm2.HEAPU32[paramsOffset / 4 + 1];\n const errorMessage = errorMessagePointer ? wasm2.UTF8ToString(errorMessagePointer) : "";\n throw new Error(`${message} ERROR_CODE: ${errorCode}, ERROR_MESSAGE: ${errorMessage}`);\n } finally {\n wasm2.stackRestore(stack);\n }\n };\n\n // web/lib/wasm/run-options.ts\n var setRunOptions = (options) => {\n const wasm2 = getInstance();\n let runOptionsHandle = 0;\n const allocs = [];\n const runOptions = options || {};\n try {\n if (options?.logSeverityLevel === void 0) {\n runOptions.logSeverityLevel = 2;\n } else if (typeof options.logSeverityLevel !== "number" || !Number.isInteger(options.logSeverityLevel) || options.logSeverityLevel < 0 || options.logSeverityLevel > 4) {\n throw new Error(`log serverity level is not valid: ${options.logSeverityLevel}`);\n }\n if (options?.logVerbosityLevel === void 0) {\n runOptions.logVerbosityLevel = 0;\n } else if (typeof options.logVerbosityLevel !== "number" || !Number.isInteger(options.logVerbosityLevel)) {\n throw new Error(`log verbosity level is not valid: ${options.logVerbosityLevel}`);\n }\n if (options?.terminate === void 0) {\n runOptions.terminate = false;\n }\n let tagDataOffset = 0;\n if (options?.tag !== void 0) {\n tagDataOffset = allocWasmString(options.tag, allocs);\n }\n runOptionsHandle = wasm2._OrtCreateRunOptions(\n runOptions.logSeverityLevel,\n runOptions.logVerbosityLevel,\n !!runOptions.terminate,\n tagDataOffset\n );\n if (runOptionsHandle === 0) {\n checkLastError("Can\'t create run options.");\n }\n if (options?.extra !== void 0) {\n iterateExtraOptions(options.extra, "", /* @__PURE__ */ new WeakSet(), (key, value) => {\n const keyDataOffset = allocWasmString(key, allocs);\n const valueDataOffset = allocWasmString(value, allocs);\n if (wasm2._OrtAddRunConfigEntry(runOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n checkLastError(`Can\'t set a run config entry: ${key} - ${value}.`);\n }\n });\n }\n return [runOptionsHandle, allocs];\n } catch (e) {\n if (runOptionsHandle !== 0) {\n wasm2._OrtReleaseRunOptions(runOptionsHandle);\n }\n allocs.forEach((alloc) => wasm2._free(alloc));\n throw e;\n }\n };\n\n // web/lib/wasm/session-options.ts\n var getGraphOptimzationLevel = (graphOptimizationLevel) => {\n switch (graphOptimizationLevel) {\n case "disabled":\n return 0;\n case "basic":\n return 1;\n case "extended":\n return 2;\n case "all":\n return 99;\n default:\n throw new Error(`unsupported graph optimization level: ${graphOptimizationLevel}`);\n }\n };\n var getExecutionMode = (executionMode) => {\n switch (executionMode) {\n case "sequential":\n return 0;\n case "parallel":\n return 1;\n default:\n throw new Error(`unsupported execution mode: ${executionMode}`);\n }\n };\n var appendDefaultOptions = (options) => {\n if (!options.extra) {\n options.extra = {};\n }\n if (!options.extra.session) {\n options.extra.session = {};\n }\n const session = options.extra.session;\n if (!session.use_ort_model_bytes_directly) {\n session.use_ort_model_bytes_directly = "1";\n }\n if (options.executionProviders && options.executionProviders.some((ep) => (typeof ep === "string" ? ep : ep.name) === "webgpu")) {\n options.enableMemPattern = false;\n }\n };\n var setExecutionProviders = (sessionOptionsHandle, executionProviders, allocs) => {\n for (const ep of executionProviders) {\n let epName = typeof ep === "string" ? ep : ep.name;\n switch (epName) {\n case "webnn":\n epName = "WEBNN";\n if (typeof ep !== "string") {\n const webnnOptions = ep;\n if (webnnOptions?.deviceType) {\n const keyDataOffset = allocWasmString("deviceType", allocs);\n const valueDataOffset = allocWasmString(webnnOptions.deviceType, allocs);\n if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n checkLastError(`Can\'t set a session config entry: \'deviceType\' - ${webnnOptions.deviceType}.`);\n }\n }\n if (webnnOptions?.numThreads) {\n let numThreads = webnnOptions.numThreads;\n if (typeof numThreads != "number" || !Number.isInteger(numThreads) || numThreads < 0) {\n numThreads = 0;\n }\n const keyDataOffset = allocWasmString("numThreads", allocs);\n const valueDataOffset = allocWasmString(numThreads.toString(), allocs);\n if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n checkLastError(`Can\'t set a session config entry: \'numThreads\' - ${webnnOptions.numThreads}.`);\n }\n }\n if (webnnOptions?.powerPreference) {\n const keyDataOffset = allocWasmString("powerPreference", allocs);\n const valueDataOffset = allocWasmString(webnnOptions.powerPreference, allocs);\n if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n checkLastError(\n `Can\'t set a session config entry: \'powerPreference\' - ${webnnOptions.powerPreference}.`\n );\n }\n }\n }\n break;\n case "webgpu":\n epName = "JS";\n if (typeof ep !== "string") {\n const webgpuOptions = ep;\n if (webgpuOptions?.preferredLayout) {\n if (webgpuOptions.preferredLayout !== "NCHW" && webgpuOptions.preferredLayout !== "NHWC") {\n throw new Error(`preferredLayout must be either \'NCHW\' or \'NHWC\': ${webgpuOptions.preferredLayout}`);\n }\n const keyDataOffset = allocWasmString("preferredLayout", allocs);\n const valueDataOffset = allocWasmString(webgpuOptions.preferredLayout, allocs);\n if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n checkLastError(\n `Can\'t set a session config entry: \'preferredLayout\' - ${webgpuOptions.preferredLayout}.`\n );\n }\n }\n }\n break;\n case "wasm":\n case "cpu":\n continue;\n default:\n throw new Error(`not supported execution provider: ${epName}`);\n }\n const epNameDataOffset = allocWasmString(epName, allocs);\n if (getInstance()._OrtAppendExecutionProvider(sessionOptionsHandle, epNameDataOffset) !== 0) {\n checkLastError(`Can\'t append execution provider: ${epName}.`);\n }\n }\n };\n var setSessionOptions = (options) => {\n const wasm2 = getInstance();\n let sessionOptionsHandle = 0;\n const allocs = [];\n const sessionOptions = options || {};\n appendDefaultOptions(sessionOptions);\n try {\n const graphOptimizationLevel = getGraphOptimzationLevel(sessionOptions.graphOptimizationLevel ?? "all");\n const executionMode = getExecutionMode(sessionOptions.executionMode ?? "sequential");\n const logIdDataOffset = typeof sessionOptions.logId === "string" ? allocWasmString(sessionOptions.logId, allocs) : 0;\n const logSeverityLevel = sessionOptions.logSeverityLevel ?? 2;\n if (!Number.isInteger(logSeverityLevel) || logSeverityLevel < 0 || logSeverityLevel > 4) {\n throw new Error(`log serverity level is not valid: ${logSeverityLevel}`);\n }\n const logVerbosityLevel = sessionOptions.logVerbosityLevel ?? 0;\n if (!Number.isInteger(logVerbosityLevel) || logVerbosityLevel < 0 || logVerbosityLevel > 4) {\n throw new Error(`log verbosity level is not valid: ${logVerbosityLevel}`);\n }\n const optimizedModelFilePathOffset = typeof sessionOptions.optimizedModelFilePath === "string" ? allocWasmString(sessionOptions.optimizedModelFilePath, allocs) : 0;\n sessionOptionsHandle = wasm2._OrtCreateSessionOptions(\n graphOptimizationLevel,\n !!sessionOptions.enableCpuMemArena,\n !!sessionOptions.enableMemPattern,\n executionMode,\n !!sessionOptions.enableProfiling,\n 0,\n logIdDataOffset,\n logSeverityLevel,\n logVerbosityLevel,\n optimizedModelFilePathOffset\n );\n if (sessionOptionsHandle === 0) {\n checkLastError("Can\'t create session options.");\n }\n if (sessionOptions.executionProviders) {\n setExecutionProviders(sessionOptionsHandle, sessionOptions.executionProviders, allocs);\n }\n if (sessionOptions.enableGraphCapture !== void 0) {\n if (typeof sessionOptions.enableGraphCapture !== "boolean") {\n throw new Error(`enableGraphCapture must be a boolean value: ${sessionOptions.enableGraphCapture}`);\n }\n const keyDataOffset = allocWasmString("enableGraphCapture", allocs);\n const valueDataOffset = allocWasmString(sessionOptions.enableGraphCapture.toString(), allocs);\n if (wasm2._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n checkLastError(\n `Can\'t set a session config entry: \'enableGraphCapture\' - ${sessionOptions.enableGraphCapture}.`\n );\n }\n }\n if (sessionOptions.freeDimensionOverrides) {\n for (const [name, value] of Object.entries(sessionOptions.freeDimensionOverrides)) {\n if (typeof name !== "string") {\n throw new Error(`free dimension override name must be a string: ${name}`);\n }\n if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {\n throw new Error(`free dimension override value must be a non-negative integer: ${value}`);\n }\n const nameOffset = allocWasmString(name, allocs);\n if (wasm2._OrtAddFreeDimensionOverride(sessionOptionsHandle, nameOffset, value) !== 0) {\n checkLastError(`Can\'t set a free dimension override: ${name} - ${value}.`);\n }\n }\n }\n if (sessionOptions.extra !== void 0) {\n iterateExtraOptions(sessionOptions.extra, "", /* @__PURE__ */ new WeakSet(), (key, value) => {\n const keyDataOffset = allocWasmString(key, allocs);\n const valueDataOffset = allocWasmString(value, allocs);\n if (wasm2._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n checkLastError(`Can\'t set a session config entry: ${key} - ${value}.`);\n }\n });\n }\n return [sessionOptionsHandle, allocs];\n } catch (e) {\n if (sessionOptionsHandle !== 0) {\n wasm2._OrtReleaseSessionOptions(sessionOptionsHandle);\n }\n allocs.forEach((alloc) => wasm2._free(alloc));\n throw e;\n }\n };\n\n // web/lib/wasm/wasm-core-impl.ts\n init_wasm_common();\n\n // web/lib/wasm/wasm-utils-load-file.ts\n init_fs();\n\n // nodejs-ignore:node:fs/promises\n var readFile2 = void 0;\n\n // web/lib/wasm/wasm-utils-load-file.ts\n var loadFile = async (file) => {\n if (typeof file === "string") {\n if (typeof process !== "undefined" && process.versions && process.versions.node) {\n try {\n return new Uint8Array(await readFile2(file));\n } catch (e) {\n if (e.code === "ERR_FS_FILE_TOO_LARGE") {\n const stream = createReadStream(file);\n const chunks = [];\n for await (const chunk of stream) {\n chunks.push(chunk);\n }\n return new Uint8Array(Buffer.concat(chunks));\n }\n throw e;\n }\n } else {\n const response = await fetch(file);\n if (!response.ok) {\n throw new Error(`failed to load external data file: ${file}`);\n }\n const contentLengthHeader = response.headers.get("Content-Length");\n const fileSize = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;\n if (fileSize < 1073741824) {\n return new Uint8Array(await response.arrayBuffer());\n } else {\n if (!response.body) {\n throw new Error(`failed to load external data file: ${file}, no response body.`);\n }\n const reader = response.body.getReader();\n let buffer;\n try {\n buffer = new ArrayBuffer(fileSize);\n } catch (e) {\n if (e instanceof RangeError) {\n const pages = Math.ceil(fileSize / 65536);\n buffer = new WebAssembly.Memory({ initial: pages, maximum: pages }).buffer;\n } else {\n throw e;\n }\n }\n let offset = 0;\n while (true) {\n const { done, value } = await reader.read();\n if (done) {\n break;\n }\n const chunkSize = value.byteLength;\n const chunk = new Uint8Array(buffer, offset, chunkSize);\n chunk.set(value);\n offset += chunkSize;\n }\n return new Uint8Array(buffer, 0, fileSize);\n }\n }\n } else if (file instanceof Blob) {\n return new Uint8Array(await file.arrayBuffer());\n } else if (file instanceof Uint8Array) {\n return file;\n } else {\n return new Uint8Array(file);\n }\n };\n\n // web/lib/wasm/wasm-core-impl.ts\n var initOrt = (numThreads, loggingLevel) => {\n const errorCode = getInstance()._OrtInit(numThreads, loggingLevel);\n if (errorCode !== 0) {\n checkLastError("Can\'t initialize onnxruntime.");\n }\n };\n var initRuntime = async (env3) => {\n initOrt(env3.wasm.numThreads, logLevelStringToEnum(env3.logLevel));\n };\n var initEp = async (env3, epName) => {\n if (true) {\n const initJsep = (init_init(), __toCommonJS(init_exports)).init;\n if (epName === "webgpu") {\n if (typeof navigator === "undefined" || !navigator.gpu) {\n throw new Error("WebGPU is not supported in current environment");\n }\n let adapter = env3.webgpu.adapter;\n if (!adapter) {\n const powerPreference = env3.webgpu.powerPreference;\n if (powerPreference !== void 0 && powerPreference !== "low-power" && powerPreference !== "high-performance") {\n throw new Error(`Invalid powerPreference setting: "${powerPreference}"`);\n }\n const forceFallbackAdapter = env3.webgpu.forceFallbackAdapter;\n if (forceFallbackAdapter !== void 0 && typeof forceFallbackAdapter !== "boolean") {\n throw new Error(`Invalid forceFallbackAdapter setting: "${forceFallbackAdapter}"`);\n }\n adapter = await navigator.gpu.requestAdapter({ powerPreference, forceFallbackAdapter });\n if (!adapter) {\n throw new Error(\n \'Failed to get GPU adapter. You may need to enable flag "--enable-unsafe-webgpu" if you are using Chrome.\'\n );\n }\n } else {\n if (typeof adapter.limits !== "object" || typeof adapter.features !== "object" || typeof adapter.requestDevice !== "function") {\n throw new Error("Invalid GPU adapter set in `env.webgpu.adapter`. It must be a GPUAdapter object.");\n }\n }\n if (!env3.wasm.simd) {\n throw new Error(\n "Not supported for WebGPU=ON and SIMD=OFF. Please set `env.wasm.simd` to true when using `webgpu` EP"\n );\n }\n await initJsep("webgpu", getInstance(), env3, adapter);\n }\n if (epName === "webnn") {\n if (typeof navigator === "undefined" || !navigator.ml) {\n throw new Error("WebNN is not supported in current environment");\n }\n await initJsep("webnn", getInstance(), env3);\n }\n }\n };\n var activeSessions = /* @__PURE__ */ new Map();\n var getSessionInputOutputCount = (sessionHandle) => {\n const wasm2 = getInstance();\n const stack = wasm2.stackSave();\n try {\n const dataOffset = wasm2.stackAlloc(8);\n const errorCode = wasm2._OrtGetInputOutputCount(sessionHandle, dataOffset, dataOffset + 4);\n if (errorCode !== 0) {\n checkLastError("Can\'t get session input/output count.");\n }\n return [wasm2.HEAP32[dataOffset / 4], wasm2.HEAP32[dataOffset / 4 + 1]];\n } finally {\n wasm2.stackRestore(stack);\n }\n };\n var copyFromExternalBuffer = (model) => {\n const wasm2 = getInstance();\n const modelDataOffset = wasm2._malloc(model.byteLength);\n if (modelDataOffset === 0) {\n throw new Error(`Can\'t create a session. failed to allocate a buffer of size ${model.byteLength}.`);\n }\n wasm2.HEAPU8.set(model, modelDataOffset);\n return [modelDataOffset, model.byteLength];\n };\n var createSession = async (modelData, options) => {\n let modelDataOffset, modelDataLength;\n const wasm2 = getInstance();\n if (Array.isArray(modelData)) {\n [modelDataOffset, modelDataLength] = modelData;\n } else if (modelData.buffer === wasm2.HEAPU8.buffer) {\n [modelDataOffset, modelDataLength] = [modelData.byteOffset, modelData.byteLength];\n } else {\n [modelDataOffset, modelDataLength] = copyFromExternalBuffer(modelData);\n }\n let sessionHandle = 0;\n let sessionOptionsHandle = 0;\n let ioBindingHandle = 0;\n let allocs = [];\n const inputNamesUTF8Encoded = [];\n const outputNamesUTF8Encoded = [];\n try {\n [sessionOptionsHandle, allocs] = setSessionOptions(options);\n if (options?.externalData && wasm2.mountExternalData) {\n const loadingPromises = [];\n for (const file of options.externalData) {\n const path = typeof file === "string" ? file : file.path;\n loadingPromises.push(loadFile(typeof file === "string" ? file : file.data).then((data) => {\n wasm2.mountExternalData(path, data);\n }));\n }\n await Promise.all(loadingPromises);\n }\n sessionHandle = await wasm2._OrtCreateSession(modelDataOffset, modelDataLength, sessionOptionsHandle);\n if (sessionHandle === 0) {\n checkLastError("Can\'t create a session.");\n }\n const [inputCount, outputCount] = getSessionInputOutputCount(sessionHandle);\n const enableGraphCapture = !!options?.enableGraphCapture;\n const inputNames = [];\n const outputNames = [];\n const outputPreferredLocations = [];\n for (let i = 0; i < inputCount; i++) {\n const name = wasm2._OrtGetInputName(sessionHandle, i);\n if (name === 0) {\n checkLastError("Can\'t get an input name.");\n }\n inputNamesUTF8Encoded.push(name);\n inputNames.push(wasm2.UTF8ToString(name));\n }\n for (let i = 0; i < outputCount; i++) {\n const name = wasm2._OrtGetOutputName(sessionHandle, i);\n if (name === 0) {\n checkLastError("Can\'t get an output name.");\n }\n outputNamesUTF8Encoded.push(name);\n const nameString = wasm2.UTF8ToString(name);\n outputNames.push(nameString);\n if (true) {\n if (enableGraphCapture && options?.preferredOutputLocation === void 0) {\n outputPreferredLocations.push("gpu-buffer");\n continue;\n }\n const location = typeof options?.preferredOutputLocation === "string" ? options.preferredOutputLocation : options?.preferredOutputLocation?.[nameString] ?? "cpu";\n if (location !== "cpu" && location !== "cpu-pinned" && location !== "gpu-buffer") {\n throw new Error(`Not supported preferred output location: ${location}.`);\n }\n if (enableGraphCapture && location !== "gpu-buffer") {\n throw new Error(`Not supported preferred output location: ${location}. Only \'gpu-buffer\' location is supported when enableGraphCapture is true.`);\n }\n outputPreferredLocations.push(location);\n }\n }\n let bindingState = null;\n if (outputPreferredLocations.some((l) => l === "gpu-buffer")) {\n ioBindingHandle = wasm2._OrtCreateBinding(sessionHandle);\n if (ioBindingHandle === 0) {\n checkLastError("Can\'t create IO binding.");\n }\n bindingState = {\n handle: ioBindingHandle,\n outputPreferredLocations,\n outputPreferredLocationsEncoded: outputPreferredLocations.map((l) => dataLocationStringToEnum(l))\n };\n }\n activeSessions.set(\n sessionHandle,\n [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, bindingState, enableGraphCapture, false]\n );\n return [sessionHandle, inputNames, outputNames];\n } catch (e) {\n inputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf));\n outputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf));\n if (ioBindingHandle !== 0) {\n wasm2._OrtReleaseBinding(ioBindingHandle);\n }\n if (sessionHandle !== 0) {\n wasm2._OrtReleaseSession(sessionHandle);\n }\n throw e;\n } finally {\n wasm2._free(modelDataOffset);\n if (sessionOptionsHandle !== 0) {\n wasm2._OrtReleaseSessionOptions(sessionOptionsHandle);\n }\n allocs.forEach((alloc) => wasm2._free(alloc));\n wasm2.unmountExternalData?.();\n }\n };\n var releaseSession = (sessionId) => {\n const wasm2 = getInstance();\n const session = activeSessions.get(sessionId);\n if (!session) {\n throw new Error(`cannot release session. invalid session id: ${sessionId}`);\n }\n const [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture] = session;\n if (ioBindingState) {\n if (enableGraphCapture) {\n wasm2._OrtClearBoundOutputs(ioBindingState.handle);\n }\n wasm2._OrtReleaseBinding(ioBindingState.handle);\n }\n wasm2.jsepOnReleaseSession?.(sessionId);\n inputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf));\n outputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf));\n wasm2._OrtReleaseSession(sessionHandle);\n activeSessions.delete(sessionId);\n };\n var prepareInputOutputTensor = (tensor, tensorHandles, allocs, sessionId, index, enableGraphCapture = false) => {\n if (!tensor) {\n tensorHandles.push(0);\n return;\n }\n const wasm2 = getInstance();\n const dataType = tensor[0];\n const dims = tensor[1];\n const location = tensor[3];\n let rawData;\n let dataByteLength;\n if (dataType === "string" && location === "gpu-buffer") {\n throw new Error("String tensor is not supported on GPU.");\n }\n if (enableGraphCapture && location !== "gpu-buffer") {\n throw new Error(\n `External buffer must be provided for input/output index ${index} when enableGraphCapture is true.`\n );\n }\n if (location === "gpu-buffer") {\n const gpuBuffer = tensor[2].gpuBuffer;\n const elementSizeInBytes = getTensorElementSize(tensorDataTypeStringToEnum(dataType));\n dataByteLength = dims.reduce((a, b) => a * b, 1) * elementSizeInBytes;\n const registerBuffer = wasm2.jsepRegisterBuffer;\n if (!registerBuffer) {\n throw new Error(\'Tensor location "gpu-buffer" is not supported without using WebGPU.\');\n }\n rawData = registerBuffer(sessionId, index, gpuBuffer, dataByteLength);\n } else {\n const data = tensor[2];\n if (Array.isArray(data)) {\n dataByteLength = 4 * data.length;\n rawData = wasm2._malloc(dataByteLength);\n allocs.push(rawData);\n let dataIndex = rawData / 4;\n for (let i = 0; i < data.length; i++) {\n if (typeof data[i] !== "string") {\n throw new TypeError(`tensor data at index ${i} is not a string`);\n }\n wasm2.HEAPU32[dataIndex++] = allocWasmString(data[i], allocs);\n }\n } else {\n dataByteLength = data.byteLength;\n rawData = wasm2._malloc(dataByteLength);\n allocs.push(rawData);\n wasm2.HEAPU8.set(new Uint8Array(data.buffer, data.byteOffset, dataByteLength), rawData);\n }\n }\n const stack = wasm2.stackSave();\n const dimsOffset = wasm2.stackAlloc(4 * dims.length);\n try {\n let dimIndex = dimsOffset / 4;\n dims.forEach((d) => wasm2.HEAP32[dimIndex++] = d);\n const tensor2 = wasm2._OrtCreateTensor(\n tensorDataTypeStringToEnum(dataType),\n rawData,\n dataByteLength,\n dimsOffset,\n dims.length,\n dataLocationStringToEnum(location)\n );\n if (tensor2 === 0) {\n checkLastError(`Can\'t create tensor for input/output. session=${sessionId}, index=${index}.`);\n }\n tensorHandles.push(tensor2);\n } finally {\n wasm2.stackRestore(stack);\n }\n };\n var run = async (sessionId, inputIndices, inputTensors, outputIndices, outputTensors, options) => {\n const wasm2 = getInstance();\n const session = activeSessions.get(sessionId);\n if (!session) {\n throw new Error(`cannot run inference. invalid session id: ${sessionId}`);\n }\n const sessionHandle = session[0];\n const inputNamesUTF8Encoded = session[1];\n const outputNamesUTF8Encoded = session[2];\n const ioBindingState = session[3];\n const enableGraphCapture = session[4];\n const inputOutputBound = session[5];\n const inputCount = inputIndices.length;\n const outputCount = outputIndices.length;\n let runOptionsHandle = 0;\n let runOptionsAllocs = [];\n const inputTensorHandles = [];\n const outputTensorHandles = [];\n const inputOutputAllocs = [];\n const beforeRunStack = wasm2.stackSave();\n const inputValuesOffset = wasm2.stackAlloc(inputCount * 4);\n const inputNamesOffset = wasm2.stackAlloc(inputCount * 4);\n const outputValuesOffset = wasm2.stackAlloc(outputCount * 4);\n const outputNamesOffset = wasm2.stackAlloc(outputCount * 4);\n try {\n [runOptionsHandle, runOptionsAllocs] = setRunOptions(options);\n for (let i = 0; i < inputCount; i++) {\n prepareInputOutputTensor(\n inputTensors[i],\n inputTensorHandles,\n inputOutputAllocs,\n sessionId,\n inputIndices[i],\n enableGraphCapture\n );\n }\n for (let i = 0; i < outputCount; i++) {\n prepareInputOutputTensor(\n outputTensors[i],\n outputTensorHandles,\n inputOutputAllocs,\n sessionId,\n inputCount + outputIndices[i],\n enableGraphCapture\n );\n }\n let inputValuesIndex = inputValuesOffset / 4;\n let inputNamesIndex = inputNamesOffset / 4;\n let outputValuesIndex = outputValuesOffset / 4;\n let outputNamesIndex = outputNamesOffset / 4;\n for (let i = 0; i < inputCount; i++) {\n wasm2.HEAPU32[inputValuesIndex++] = inputTensorHandles[i];\n wasm2.HEAPU32[inputNamesIndex++] = inputNamesUTF8Encoded[inputIndices[i]];\n }\n for (let i = 0; i < outputCount; i++) {\n wasm2.HEAPU32[outputValuesIndex++] = outputTensorHandles[i];\n wasm2.HEAPU32[outputNamesIndex++] = outputNamesUTF8Encoded[outputIndices[i]];\n }\n if (ioBindingState && !inputOutputBound) {\n const { handle, outputPreferredLocations, outputPreferredLocationsEncoded } = ioBindingState;\n if (inputNamesUTF8Encoded.length !== inputCount) {\n throw new Error(`input count from feeds (${inputCount}) is expected to be always equal to model\'s input count (${inputNamesUTF8Encoded.length}).`);\n }\n for (let i = 0; i < inputCount; i++) {\n const index = inputIndices[i];\n const errorCode2 = await wasm2._OrtBindInput(handle, inputNamesUTF8Encoded[index], inputTensorHandles[i]);\n if (errorCode2 !== 0) {\n checkLastError(`Can\'t bind input[${i}] for session=${sessionId}.`);\n }\n }\n for (let i = 0; i < outputCount; i++) {\n const index = outputIndices[i];\n const location = outputTensors[i]?.[3];\n if (location) {\n const errorCode2 = wasm2._OrtBindOutput(handle, outputNamesUTF8Encoded[index], outputTensorHandles[i], 0);\n if (errorCode2 !== 0) {\n checkLastError(`Can\'t bind pre-allocated output[${i}] for session=${sessionId}.`);\n }\n } else {\n const errorCode2 = wasm2._OrtBindOutput(handle, outputNamesUTF8Encoded[index], 0, outputPreferredLocationsEncoded[index]);\n if (errorCode2 !== 0) {\n checkLastError(`Can\'t bind output[${i}] to ${outputPreferredLocations[i]} for session=${sessionId}.`);\n }\n }\n }\n activeSessions.set(\n sessionId,\n [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture, true]\n );\n }\n wasm2.jsepOnRunStart?.(sessionHandle);\n let errorCode;\n if (ioBindingState) {\n errorCode = await wasm2._OrtRunWithBinding(\n sessionHandle,\n ioBindingState.handle,\n outputCount,\n outputValuesOffset,\n runOptionsHandle\n );\n } else {\n errorCode = await wasm2._OrtRun(\n sessionHandle,\n inputNamesOffset,\n inputValuesOffset,\n inputCount,\n outputNamesOffset,\n outputCount,\n outputValuesOffset,\n runOptionsHandle\n );\n }\n if (errorCode !== 0) {\n checkLastError("failed to call OrtRun().");\n }\n const output = [];\n for (let i = 0; i < outputCount; i++) {\n const tensor = wasm2.HEAPU32[outputValuesOffset / 4 + i];\n if (tensor === outputTensorHandles[i]) {\n output.push(outputTensors[i]);\n continue;\n }\n const beforeGetTensorDataStack = wasm2.stackSave();\n const tensorDataOffset = wasm2.stackAlloc(4 * 4);\n let keepOutputTensor = false;\n let type, dataOffset = 0;\n try {\n const errorCode2 = wasm2._OrtGetTensorData(\n tensor,\n tensorDataOffset,\n tensorDataOffset + 4,\n tensorDataOffset + 8,\n tensorDataOffset + 12\n );\n if (errorCode2 !== 0) {\n checkLastError(`Can\'t access output tensor data on index ${i}.`);\n }\n let tensorDataIndex = tensorDataOffset / 4;\n const dataType = wasm2.HEAPU32[tensorDataIndex++];\n dataOffset = wasm2.HEAPU32[tensorDataIndex++];\n const dimsOffset = wasm2.HEAPU32[tensorDataIndex++];\n const dimsLength = wasm2.HEAPU32[tensorDataIndex++];\n const dims = [];\n for (let i2 = 0; i2 < dimsLength; i2++) {\n dims.push(wasm2.HEAPU32[dimsOffset / 4 + i2]);\n }\n wasm2._OrtFree(dimsOffset);\n const size = dims.reduce((a, b) => a * b, 1);\n type = tensorDataTypeEnumToString(dataType);\n const preferredLocation = ioBindingState?.outputPreferredLocations[outputIndices[i]];\n if (type === "string") {\n if (preferredLocation === "gpu-buffer") {\n throw new Error("String tensor is not supported on GPU.");\n }\n const stringData = [];\n let dataIndex = dataOffset / 4;\n for (let i2 = 0; i2 < size; i2++) {\n const offset = wasm2.HEAPU32[dataIndex++];\n const maxBytesToRead = i2 === size - 1 ? void 0 : wasm2.HEAPU32[dataIndex] - offset;\n stringData.push(wasm2.UTF8ToString(offset, maxBytesToRead));\n }\n output.push([type, dims, stringData, "cpu"]);\n } else {\n if (preferredLocation === "gpu-buffer" && size > 0) {\n const getBuffer = wasm2.jsepGetBuffer;\n if (!getBuffer) {\n throw new Error(\'preferredLocation "gpu-buffer" is not supported without using WebGPU.\');\n }\n const gpuBuffer = getBuffer(dataOffset);\n const elementSize = getTensorElementSize(dataType);\n if (elementSize === void 0 || !isGpuBufferSupportedType(type)) {\n throw new Error(`Unsupported data type: ${type}`);\n }\n keepOutputTensor = true;\n output.push([\n type,\n dims,\n {\n gpuBuffer,\n download: wasm2.jsepCreateDownloader(gpuBuffer, size * elementSize, type),\n dispose: () => {\n wasm2._OrtReleaseTensor(tensor);\n }\n },\n "gpu-buffer"\n ]);\n } else {\n const typedArrayConstructor = tensorTypeToTypedArrayConstructor(type);\n const data = new typedArrayConstructor(size);\n new Uint8Array(data.buffer, data.byteOffset, data.byteLength).set(wasm2.HEAPU8.subarray(dataOffset, dataOffset + data.byteLength));\n output.push([type, dims, data, "cpu"]);\n }\n }\n } finally {\n wasm2.stackRestore(beforeGetTensorDataStack);\n if (type === "string" && dataOffset) {\n wasm2._free(dataOffset);\n }\n if (!keepOutputTensor) {\n wasm2._OrtReleaseTensor(tensor);\n }\n }\n }\n if (ioBindingState && !enableGraphCapture) {\n wasm2._OrtClearBoundOutputs(ioBindingState.handle);\n activeSessions.set(\n sessionId,\n [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture, false]\n );\n }\n return output;\n } finally {\n wasm2.stackRestore(beforeRunStack);\n inputTensorHandles.forEach((v) => wasm2._OrtReleaseTensor(v));\n outputTensorHandles.forEach((v) => wasm2._OrtReleaseTensor(v));\n inputOutputAllocs.forEach((p) => wasm2._free(p));\n if (runOptionsHandle !== 0) {\n wasm2._OrtReleaseRunOptions(runOptionsHandle);\n }\n runOptionsAllocs.forEach((p) => wasm2._free(p));\n }\n };\n var endProfiling = (sessionId) => {\n const wasm2 = getInstance();\n const session = activeSessions.get(sessionId);\n if (!session) {\n throw new Error("invalid session id");\n }\n const sessionHandle = session[0];\n const profileFileName = wasm2._OrtEndProfiling(sessionHandle);\n if (profileFileName === 0) {\n checkLastError("Can\'t get an profile file name.");\n }\n wasm2._OrtFree(profileFileName);\n };\n var extractTransferableBuffers = (tensors) => {\n const buffers = [];\n for (const tensor of tensors) {\n const data = tensor[2];\n if (!Array.isArray(data) && "buffer" in data) {\n buffers.push(data.buffer);\n }\n }\n return buffers;\n };\n\n // web/lib/wasm/proxy-worker/main.ts\n self.onmessage = (ev) => {\n const { type, in: message } = ev.data;\n try {\n switch (type) {\n case "init-wasm":\n initializeWebAssembly(message.wasm).then(\n () => {\n initRuntime(message).then(\n () => {\n postMessage({ type });\n },\n (err) => {\n postMessage({ type, err });\n }\n );\n },\n (err) => {\n postMessage({ type, err });\n }\n );\n break;\n case "init-ep": {\n const { epName, env: env3 } = message;\n initEp(env3, epName).then(\n () => {\n postMessage({ type });\n },\n (err) => {\n postMessage({ type, err });\n }\n );\n break;\n }\n case "copy-from": {\n const { buffer } = message;\n const bufferData = copyFromExternalBuffer(buffer);\n postMessage({ type, out: bufferData });\n break;\n }\n case "create": {\n const { model, options } = message;\n createSession(model, options).then(\n (sessionMetadata) => {\n postMessage({ type, out: sessionMetadata });\n },\n (err) => {\n postMessage({ type, err });\n }\n );\n break;\n }\n case "release":\n releaseSession(message);\n postMessage({ type });\n break;\n case "run": {\n const { sessionId, inputIndices, inputs, outputIndices, options } = message;\n run(sessionId, inputIndices, inputs, outputIndices, new Array(outputIndices.length).fill(null), options).then(\n (outputs) => {\n if (outputs.some((o) => o[3] !== "cpu")) {\n postMessage({ type, err: "Proxy does not support non-cpu tensor location." });\n } else {\n postMessage(\n { type, out: outputs },\n extractTransferableBuffers([...inputs, ...outputs])\n );\n }\n },\n (err) => {\n postMessage({ type, err });\n }\n );\n break;\n }\n case "end-profiling":\n endProfiling(message);\n postMessage({ type });\n break;\n default:\n }\n } catch (err) {\n postMessage({ type, err });\n }\n };\n})();\n/**\n * @license\n * Copyright 2021 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the "License");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an "AS IS" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n/**\n * @license\n * Copyright 2020 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the "License");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an "AS IS" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n/**\n * @license\n * Copyright 2019 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the "License");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an "AS IS" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["nodejs-ignore:fs", "nodejs-ignore:path", "../../lib/wasm/binding/ort-wasm-simd.jsep.js", "nodejs-ignore:worker_threads", "nodejs-ignore:perf_hooks", "nodejs-ignore:os", "../../lib/wasm/binding/ort-wasm-simd-threaded.jsep.js", "../../lib/wasm/binding/ort-wasm-threaded.worker.js", "../../lib/wasm/wasm-common.ts", "../../../common/lib/backend-impl.ts", "../../../common/lib/backend.ts", "../../../common/lib/version.ts", "../../../common/lib/env-impl.ts", "../../../common/lib/env.ts", "../../../common/lib/tensor-conversion-impl.ts", "../../../common/lib/tensor-factory-impl.ts", "../../../common/lib/tensor-impl-type-mapping.ts", "../../../common/lib/tensor-utils-impl.ts", "../../../common/lib/tensor-impl.ts", "../../../common/lib/tensor.ts", "../../../common/lib/trace.ts", "../../../common/lib/inference-session-impl.ts", "../../../common/lib/inference-session.ts", "../../../common/lib/tensor-conversion.ts", "../../../common/lib/tensor-factory.ts", "../../../common/lib/onnx-model.ts", "../../../common/lib/onnx-value.ts", "../../../common/lib/training-session-impl.ts", "../../../common/lib/training-session.ts", "../../../common/lib/index.ts", "../../lib/wasm/jsep/log.ts", "../../lib/wasm/jsep/tensor-view.ts", "../../lib/wasm/jsep/webgpu/types.ts", "../../lib/wasm/jsep/webgpu/gpu-data-manager.ts", "../../lib/wasm/jsep/webgpu/attribute-with-cache-key.ts", "../../lib/wasm/jsep/util.ts", "../../lib/wasm/jsep/webgpu/ops/common.ts", "../../lib/wasm/jsep/webgpu/ops/transpose.ts", "../../lib/wasm/jsep/webgpu/ops/reduce-shared.ts", "../../lib/wasm/jsep/webgpu/ops/reduce.ts", "../../lib/wasm/jsep/webgpu/ops/argminmax.ts", "../../lib/wasm/jsep/webgpu/ops/concat.ts", "../../lib/wasm/jsep/webgpu/ops/attention.ts", "../../lib/wasm/jsep/webgpu/ops/batch-norm.ts", "../../lib/wasm/jsep/webgpu/ops/bias-add.ts", "../../lib/wasm/jsep/webgpu/ops/unary-op.ts", "../../lib/wasm/jsep/webgpu/ops/bias-split-gelu.ts", "../../lib/wasm/jsep/webgpu/ops/binary-op.ts", "../../lib/wasm/jsep/webgpu/ops/fuse-utils.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/activation_util.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/conv_util.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/matmul_packed_webgpu.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/conv2d_mm_webgpu.ts", "../../lib/wasm/jsep/webgpu/ops/conv-grouped.ts", "../../lib/wasm/jsep/webgpu/ops/matmul.ts", "../../lib/wasm/jsep/webgpu/ops/conv.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_mm_webgpu.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_webgpu.ts", "../../lib/wasm/jsep/webgpu/ops/conv-transpose.ts", "../../lib/wasm/jsep/webgpu/ops/cumsum.ts", "../../lib/wasm/jsep/webgpu/ops/depth-to-space.ts", "../../lib/wasm/jsep/webgpu/ops/einsum.ts", "../../lib/wasm/jsep/webgpu/ops/expand.ts", "../../lib/wasm/jsep/webgpu/ops/fast-gelu.ts", "../../lib/wasm/jsep/webgpu/ops/gather.ts", "../../lib/wasm/jsep/webgpu/ops/gather-elements.ts", "../../lib/wasm/jsep/webgpu/ops/gemm.ts", "../../lib/wasm/jsep/webgpu/ops/instance-norm.ts", "../../lib/wasm/jsep/webgpu/ops/layer-norm.ts", "../../lib/wasm/jsep/webgpu/ops/matmulnbits.ts", "../../lib/wasm/jsep/webgpu/ops/multihead-attentiion.ts", "../../lib/wasm/jsep/webgpu/ops/pad.ts", "../../lib/wasm/jsep/webgpu/ops/pool.ts", "../../lib/wasm/jsep/webgpu/ops/range.ts", "../../lib/wasm/jsep/webgpu/ops/resize.ts", "../../lib/wasm/jsep/webgpu/ops/rotary-embedding.ts", "../../lib/wasm/jsep/webgpu/ops/skip-layer-norm.ts", "../../lib/wasm/jsep/webgpu/ops/slice.ts", "../../lib/wasm/jsep/webgpu/ops/softmax.ts", "../../lib/wasm/jsep/webgpu/ops/split.ts", "../../lib/wasm/jsep/webgpu/ops/tile.ts", "../../lib/wasm/jsep/webgpu/ops/where.ts", "../../lib/wasm/jsep/webgpu/op-resolve-rules.ts", "../../lib/wasm/jsep/webgpu/program-manager.ts", "../../lib/wasm/jsep/backend-webgpu.ts", "../../lib/wasm/jsep/init.ts", "nodejs-ignore:node:path", "../../lib/wasm/wasm-factory.ts", "../../lib/wasm/wasm-utils.ts", "../../lib/wasm/run-options.ts", "../../lib/wasm/session-options.ts", "../../lib/wasm/wasm-core-impl.ts", "../../lib/wasm/wasm-utils-load-file.ts", "nodejs-ignore:node:fs/promises", "../../lib/wasm/proxy-worker/main.ts"],
  "sourcesContent": ["export const readFile = undefined;export const readFileSync = undefined;export const createReadStream = undefined;", "export const join = undefined;", "\nvar ortWasm = (() => {\n  var _scriptDir = typeof document != 'undefined' ? document.currentScript?.src : undefined;\n  if (typeof __filename != 'undefined') _scriptDir ||= __filename;\n  return (\nfunction(moduleArg = {}) {\n\nvar g=moduleArg,aa,ba,readyPromise=new Promise((a,b)=>{aa=a;ba=b});\"use strict\";g.mountExternalData=(a,b)=>{(g.Ph||(g.Ph=new Map)).set(a,b)};g.unmountExternalData=()=>{delete g.Ph};\nlet da=()=>{const a=(c,d,e)=>(...f)=>{const h=t,k=d?.();f=c(...f);const l=d?.();k!==l&&(c=l,e(k),d=e=null);return t!=h?ca():f},b=c=>async(...d)=>{try{if(g.Oh)throw Error(\"Session already started\");const e=g.Oh={gi:d[0],errors:[]},f=await c(...d);if(g.Oh!==e)throw Error(\"Session mismatch\");g.Uh?.flush();const h=e.errors;if(0<h.length){let k=await Promise.all(h);k=k.filter(l=>l);if(0<k.length)throw Error(k.join(\"\\n\"));}return f}finally{g.Oh=null}};g._OrtCreateSession=a(g._OrtCreateSession,()=>g._OrtCreateSession,\nc=>g._OrtCreateSession=c);g._OrtRun=b(a(g._OrtRun,()=>g._OrtRun,c=>g._OrtRun=c));g._OrtRunWithBinding=b(a(g._OrtRunWithBinding,()=>g._OrtRunWithBinding,c=>g._OrtRunWithBinding=c));g._OrtBindInput=a(g._OrtBindInput,()=>g._OrtBindInput,c=>g._OrtBindInput=c);da=void 0};\ng.jsepInit=(a,b)=>{da?.();if(\"webgpu\"===a){[g.Uh,g.Zh,g.ci,g.Vh,g.bi,g.je,g.di,g.fi,g.$h,g.ai,g.ei]=b;const c=g.Uh;g.jsepRegisterBuffer=(d,e,f,h)=>c.registerBuffer(d,e,f,h);g.jsepGetBuffer=d=>c.getBuffer(d);g.jsepCreateDownloader=(d,e,f)=>c.createDownloader(d,e,f);g.jsepOnReleaseSession=d=>{c.onReleaseSession(d)};g.jsepOnRunStart=d=>c.onRunStart(d)}};\nvar ea=Object.assign({},g),fa=\"./this.program\",ha=(a,b)=>{throw b;},ia=\"object\"==typeof window,ja=\"function\"==typeof importScripts,ka=\"object\"==typeof process&&\"object\"==typeof process.versions&&\"string\"==typeof process.versions.node,v=\"\",la,ma,na;\nif(ka){var fs=require(\"fs\"),oa=require(\"path\");v=ja?oa.dirname(v)+\"/\":__dirname+\"/\";la=(a,b)=>{a=pa(a)?new URL(a):oa.normalize(a);return fs.readFileSync(a,b?void 0:\"utf8\")};na=a=>{a=la(a,!0);a.buffer||(a=new Uint8Array(a));return a};ma=(a,b,c,d=!0)=>{a=pa(a)?new URL(a):oa.normalize(a);fs.readFile(a,d?void 0:\"utf8\",(e,f)=>{e?c(e):b(d?f.buffer:f)})};!g.thisProgram&&1<process.argv.length&&(fa=process.argv[1].replace(/\\\\/g,\"/\"));process.argv.slice(2);ha=(a,b)=>{process.exitCode=a;throw b;}}else if(ia||\nja)ja?v=self.location.href:\"undefined\"!=typeof document&&document.currentScript&&(v=document.currentScript.src),_scriptDir&&(v=_scriptDir),v.startsWith(\"blob:\")?v=\"\":v=v.substr(0,v.replace(/[?#].*/,\"\").lastIndexOf(\"/\")+1),la=a=>{var b=new XMLHttpRequest;b.open(\"GET\",a,!1);b.send(null);return b.responseText},ja&&(na=a=>{var b=new XMLHttpRequest;b.open(\"GET\",a,!1);b.responseType=\"arraybuffer\";b.send(null);return new Uint8Array(b.response)}),ma=(a,b,c)=>{var d=new XMLHttpRequest;d.open(\"GET\",a,!0);d.responseType=\n\"arraybuffer\";d.onload=()=>{200==d.status||0==d.status&&d.response?b(d.response):c()};d.onerror=c;d.send(null)};var qa=console.log.bind(console),w=console.error.bind(console);Object.assign(g,ea);ea=null;var ra,x=!1,sa,z,E,ta,ua,G,I,va,wa,xa,ya;\nfunction za(){var a=ra.buffer;g.HEAP8=z=new Int8Array(a);g.HEAP16=ta=new Int16Array(a);g.HEAPU8=E=new Uint8Array(a);g.HEAPU16=ua=new Uint16Array(a);g.HEAP32=G=new Int32Array(a);g.HEAPU32=I=new Uint32Array(a);g.HEAPF32=va=new Float32Array(a);g.HEAPF64=ya=new Float64Array(a);g.HEAP64=wa=new BigInt64Array(a);g.HEAPU64=xa=new BigUint64Array(a)}var Aa=[],Ba=[],Ca=[],Da=0,Ea=null,Fa=null;\nfunction Ga(a){a=\"Aborted(\"+a+\")\";w(a);x=!0;sa=1;a=new WebAssembly.RuntimeError(a+\". Build with -sASSERTIONS for more info.\");ba(a);throw a;}var Ha=a=>a.startsWith(\"data:application/octet-stream;base64,\"),pa=a=>a.startsWith(\"file://\"),Ia;Ia=\"ort-wasm-simd.wasm\";if(!Ha(Ia)){var Ja=Ia;Ia=g.locateFile?g.locateFile(Ja,v):v+Ja}function Ka(a){if(na)return na(a);throw\"both async and sync fetching of the wasm failed\";}\nfunction La(a){if(ia||ja){if(\"function\"==typeof fetch&&!pa(a))return fetch(a,{credentials:\"same-origin\"}).then(b=>{if(!b.ok)throw`failed to load wasm binary file at '${a}'`;return b.arrayBuffer()}).catch(()=>Ka(a));if(ma)return new Promise((b,c)=>{ma(a,d=>b(new Uint8Array(d)),c)})}return Promise.resolve().then(()=>Ka(a))}function Ma(a,b,c){return La(a).then(d=>WebAssembly.instantiate(d,b)).then(c,d=>{w(`failed to asynchronously prepare wasm: ${d}`);Ga(d)})}\nfunction Na(a,b){var c=Ia;return\"function\"!=typeof WebAssembly.instantiateStreaming||Ha(c)||pa(c)||ka||\"function\"!=typeof fetch?Ma(c,a,b):fetch(c,{credentials:\"same-origin\"}).then(d=>WebAssembly.instantiateStreaming(d,a).then(b,function(e){w(`wasm streaming compile failed: ${e}`);w(\"falling back to ArrayBuffer instantiation\");return Ma(c,a,b)}))}\nvar Oa={1261504:(a,b,c,d)=>{if(\"undefined\"==typeof g||!g.Ph)return 1;a=J(a>>>0);a.startsWith(\"./\")&&(a=a.substring(2));a=g.Ph.get(a);if(!a)return 2;b>>>=0;c>>>=0;if(b+c>a.byteLength)return 3;try{return E.set(a.subarray(b,b+c),d>>>0>>>0),0}catch{return 4}},1262005:(a,b,c)=>{c=J(c);const d=new Uint8Array(b);d.set(E.subarray(a>>>0,a+b>>>0));\"object\"==typeof process&&\"object\"==typeof process.versions&&\"string\"==typeof process.versions.node?require(\"fs\").writeFileSync(c,d):(a=new File([d],c,{type:\"application/octet-stream\"}),\na=URL.createObjectURL(a),window.open(a,\"_blank\"))},1262513:()=>{g.$h()},1262544:()=>{g.ai()},1262573:()=>{g.ei()},1262598:a=>g.Zh(a),1262631:a=>g.ci(a),1262663:(a,b,c)=>{g.Vh(a,b,c,!0)},1262702:(a,b,c)=>{g.Vh(a,b,c)},1262735:a=>{g.je(\"Abs\",a,void 0)},1262786:a=>{g.je(\"Neg\",a,void 0)},1262837:a=>{g.je(\"Floor\",a,void 0)},1262890:a=>{g.je(\"Ceil\",a,void 0)},1262942:a=>{g.je(\"Reciprocal\",a,void 0)},1263E3:a=>{g.je(\"Sqrt\",a,void 0)},1263052:a=>{g.je(\"Exp\",a,void 0)},1263103:a=>{g.je(\"Erf\",a,void 0)},1263154:a=>\n{g.je(\"Sigmoid\",a,void 0)},1263209:(a,b,c)=>{g.je(\"HardSigmoid\",a,{alpha:b,beta:c})},1263288:a=>{g.je(\"Log\",a,void 0)},1263339:a=>{g.je(\"Sin\",a,void 0)},1263390:a=>{g.je(\"Cos\",a,void 0)},1263441:a=>{g.je(\"Tan\",a,void 0)},1263492:a=>{g.je(\"Asin\",a,void 0)},1263544:a=>{g.je(\"Acos\",a,void 0)},1263596:a=>{g.je(\"Atan\",a,void 0)},1263648:a=>{g.je(\"Sinh\",a,void 0)},1263700:a=>{g.je(\"Cosh\",a,void 0)},1263752:a=>{g.je(\"Asinh\",a,void 0)},1263805:a=>{g.je(\"Acosh\",a,void 0)},1263858:a=>{g.je(\"Atanh\",a,void 0)},\n1263911:a=>{g.je(\"Tanh\",a,void 0)},1263963:a=>{g.je(\"Not\",a,void 0)},1264014:(a,b,c)=>{g.je(\"Clip\",a,{min:b,max:c})},1264083:a=>{g.je(\"Clip\",a,void 0)},1264135:(a,b)=>{g.je(\"Elu\",a,{alpha:b})},1264193:a=>{g.je(\"Relu\",a,void 0)},1264245:(a,b)=>{g.je(\"LeakyRelu\",a,{alpha:b})},1264309:(a,b)=>{g.je(\"ThresholdedRelu\",a,{alpha:b})},1264379:(a,b)=>{g.je(\"Cast\",a,{to:b})},1264437:a=>{g.je(\"Add\",a,void 0)},1264488:a=>{g.je(\"Sub\",a,void 0)},1264539:a=>{g.je(\"Mul\",a,void 0)},1264590:a=>{g.je(\"Div\",a,void 0)},\n1264641:a=>{g.je(\"Pow\",a,void 0)},1264692:a=>{g.je(\"Equal\",a,void 0)},1264745:a=>{g.je(\"Greater\",a,void 0)},1264800:a=>{g.je(\"GreaterOrEqual\",a,void 0)},1264862:a=>{g.je(\"Less\",a,void 0)},1264914:a=>{g.je(\"LessOrEqual\",a,void 0)},1264973:(a,b,c,d,e)=>{g.je(\"ReduceMean\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265132:(a,b,c,d,e)=>{g.je(\"ReduceMax\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265290:(a,b,c,d,e)=>\n{g.je(\"ReduceMin\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265448:(a,b,c,d,e)=>{g.je(\"ReduceProd\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265607:(a,b,c,d,e)=>{g.je(\"ReduceSum\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265765:(a,b,c,d,e)=>{g.je(\"ReduceL1\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265922:(a,b,c,d,e)=>\n{g.je(\"ReduceL2\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1266079:(a,b,c,d,e)=>{g.je(\"ReduceLogSum\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1266240:(a,b,c,d,e)=>{g.je(\"ReduceSumSquare\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1266404:(a,b,c,d,e)=>{g.je(\"ReduceLogSumExp\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1266568:a=>\n{g.je(\"Where\",a,void 0)},1266621:(a,b,c)=>{g.je(\"Transpose\",a,{perm:b?Array.from(G.subarray(b>>>0,c>>>0)):[]})},1266729:(a,b,c,d)=>{g.je(\"DepthToSpace\",a,{blocksize:b,mode:J(c),format:d?\"NHWC\":\"NCHW\"})},1266862:(a,b,c,d)=>{g.je(\"DepthToSpace\",a,{blocksize:b,mode:J(c),format:d?\"NHWC\":\"NCHW\"})},1266995:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>{g.je(\"ConvTranspose\",a,{format:l?\"NHWC\":\"NCHW\",autoPad:b,dilations:[c],group:d,kernelShape:[e],pads:[f,h],strides:[k],wIsConst:()=>!!z[m>>>0],outputPadding:n?Array.from(G.subarray(n>>>\n0,q>>>0)):[],outputShape:r?Array.from(G.subarray(r>>>0,p>>>0)):[],activation:J(u)})},1267396:(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>{g.je(\"ConvTranspose\",a,{format:k?\"NHWC\":\"NCHW\",autoPad:b,dilations:Array.from(G.subarray(c>>>0,(c>>>0)+2>>>0)),group:d,kernelShape:Array.from(G.subarray(e>>>0,(e>>>0)+2>>>0)),pads:Array.from(G.subarray(f>>>0,(f>>>0)+4>>>0)),strides:Array.from(G.subarray(h>>>0,(h>>>0)+2>>>0)),wIsConst:()=>!!z[l>>>0],outputPadding:m?Array.from(G.subarray(m>>>0,n>>>0)):[],outputShape:q?Array.from(G.subarray(q>>>\n0,r>>>0)):[],activation:J(p)})},1267961:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>{g.je(\"ConvTranspose\",a,{format:l?\"NHWC\":\"NCHW\",autoPad:b,dilations:[c],group:d,kernelShape:[e],pads:[f,h],strides:[k],wIsConst:()=>!!z[m>>>0],outputPadding:n?Array.from(G.subarray(n>>>0,q>>>0)):[],outputShape:r?Array.from(G.subarray(r>>>0,p>>>0)):[],activation:J(u)})},1268362:(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>{g.je(\"ConvTranspose\",a,{format:k?\"NHWC\":\"NCHW\",autoPad:b,dilations:Array.from(G.subarray(c>>>0,(c>>>0)+2>>>0)),group:d,\nkernelShape:Array.from(G.subarray(e>>>0,(e>>>0)+2>>>0)),pads:Array.from(G.subarray(f>>>0,(f>>>0)+4>>>0)),strides:Array.from(G.subarray(h>>>0,(h>>>0)+2>>>0)),wIsConst:()=>!!z[l>>>0],outputPadding:m?Array.from(G.subarray(m>>>0,n>>>0)):[],outputShape:q?Array.from(G.subarray(q>>>0,r>>>0)):[],activation:J(p)})},1268927:(a,b)=>{g.je(\"GlobalAveragePool\",a,{format:b?\"NHWC\":\"NCHW\"})},1269018:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>{g.je(\"AveragePool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:d,\nstorage_order:e,dilations:[f,h],kernel_shape:[k,l],pads:[m,n,q,r],strides:[p,u]})},1269302:(a,b)=>{g.je(\"GlobalAveragePool\",a,{format:b?\"NHWC\":\"NCHW\"})},1269393:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>{g.je(\"AveragePool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:e,dilations:[f,h],kernel_shape:[k,l],pads:[m,n,q,r],strides:[p,u]})},1269677:(a,b)=>{g.je(\"GlobalMaxPool\",a,{format:b?\"NHWC\":\"NCHW\"})},1269764:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>{g.je(\"MaxPool\",a,{format:y?\n\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:e,dilations:[f,h],kernel_shape:[k,l],pads:[m,n,q,r],strides:[p,u]})},1270044:(a,b)=>{g.je(\"GlobalMaxPool\",a,{format:b?\"NHWC\":\"NCHW\"})},1270131:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>{g.je(\"MaxPool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:e,dilations:[f,h],kernel_shape:[k,l],pads:[m,n,q,r],strides:[p,u]})},1270411:(a,b,c,d,e)=>{g.je(\"Gemm\",a,{alpha:b,beta:c,transA:d,transB:e})},1270515:a=>\n{g.je(\"MatMul\",a,void 0)},1270569:(a,b,c,d)=>{g.je(\"ArgMax\",a,{keepDims:!!b,selectLastIndex:!!c,axis:d})},1270677:(a,b,c,d)=>{g.je(\"ArgMin\",a,{keepDims:!!b,selectLastIndex:!!c,axis:d})},1270785:(a,b)=>{g.je(\"Softmax\",a,{axis:b})},1270848:(a,b)=>{g.je(\"Concat\",a,{axis:b})},1270908:(a,b,c,d,e)=>{g.je(\"Split\",a,{axis:b,numOutputs:c,splitSizes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1271048:a=>{g.je(\"Expand\",a,void 0)},1271102:(a,b)=>{g.je(\"Gather\",a,{axis:Number(b)})},1271173:(a,b)=>{g.je(\"GatherElements\",\na,{axis:Number(b)})},1271252:(a,b,c,d,e,f,h,k,l,m,n)=>{g.je(\"Resize\",a,{antialias:b,axes:c?Array.from(G.subarray(c>>>0,d>>>0)):[],coordinateTransformMode:J(e),cubicCoeffA:f,excludeOutside:h,extrapolationValue:k,keepAspectRatioPolicy:J(l),mode:J(m),nearestMode:J(n)})},1271598:(a,b,c,d,e,f,h)=>{g.je(\"Slice\",a,{starts:b?Array.from(G.subarray(b>>>0,c>>>0)):[],ends:d?Array.from(G.subarray(d>>>0,e>>>0)):[],axes:f?Array.from(G.subarray(f>>>0,h>>>0)):[]})},1271814:a=>{g.je(\"Tile\",a,void 0)},1271866:(a,b,\nc,d)=>{g.je(\"LayerNormalization\",a,{axis:b,epsilon:c,simplified:!!d})},1271977:(a,b,c)=>{g.je(\"InstanceNormalization\",a,{epsilon:b,format:c?\"NHWC\":\"NCHW\"})},1272091:(a,b,c)=>{g.je(\"InstanceNormalization\",a,{epsilon:b,format:c?\"NHWC\":\"NCHW\"})},1272205:a=>{g.je(\"Range\",a,void 0)},1272258:(a,b)=>{g.je(\"Einsum\",a,{equation:J(b)})},1272339:(a,b,c,d,e)=>{g.je(\"Pad\",a,{mode:b,value:c,pads:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1272466:(a,b,c,d,e,f)=>{g.je(\"BatchNormalization\",a,{epsilon:b,momentum:c,\nspatial:!!e,trainingMode:!!d,format:f?\"NHWC\":\"NCHW\"})},1272635:(a,b,c,d,e,f)=>{g.je(\"BatchNormalization\",a,{epsilon:b,momentum:c,spatial:!!e,trainingMode:!!d,format:f?\"NHWC\":\"NCHW\"})},1272804:(a,b,c)=>{g.je(\"CumSum\",a,{exclusive:Number(b),reverse:Number(c)})},1272901:(a,b,c,d,e,f,h,k,l)=>{g.je(\"Attention\",a,{numHeads:b,isUnidirectional:c,maskFilterValue:d,scale:e,doRotary:f,qkvHiddenSizes:h?Array.from(G.subarray(Number(k)>>>0,Number(k)+h>>>0)):[],pastPresentShareBuffer:!!l})},1273173:a=>{g.je(\"BiasAdd\",\na,void 0)},1273228:a=>{g.je(\"BiasSplitGelu\",a,void 0)},1273289:a=>{g.je(\"FastGelu\",a,void 0)},1273345:(a,b,c,d,e,f,h,k,l,m,n,q,r)=>{g.je(\"Conv\",a,{format:l?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c],group:d,kernel_shape:[e],pads:f?Array.from(G.subarray(f>>>0,h>>>0)):[],strides:[k],w_is_const:()=>!!z[m>>>0],activation:J(n),activation_params:q?Array.from(va.subarray(q>>>0,r>>>0)):[]})},1273715:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>{g.je(\"Conv\",a,{format:q?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c,d],group:e,kernel_shape:[f,\nh],pads:k?Array.from(G.subarray(k>>>0,l>>>0)):[],strides:[m,n],w_is_const:()=>!!z[r>>>0],activation:J(p),activation_params:u?Array.from(va.subarray(u>>>0,y>>>0)):[]})},1274106:a=>{g.je(\"Gelu\",a,void 0)},1274158:(a,b,c,d,e,f)=>{g.je(\"MatMulNBits\",a,{k:b,n:c,accuracyLevel:d,bits:e,blockSize:f})},1274285:(a,b,c,d,e,f)=>{g.je(\"MultiHeadAttention\",a,{numHeads:b,isUnidirectional:c,maskFilterValue:d,scale:e,doRotary:f})},1274444:(a,b,c,d,e)=>{g.je(\"RotaryEmbedding\",a,{interleaved:!!b,numHeads:c,rotaryEmbeddingDim:d,\nscale:e})},1274583:(a,b,c)=>{g.je(\"SkipLayerNormalization\",a,{epsilon:b,simplified:!!c})},1274685:(a,b,c)=>{g.je(\"SkipLayerNormalization\",a,{epsilon:b,simplified:!!c})},1274787:(a,b,c,d)=>{g.je(\"LayerNormalization\",a,{axis:b,epsilon:c,simplified:!!d})},1274898:a=>{g.di(a)},1274932:(a,b)=>g.fi(a,b,g.Oh.gi,g.Oh.errors)};function Pa(a){this.name=\"ExitStatus\";this.message=`Program terminated with exit(${a})`;this.status=a}var Qa=[],Ra=0,L=0;class Sa{constructor(a){this.Nh=a;this.Ih=a-24}}\nvar Za=a=>{var b=L;if(!b)return Ta(0),0;var c=new Sa(b);I[c.Ih+16>>>2>>>0]=b;var d=I[c.Ih+4>>>2>>>0];if(!d)return Ta(0),b;for(var e in a){var f=a[e];if(0===f||f===d)break;if(Ua(f,d,c.Ih+16))return Ta(f),b}Ta(d);return b},$a=\"undefined\"!=typeof TextDecoder?new TextDecoder(\"utf8\"):void 0,ab=(a,b,c)=>{b>>>=0;var d=b+c;for(c=b;a[c]&&!(c>=d);)++c;if(16<c-b&&a.buffer&&$a)return $a.decode(a.subarray(b,c));for(d=\"\";b<c;){var e=a[b++];if(e&128){var f=a[b++]&63;if(192==(e&224))d+=String.fromCharCode((e&31)<<\n6|f);else{var h=a[b++]&63;e=224==(e&240)?(e&15)<<12|f<<6|h:(e&7)<<18|f<<12|h<<6|a[b++]&63;65536>e?d+=String.fromCharCode(e):(e-=65536,d+=String.fromCharCode(55296|e>>10,56320|e&1023))}}else d+=String.fromCharCode(e)}return d},J=(a,b)=>(a>>>=0)?ab(E,a,b):\"\",bb=a=>{for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);127>=d?b++:2047>=d?b+=2:55296<=d&&57343>=d?(b+=4,++c):b+=3}return b},M=(a,b,c,d)=>{c>>>=0;if(!(0<d))return 0;var e=c;d=c+d-1;for(var f=0;f<a.length;++f){var h=a.charCodeAt(f);if(55296<=\nh&&57343>=h){var k=a.charCodeAt(++f);h=65536+((h&1023)<<10)|k&1023}if(127>=h){if(c>=d)break;b[c++>>>0]=h}else{if(2047>=h){if(c+1>=d)break;b[c++>>>0]=192|h>>6}else{if(65535>=h){if(c+2>=d)break;b[c++>>>0]=224|h>>12}else{if(c+3>=d)break;b[c++>>>0]=240|h>>18;b[c++>>>0]=128|h>>12&63}b[c++>>>0]=128|h>>6&63}b[c++>>>0]=128|h&63}}b[c>>>0]=0;return c-e},cb,N=a=>{for(var b=\"\";E[a>>>0];)b+=cb[E[a++>>>0]];return b},db={},eb={},fb={},O;\nfunction gb(a,b,c={}){var d=b.name;if(!a)throw new O(`type \"${d}\" must have a positive integer typeid pointer`);if(eb.hasOwnProperty(a)){if(c.Xh)return;throw new O(`Cannot register type '${d}' twice`);}eb[a]=b;delete fb[a];db.hasOwnProperty(a)&&(b=db[a],delete db[a],b.forEach(e=>e()))}function P(a,b,c={}){if(!(\"argPackAdvance\"in b))throw new TypeError(\"registerType registeredInstance requires argPackAdvance\");return gb(a,b,c)}\nvar hb=(a,b,c)=>{switch(b){case 1:return c?d=>z[d>>>0]:d=>E[d>>>0];case 2:return c?d=>ta[d>>>1>>>0]:d=>ua[d>>>1>>>0];case 4:return c?d=>G[d>>>2>>>0]:d=>I[d>>>2>>>0];case 8:return c?d=>wa[d>>>3]:d=>xa[d>>>3];default:throw new TypeError(`invalid integer width (${b}): ${a}`);}},ib=[],Q=[];function jb(a){a>>>=0;9<a&&0===--Q[a+1]&&(Q[a]=void 0,ib.push(a))}\nvar R=a=>{if(!a)throw new O(\"Cannot use deleted val. handle = \"+a);return Q[a]},S=a=>{switch(a){case void 0:return 2;case null:return 4;case !0:return 6;case !1:return 8;default:const b=ib.pop()||Q.length;Q[b]=a;Q[b+1]=1;return b}};function kb(a){return this.fromWireType(I[a>>>2>>>0])}\nvar lb={name:\"emscripten::val\",fromWireType:a=>{var b=R(a);jb(a);return b},toWireType:(a,b)=>S(b),argPackAdvance:8,readValueFromPointer:kb,Mh:null},mb=(a,b)=>{switch(b){case 4:return function(c){return this.fromWireType(va[c>>>2>>>0])};case 8:return function(c){return this.fromWireType(ya[c>>>3>>>0])};default:throw new TypeError(`invalid float width (${b}): ${a}`);}},nb=\"undefined\"!=typeof TextDecoder?new TextDecoder(\"utf-16le\"):void 0,ob=(a,b)=>{var c=a>>1;for(var d=c+b/2;!(c>=d)&&ua[c>>>0];)++c;\nc<<=1;if(32<c-a&&nb)return nb.decode(E.subarray(a>>>0,c>>>0));c=\"\";for(d=0;!(d>=b/2);++d){var e=ta[a+2*d>>>1>>>0];if(0==e)break;c+=String.fromCharCode(e)}return c},pb=(a,b,c)=>{c??=2147483647;if(2>c)return 0;c-=2;var d=b;c=c<2*a.length?c/2:a.length;for(var e=0;e<c;++e)ta[b>>>1>>>0]=a.charCodeAt(e),b+=2;ta[b>>>1>>>0]=0;return b-d},qb=a=>2*a.length,rb=(a,b)=>{for(var c=0,d=\"\";!(c>=b/4);){var e=G[a+4*c>>>2>>>0];if(0==e)break;++c;65536<=e?(e-=65536,d+=String.fromCharCode(55296|e>>10,56320|e&1023)):d+=\nString.fromCharCode(e)}return d},sb=(a,b,c)=>{b>>>=0;c??=2147483647;if(4>c)return 0;var d=b;c=d+c-4;for(var e=0;e<a.length;++e){var f=a.charCodeAt(e);if(55296<=f&&57343>=f){var h=a.charCodeAt(++e);f=65536+((f&1023)<<10)|h&1023}G[b>>>2>>>0]=f;b+=4;if(b+4>c)break}G[b>>>2>>>0]=0;return b-d},tb=a=>{for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);55296<=d&&57343>=d&&++c;b+=4}return b},vb=(a,b)=>{var c=eb[a];if(void 0===c)throw a=ub(a),c=N(a),T(a),new O(`${b} has unknown type ${c}`);return c},wb=\n(a,b,c)=>{var d=[];a=a.toWireType(d,c);d.length&&(I[b>>>2>>>0]=S(d));return a},xb=a=>{try{a()}catch(b){Ga(b)}},yb=a=>{if(!x)try{a();try{sa=sa=a=sa,g.onExit?.(a),x=!0,ha(a,new Pa(a))}catch(b){b instanceof Pa||\"unwind\"==b||ha(1,b)}}catch(b){b instanceof Pa||\"unwind\"==b||ha(1,b)}};\nfunction zb(){var a=U,b={};for(let [c,d]of Object.entries(a))b[c]=\"function\"==typeof d?(...e)=>{Ab.push(c);try{return d(...e)}finally{x||(Ab.pop(),t&&1===V&&0===Ab.length&&(V=0,xb(Bb),\"undefined\"!=typeof Fibers&&Fibers.mi()))}}:d;return b}var V=0,t=null,Cb=0,Ab=[],Db={},Eb={},Fb=0,Gb=null,Hb=[];function ca(){return new Promise((a,b)=>{Gb={resolve:a,reject:b}})}\nfunction Ib(){var a=Jb(65548),b=a+12;I[a>>>2>>>0]=b;I[a+4>>>2>>>0]=b+65536;b=Ab[0];var c=Db[b];void 0===c&&(c=Fb++,Db[b]=c,Eb[c]=b);G[a+8>>>2>>>0]=c;return a}\nfunction Kb(a){if(!x){if(0===V){var b=!1,c=!1;a((d=0)=>{if(!x&&(Cb=d,b=!0,c)){V=2;xb(()=>Lb(t));\"undefined\"!=typeof Browser&&Browser.Sh.Wh&&Browser.Sh.resume();d=!1;try{var e=(0,U[Eb[G[t+8>>>2>>>0]]])()}catch(k){e=k,d=!0}var f=!1;if(!t){var h=Gb;h&&(Gb=null,(d?h.reject:h.resolve)(e),f=!0)}if(d&&!f)throw e;}});c=!0;b||(V=1,t=Ib(),\"undefined\"!=typeof Browser&&Browser.Sh.Wh&&Browser.Sh.pause(),xb(()=>Mb(t)))}else 2===V?(V=0,xb(Nb),T(t),t=null,Hb.forEach(yb)):Ga(`invalid state: ${V}`);return Cb}}\nfunction Ob(a){return Kb(b=>{a().then(b)})}var Pb=[],Qb={},Rb=a=>{var b=Qb[a];return void 0===b?N(a):b},Sb=()=>\"object\"==typeof globalThis?globalThis:Function(\"return this\")(),Tb=a=>{var b=Pb.length;Pb.push(a);return b},Ub=(a,b)=>{for(var c=Array(a),d=0;d<a;++d)c[d]=vb(I[b+4*d>>>2>>>0],\"parameter \"+d);return c},Vb=(a,b)=>Object.defineProperty(b,\"name\",{value:a});\nfunction Wb(a){var b=Function;if(!(b instanceof Function))throw new TypeError(`new_ called with constructor type ${typeof b} which is not a function`);var c=Vb(b.name||\"unknownFunctionName\",function(){});c.prototype=b.prototype;c=new c;a=b.apply(c,a);return a instanceof Object?a:c}\nvar W=a=>0===a%4&&(0!==a%100||0===a%400),Xb=[0,31,60,91,121,152,182,213,244,274,305,335],Yb=[0,31,59,90,120,151,181,212,243,273,304,334],Zb=[],$b=(a,b)=>{Zb.length=0;for(var c;c=E[a++>>>0];){var d=105!=c;d&=112!=c;b+=d&&b%8?4:0;Zb.push(112==c?I[b>>>2>>>0]:106==c?wa[b>>>3]:105==c?G[b>>>2>>>0]:ya[b>>>3>>>0]);b+=d?8:4}return Zb},ac={},cc=()=>{if(!bc){var a={USER:\"web_user\",LOGNAME:\"web_user\",PATH:\"/\",PWD:\"/\",HOME:\"/home/web_user\",LANG:(\"object\"==typeof navigator&&navigator.languages&&navigator.languages[0]||\n\"C\").replace(\"-\",\"_\")+\".UTF-8\",_:fa||\"./this.program\"},b;for(b in ac)void 0===ac[b]?delete a[b]:a[b]=ac[b];var c=[];for(b in a)c.push(`${b}=${a[b]}`);bc=c}return bc},bc,dc=[null,[],[]],ec=[31,29,31,30,31,30,31,31,30,31,30,31],fc=[31,28,31,30,31,30,31,31,30,31,30,31];function gc(a){var b=Array(bb(a)+1);M(a,b,0,b.length);return b}\nfunction hc(a,b,c,d){function e(p,u,y){for(p=\"number\"==typeof p?p.toString():p||\"\";p.length<u;)p=y[0]+p;return p}function f(p,u){return e(p,u,\"0\")}function h(p,u){function y(B){return 0>B?-1:0<B?1:0}var A;0===(A=y(p.getFullYear()-u.getFullYear()))&&0===(A=y(p.getMonth()-u.getMonth()))&&(A=y(p.getDate()-u.getDate()));return A}function k(p){switch(p.getDay()){case 0:return new Date(p.getFullYear()-1,11,29);case 1:return p;case 2:return new Date(p.getFullYear(),0,3);case 3:return new Date(p.getFullYear(),\n0,2);case 4:return new Date(p.getFullYear(),0,1);case 5:return new Date(p.getFullYear()-1,11,31);case 6:return new Date(p.getFullYear()-1,11,30)}}function l(p){var u=p.Kh;for(p=new Date((new Date(p.Lh+1900,0,1)).getTime());0<u;){var y=p.getMonth(),A=(W(p.getFullYear())?ec:fc)[y];if(u>A-p.getDate())u-=A-p.getDate()+1,p.setDate(1),11>y?p.setMonth(y+1):(p.setMonth(0),p.setFullYear(p.getFullYear()+1));else{p.setDate(p.getDate()+u);break}}y=new Date(p.getFullYear()+1,0,4);u=k(new Date(p.getFullYear(),\n0,4));y=k(y);return 0>=h(u,p)?0>=h(y,p)?p.getFullYear()+1:p.getFullYear():p.getFullYear()-1}a>>>=0;b>>>=0;c>>>=0;d>>>=0;var m=I[d+40>>>2>>>0];d={ji:G[d>>>2>>>0],ii:G[d+4>>>2>>>0],Qh:G[d+8>>>2>>>0],Th:G[d+12>>>2>>>0],Rh:G[d+16>>>2>>>0],Lh:G[d+20>>>2>>>0],Jh:G[d+24>>>2>>>0],Kh:G[d+28>>>2>>>0],li:G[d+32>>>2>>>0],hi:G[d+36>>>2>>>0],ki:m?J(m):\"\"};c=J(c);m={\"%c\":\"%a %b %d %H:%M:%S %Y\",\"%D\":\"%m/%d/%y\",\"%F\":\"%Y-%m-%d\",\"%h\":\"%b\",\"%r\":\"%I:%M:%S %p\",\"%R\":\"%H:%M\",\"%T\":\"%H:%M:%S\",\"%x\":\"%m/%d/%y\",\"%X\":\"%H:%M:%S\",\n\"%Ec\":\"%c\",\"%EC\":\"%C\",\"%Ex\":\"%m/%d/%y\",\"%EX\":\"%H:%M:%S\",\"%Ey\":\"%y\",\"%EY\":\"%Y\",\"%Od\":\"%d\",\"%Oe\":\"%e\",\"%OH\":\"%H\",\"%OI\":\"%I\",\"%Om\":\"%m\",\"%OM\":\"%M\",\"%OS\":\"%S\",\"%Ou\":\"%u\",\"%OU\":\"%U\",\"%OV\":\"%V\",\"%Ow\":\"%w\",\"%OW\":\"%W\",\"%Oy\":\"%y\"};for(var n in m)c=c.replace(new RegExp(n,\"g\"),m[n]);var q=\"Sunday Monday Tuesday Wednesday Thursday Friday Saturday\".split(\" \"),r=\"January February March April May June July August September October November December\".split(\" \");m={\"%a\":p=>q[p.Jh].substring(0,3),\"%A\":p=>q[p.Jh],\"%b\":p=>\nr[p.Rh].substring(0,3),\"%B\":p=>r[p.Rh],\"%C\":p=>f((p.Lh+1900)/100|0,2),\"%d\":p=>f(p.Th,2),\"%e\":p=>e(p.Th,2,\" \"),\"%g\":p=>l(p).toString().substring(2),\"%G\":l,\"%H\":p=>f(p.Qh,2),\"%I\":p=>{p=p.Qh;0==p?p=12:12<p&&(p-=12);return f(p,2)},\"%j\":p=>{for(var u=0,y=0;y<=p.Rh-1;u+=(W(p.Lh+1900)?ec:fc)[y++]);return f(p.Th+u,3)},\"%m\":p=>f(p.Rh+1,2),\"%M\":p=>f(p.ii,2),\"%n\":()=>\"\\n\",\"%p\":p=>0<=p.Qh&&12>p.Qh?\"AM\":\"PM\",\"%S\":p=>f(p.ji,2),\"%t\":()=>\"\\t\",\"%u\":p=>p.Jh||7,\"%U\":p=>f(Math.floor((p.Kh+7-p.Jh)/7),2),\"%V\":p=>{var u=\nMath.floor((p.Kh+7-(p.Jh+6)%7)/7);2>=(p.Jh+371-p.Kh-2)%7&&u++;if(u)53==u&&(y=(p.Jh+371-p.Kh)%7,4==y||3==y&&W(p.Lh)||(u=1));else{u=52;var y=(p.Jh+7-p.Kh-1)%7;(4==y||5==y&&W(p.Lh%400-1))&&u++}return f(u,2)},\"%w\":p=>p.Jh,\"%W\":p=>f(Math.floor((p.Kh+7-(p.Jh+6)%7)/7),2),\"%y\":p=>(p.Lh+1900).toString().substring(2),\"%Y\":p=>p.Lh+1900,\"%z\":p=>{p=p.hi;var u=0<=p;p=Math.abs(p)/60;return(u?\"+\":\"-\")+String(\"0000\"+(p/60*100+p%60)).slice(-4)},\"%Z\":p=>p.ki,\"%%\":()=>\"%\"};c=c.replace(/%%/g,\"\\x00\\x00\");for(n in m)c.includes(n)&&\n(c=c.replace(new RegExp(n,\"g\"),m[n](d)));c=c.replace(/\\0\\0/g,\"%\");n=gc(c);if(n.length>b)return 0;z.set(n,a>>>0);return n.length-1}for(var ic=Array(256),jc=0;256>jc;++jc)ic[jc]=String.fromCharCode(jc);cb=ic;O=g.BindingError=class extends Error{constructor(a){super(a);this.name=\"BindingError\"}};g.InternalError=class extends Error{constructor(a){super(a);this.name=\"InternalError\"}};Q.push(0,1,void 0,1,null,1,!0,1,!1,1);g.count_emval_handles=()=>Q.length/2-5-ib.length;\nvar Cf={bd:function(a,b,c){return Ob(async()=>{await g.bi(a,b,c)})},v:function(a){a=new Sa(a>>>0);0==z[a.Ih+12>>>0]&&(z[a.Ih+12>>>0]=1,Ra--);z[a.Ih+13>>>0]=0;Qa.push(a);kc(a.Nh);if(lc(I[a.Ih+4>>>2>>>0]))a=I[a.Nh>>>2>>>0];else{var b=I[a.Ih+16>>>2>>>0];a=0!==b?b:a.Nh}return a},N:()=>{X(0,0);var a=Qa.pop();mc(a.Nh);L=0},a:function(){return Za([])},m:function(a){return Za([a>>>0])},x:function(a,b){return Za([a>>>0,b>>>0])},q:function(a,b,c){return Za([a>>>0,b>>>0,c>>>0])},Bb:()=>{var a=Qa.pop();a||Ga(\"no exception to throw\");\nvar b=a.Nh;0==z[a.Ih+13>>>0]&&(Qa.push(a),z[a.Ih+13>>>0]=1,z[a.Ih+12>>>0]=0,Ra++);L=b;throw L;},s:function(a,b,c){a>>>=0;var d=new Sa(a);I[d.Ih+16>>>2>>>0]=0;I[d.Ih+4>>>2>>>0]=b>>>0;I[d.Ih+8>>>2>>>0]=c>>>0;L=a;Ra++;throw L;},fb:()=>Ra,g:function(a){L||=a>>>0;throw L;},Cb:function(){return 0},$c:function(){},Mc:function(){},Oc:function(){},Gc:function(){return 0},Zc:function(){},Uc:function(){},Yc:function(){},_b:function(){},Nc:function(){},Kc:function(){},_c:function(){},Lc:function(){},Wb:function(a,\nb,c){b=N(b>>>0);P(a>>>0,{name:b,fromWireType:d=>d,toWireType:function(d,e){if(\"bigint\"!=typeof e&&\"number\"!=typeof e)throw null===e?e=\"null\":(d=typeof e,e=\"object\"===d||\"array\"===d||\"function\"===d?e.toString():\"\"+e),new TypeError(`Cannot convert \"${e}\" to ${this.name}`);\"number\"==typeof e&&(e=BigInt(e));return e},argPackAdvance:8,readValueFromPointer:hb(b,c>>>0,-1==b.indexOf(\"u\")),Mh:null})},Ec:function(a,b,c,d){b=N(b>>>0);P(a>>>0,{name:b,fromWireType:function(e){return!!e},toWireType:function(e,\nf){return f?c:d},argPackAdvance:8,readValueFromPointer:function(e){return this.fromWireType(E[e>>>0])},Mh:null})},Cc:function(a){return P(a>>>0,lb)},Vb:function(a,b,c){b=N(b>>>0);P(a>>>0,{name:b,fromWireType:d=>d,toWireType:(d,e)=>e,argPackAdvance:8,readValueFromPointer:mb(b,c>>>0),Mh:null})},Aa:function(a,b,c,d,e){a>>>=0;c>>>=0;b=N(b>>>0);-1===e&&(e=4294967295);e=k=>k;if(0===d){var f=32-8*c;e=k=>k<<f>>>f}var h=b.includes(\"unsigned\")?function(k,l){return l>>>0}:function(k,l){return l};P(a,{name:b,\nfromWireType:e,toWireType:h,argPackAdvance:8,readValueFromPointer:hb(b,c,0!==d),Mh:null})},_:function(a,b,c){function d(f){return new e(z.buffer,I[f+4>>>2>>>0],I[f>>>2>>>0])}var e=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,BigInt64Array,BigUint64Array][b];c=N(c>>>0);P(a>>>0,{name:c,fromWireType:d,argPackAdvance:8,readValueFromPointer:d},{Xh:!0})},Xb:function(a,b){b=N(b>>>0);var c=\"std::string\"===b;P(a>>>0,{name:b,fromWireType:function(d){var e=I[d>>>\n2>>>0],f=d+4;if(c)for(var h=f,k=0;k<=e;++k){var l=f+k;if(k==e||0==E[l>>>0]){h=J(h,l-h);if(void 0===m)var m=h;else m+=String.fromCharCode(0),m+=h;h=l+1}}else{m=Array(e);for(k=0;k<e;++k)m[k]=String.fromCharCode(E[f+k>>>0]);m=m.join(\"\")}T(d);return m},toWireType:function(d,e){e instanceof ArrayBuffer&&(e=new Uint8Array(e));var f=\"string\"==typeof e;if(!(f||e instanceof Uint8Array||e instanceof Uint8ClampedArray||e instanceof Int8Array))throw new O(\"Cannot pass non-string to std::string\");var h=c&&f?bb(e):\ne.length;var k=Jb(4+h+1),l=k+4;I[k>>>2>>>0]=h;if(c&&f)M(e,E,l,h+1);else if(f)for(f=0;f<h;++f){var m=e.charCodeAt(f);if(255<m)throw T(l),new O(\"String has UTF-16 code units that do not fit in 8 bits\");E[l+f>>>0]=m}else for(f=0;f<h;++f)E[l+f>>>0]=e[f];null!==d&&d.push(T,k);return k},argPackAdvance:8,readValueFromPointer:kb,Mh(d){T(d)}})},Ab:function(a,b,c){b>>>=0;c>>>=0;c=N(c);if(2===b){var d=ob;var e=pb;var f=qb;var h=k=>ua[k>>>1>>>0]}else 4===b&&(d=rb,e=sb,f=tb,h=k=>I[k>>>2>>>0]);P(a>>>0,{name:c,\nfromWireType:k=>{for(var l=I[k>>>2>>>0],m,n=k+4,q=0;q<=l;++q){var r=k+4+q*b;if(q==l||0==h(r))n=d(n,r-n),void 0===m?m=n:(m+=String.fromCharCode(0),m+=n),n=r+b}T(k);return m},toWireType:(k,l)=>{if(\"string\"!=typeof l)throw new O(`Cannot pass non-string to C++ string type ${c}`);var m=f(l),n=Jb(4+m+b);I[n>>>2>>>0]=m/b;e(l,n+4,m+b);null!==k&&k.push(T,n);return n},argPackAdvance:8,readValueFromPointer:kb,Mh(k){T(k)}})},Fc:function(a,b){b=N(b>>>0);P(a>>>0,{Yh:!0,name:b,argPackAdvance:0,fromWireType:()=>\n{},toWireType:()=>{}})},ad:()=>1,kd:function(a,b,c){b>>>=0;c>>>=0;a=R(a>>>0);b=vb(b,\"emval::as\");return wb(b,c,a)},Cd:function(a){a>>>=0;return Ob(()=>{a=R(a);return a.then(S)})},ud:function(a,b,c,d){c>>>=0;d>>>=0;a=Pb[a>>>0];b=R(b>>>0);return a(null,b,c,d)},ia:function(a,b,c,d,e){c>>>=0;d>>>=0;e>>>=0;a=Pb[a>>>0];b=R(b>>>0);c=Rb(c);return a(b,b[c],d,e)},Bc:jb,qd:function(a,b){b>>>=0;a=R(a>>>0);b=R(b);return a==b},zd:function(a){a>>>=0;if(0===a)return S(Sb());a=Rb(a);return S(Sb()[a])},ha:function(a,\nb,c){b=Ub(a,b>>>0);var d=b.shift();a--;var e=\"return function (obj, func, destructorsRef, args) {\\n\",f=0,h=[];0===c&&h.push(\"obj\");for(var k=[\"retType\"],l=[d],m=0;m<a;++m)h.push(\"arg\"+m),k.push(\"argType\"+m),l.push(b[m]),e+=`  var arg${m} = argType${m}.readValueFromPointer(args${f?\"+\"+f:\"\"});\\n`,f+=b[m].argPackAdvance;e+=`  var rv = ${1===c?\"new func\":\"func.call\"}(${h.join(\", \")});\\n`;d.Yh||(k.push(\"emval_returnValue\"),l.push(wb),e+=\"  return emval_returnValue(retType, destructorsRef, rv);\\n\");k.push(e+\n\"};\\n\");a=Wb(k)(...l);c=`methodCaller<(${b.map(n=>n.name).join(\", \")}) => ${d.name}>`;return Tb(Vb(c,a))},yd:function(a,b){b>>>=0;a=R(a>>>0);b=R(b);return S(a[b])},ba:function(a){a>>>=0;9<a&&(Q[a+1]+=1)},md:function(){return S([])},hd:function(a){a=R(a>>>0);for(var b=Array(a.length),c=0;c<a.length;c++)b[c]=a[c];return S(b)},U:function(a){return S(Rb(a>>>0))},Xa:function(){return S({})},vd:function(a){a>>>=0;for(var b=R(a);b.length;){var c=b.pop();b.pop()(c)}jb(a)},sd:function(a,b,c){b>>>=0;c>>>=0;\na=R(a>>>0);b=R(b);c=R(c);a[b]=c},zb:function(a,b){b>>>=0;a=vb(a>>>0,\"_emval_take_value\");a=a.readValueFromPointer(b);return S(a)},Rc:function(a,b){a=-9007199254740992>a||9007199254740992<a?NaN:Number(a);b>>>=0;a=new Date(1E3*a);G[b>>>2>>>0]=a.getUTCSeconds();G[b+4>>>2>>>0]=a.getUTCMinutes();G[b+8>>>2>>>0]=a.getUTCHours();G[b+12>>>2>>>0]=a.getUTCDate();G[b+16>>>2>>>0]=a.getUTCMonth();G[b+20>>>2>>>0]=a.getUTCFullYear()-1900;G[b+24>>>2>>>0]=a.getUTCDay();G[b+28>>>2>>>0]=(a.getTime()-Date.UTC(a.getUTCFullYear(),\n0,1,0,0,0,0))/864E5|0},Sc:function(a,b){a=-9007199254740992>a||9007199254740992<a?NaN:Number(a);b>>>=0;a=new Date(1E3*a);G[b>>>2>>>0]=a.getSeconds();G[b+4>>>2>>>0]=a.getMinutes();G[b+8>>>2>>>0]=a.getHours();G[b+12>>>2>>>0]=a.getDate();G[b+16>>>2>>>0]=a.getMonth();G[b+20>>>2>>>0]=a.getFullYear()-1900;G[b+24>>>2>>>0]=a.getDay();G[b+28>>>2>>>0]=(W(a.getFullYear())?Xb:Yb)[a.getMonth()]+a.getDate()-1|0;G[b+36>>>2>>>0]=-(60*a.getTimezoneOffset());var c=(new Date(a.getFullYear(),6,1)).getTimezoneOffset(),\nd=(new Date(a.getFullYear(),0,1)).getTimezoneOffset();G[b+32>>>2>>>0]=(c!=d&&a.getTimezoneOffset()==Math.min(d,c))|0},Tc:function(a){a>>>=0;var b=new Date(G[a+20>>>2>>>0]+1900,G[a+16>>>2>>>0],G[a+12>>>2>>>0],G[a+8>>>2>>>0],G[a+4>>>2>>>0],G[a>>>2>>>0],0),c=G[a+32>>>2>>>0],d=b.getTimezoneOffset(),e=(new Date(b.getFullYear(),6,1)).getTimezoneOffset(),f=(new Date(b.getFullYear(),0,1)).getTimezoneOffset(),h=Math.min(f,e);0>c?G[a+32>>>2>>>0]=Number(e!=f&&h==d):0<c!=(h==d)&&(e=Math.max(f,e),b.setTime(b.getTime()+\n6E4*((0<c?h:e)-d)));G[a+24>>>2>>>0]=b.getDay();G[a+28>>>2>>>0]=(W(b.getFullYear())?Xb:Yb)[b.getMonth()]+b.getDate()-1|0;G[a>>>2>>>0]=b.getSeconds();G[a+4>>>2>>>0]=b.getMinutes();G[a+8>>>2>>>0]=b.getHours();G[a+12>>>2>>>0]=b.getDate();G[a+16>>>2>>>0]=b.getMonth();G[a+20>>>2>>>0]=b.getYear();a=b.getTime();return BigInt(isNaN(a)?-1:a/1E3)},Pc:function(){return-52},Qc:function(){},Ic:function(a,b,c,d){c>>>=0;d>>>=0;var e=(new Date).getFullYear(),f=new Date(e,0,1),h=new Date(e,6,1);e=f.getTimezoneOffset();\nvar k=h.getTimezoneOffset();I[a>>>0>>>2>>>0]=60*Math.max(e,k);G[b>>>0>>>2>>>0]=Number(e!=k);a=l=>l.toLocaleTimeString(void 0,{hour12:!1,timeZoneName:\"short\"}).split(\" \")[1];f=a(f);h=a(h);k<e?(M(f,E,c,17),M(h,E,d,17)):(M(f,E,d,17),M(h,E,c,17))},bb:()=>{Ga(\"\")},A:function(a,b,c){a>>>=0;b=$b(b>>>0,c>>>0);return Oa[a](...b)},bc:function(a,b,c){a>>>=0;b=$b(b>>>0,c>>>0);return Oa[a](...b)},$b:()=>Date.now(),Jc:function(){return 4294901760},ga:()=>performance.now(),Hc:function(a){a>>>=0;var b=E.length;if(4294901760<\na)return!1;for(var c=1;4>=c;c*=2){var d=b*(1+.2/c);d=Math.min(d,a+100663296);var e=Math;d=Math.max(a,d);a:{e=(e.min.call(e,4294901760,d+(65536-d%65536)%65536)-ra.buffer.byteLength+65535)/65536;try{ra.grow(e);za();var f=1;break a}catch(h){}f=void 0}if(f)return!0}return!1},Wc:function(a,b){a>>>=0;b>>>=0;var c=0;cc().forEach((d,e)=>{var f=b+c;e=I[a+4*e>>>2>>>0]=f;for(f=0;f<d.length;++f)z[e++>>>0]=d.charCodeAt(f);z[e>>>0]=0;c+=d.length+1});return 0},Xc:function(a,b){a>>>=0;b>>>=0;var c=cc();I[a>>>2>>>\n0]=c.length;var d=0;c.forEach(e=>d+=e.length+1);I[b>>>2>>>0]=d;return 0},Db:()=>52,Zb:function(){return 52},Vc:function(){return 70},Yb:function(a,b,c,d){b>>>=0;c>>>=0;d>>>=0;for(var e=0,f=0;f<c;f++){var h=I[b>>>2>>>0],k=I[b+4>>>2>>>0];b+=8;for(var l=0;l<k;l++){var m=E[h+l>>>0],n=dc[a];0===m||10===m?((1===a?qa:w)(ab(n,0)),n.length=0):n.push(m)}e+=k}I[d>>>2>>>0]=e;return 0},xb:nc,cd:oc,ua:pc,W:qc,$:rc,ra:sc,ta:tc,dd:uc,ob:vc,P:wc,z:xc,b:yc,Ub:zc,ya:Ac,e:Bc,kb:Cc,h:Dc,X:Ec,i:Fc,ed:Gc,j:Hc,t:Ic,r:Jc,\no:Kc,Wa:Lc,Ca:Mc,ma:Nc,Qb:Oc,db:Pc,Ib:Qc,mb:Rc,kc:Sc,xc:Tc,hc:Uc,ic:Vc,ac:Wc,oa:Xc,yb:Yc,Ba:Zc,Eb:$c,ea:ad,jc:bd,Ta:cd,F:dd,G:ed,Gb:fd,jd:gd,qa:hd,O:jd,V:kd,T:ld,y:md,Fb:nd,gc:od,D:pd,Hb:qd,id:rd,Ua:sd,wa:td,lc:ud,cc:vd,Nb:wd,aa:xd,I:yd,C:zd,_a:Ad,fc:Bd,Q:Cd,d:Dd,ab:Ed,n:Fd,Ya:Gd,va:Hd,wb:Id,f:Jd,yc:Kd,da:Ld,gb:Md,Da:Nd,lb:Od,hb:Pd,c:Qd,vc:Rd,od:Sd,k:Td,tc:Ud,l:Vd,wc:Wd,sc:Xd,rd:Yd,p:Zd,Ra:$d,tb:ae,Qa:be,Kb:ce,B:de,K:ee,S:fe,$a:ge,pc:he,ub:ie,za:je,ka:ke,xa:le,Sb:me,La:ne,jb:oe,Ga:pe,nc:qe,Ha:re,\nIa:se,fd:te,xd:ue,Z:ve,pa:we,pd:xe,wd:ye,Mb:ze,Ma:Ae,Ka:Be,Tb:Ce,rc:De,Ja:Ee,Na:Fe,pb:Ge,la:He,Ea:Ie,mc:Je,qc:Ke,Jb:Le,Fa:Me,ja:Ne,Ad:Oe,nd:Pe,R:Qe,eb:Re,Za:Se,ec:Te,ib:Ue,E:Ve,M:We,Va:Xe,ld:Ye,ca:Ze,nb:$e,na:af,dc:bf,Ac:cf,u:df,L:ef,td:ff,Pb:gf,oc:hf,Bd:jf,Ob:kf,Lb:lf,cb:mf,zc:nf,Rb:of,Oa:pf,Y:qf,uc:rf,J:sf,gd:tf,vb:uf,sa:vf,H:wf,rb:xf,Pa:yf,Sa:zf,sb:Af,qb:Bf,w:function(a){return a>>>0},Dc:hc,fa:function(a,b,c,d){return hc(a>>>0,b>>>0,c>>>0,d>>>0)}},U=function(){function a(c){U=c.exports;U=zb();\nU=Df();ra=U.Dd;za();Ba.unshift(U.Ed);Da--;0==Da&&(null!==Ea&&(clearInterval(Ea),Ea=null),Fa&&(c=Fa,Fa=null,c()));return U}var b={a:Cf};Da++;if(g.instantiateWasm)try{return g.instantiateWasm(b,a)}catch(c){w(`Module.instantiateWasm callback failed with error: ${c}`),ba(c)}Na(b,function(c){a(c.instance)}).catch(ba);return{}}(),ub=a=>(ub=U.Fd)(a);g._OrtInit=(a,b)=>(g._OrtInit=U.Gd)(a,b);g._OrtGetLastError=(a,b)=>(g._OrtGetLastError=U.Hd)(a,b);\ng._OrtCreateSessionOptions=(a,b,c,d,e,f,h,k,l,m)=>(g._OrtCreateSessionOptions=U.Id)(a,b,c,d,e,f,h,k,l,m);g._OrtAppendExecutionProvider=(a,b)=>(g._OrtAppendExecutionProvider=U.Jd)(a,b);g._OrtAddFreeDimensionOverride=(a,b,c)=>(g._OrtAddFreeDimensionOverride=U.Kd)(a,b,c);g._OrtAddSessionConfigEntry=(a,b,c)=>(g._OrtAddSessionConfigEntry=U.Ld)(a,b,c);g._OrtReleaseSessionOptions=a=>(g._OrtReleaseSessionOptions=U.Md)(a);g._OrtCreateSession=(a,b,c)=>(g._OrtCreateSession=U.Nd)(a,b,c);\ng._OrtReleaseSession=a=>(g._OrtReleaseSession=U.Od)(a);g._OrtGetInputOutputCount=(a,b,c)=>(g._OrtGetInputOutputCount=U.Pd)(a,b,c);g._OrtGetInputName=(a,b)=>(g._OrtGetInputName=U.Qd)(a,b);g._OrtGetOutputName=(a,b)=>(g._OrtGetOutputName=U.Rd)(a,b);g._OrtFree=a=>(g._OrtFree=U.Sd)(a);g._OrtCreateTensor=(a,b,c,d,e,f)=>(g._OrtCreateTensor=U.Td)(a,b,c,d,e,f);g._OrtGetTensorData=(a,b,c,d,e)=>(g._OrtGetTensorData=U.Ud)(a,b,c,d,e);g._OrtReleaseTensor=a=>(g._OrtReleaseTensor=U.Vd)(a);\ng._OrtCreateRunOptions=(a,b,c,d)=>(g._OrtCreateRunOptions=U.Wd)(a,b,c,d);g._OrtAddRunConfigEntry=(a,b,c)=>(g._OrtAddRunConfigEntry=U.Xd)(a,b,c);g._OrtReleaseRunOptions=a=>(g._OrtReleaseRunOptions=U.Yd)(a);g._OrtCreateBinding=a=>(g._OrtCreateBinding=U.Zd)(a);g._OrtBindInput=(a,b,c)=>(g._OrtBindInput=U._d)(a,b,c);g._OrtBindOutput=(a,b,c,d)=>(g._OrtBindOutput=U.$d)(a,b,c,d);g._OrtClearBoundOutputs=a=>(g._OrtClearBoundOutputs=U.ae)(a);g._OrtReleaseBinding=a=>(g._OrtReleaseBinding=U.be)(a);\ng._OrtRunWithBinding=(a,b,c,d,e)=>(g._OrtRunWithBinding=U.ce)(a,b,c,d,e);g._OrtRun=(a,b,c,d,e,f,h,k)=>(g._OrtRun=U.de)(a,b,c,d,e,f,h,k);g._OrtEndProfiling=a=>(g._OrtEndProfiling=U.ee)(a);g._JsepOutput=(a,b,c)=>(g._JsepOutput=U.fe)(a,b,c);g._JsepGetNodeName=a=>(g._JsepGetNodeName=U.ge)(a);\nvar Jb=g._malloc=a=>(Jb=g._malloc=U.he)(a),T=g._free=a=>(T=g._free=U.ie)(a),X=(a,b)=>(X=U.ke)(a,b),Ta=a=>(Ta=U.le)(a),Y=a=>(Y=U.me)(a),Ef=a=>(Ef=U.ne)(a),Z=()=>(Z=U.oe)(),mc=a=>(mc=U.pe)(a),kc=a=>(kc=U.qe)(a),Ua=(a,b,c)=>(Ua=U.re)(a,b,c),lc=a=>(lc=U.se)(a),dynCall_vii=g.dynCall_vii=(a,b,c)=>(dynCall_vii=g.dynCall_vii=U.te)(a,b,c),Ff=g.dynCall_iiii=(a,b,c,d)=>(Ff=g.dynCall_iiii=U.ue)(a,b,c,d),dynCall_iii=g.dynCall_iii=(a,b,c)=>(dynCall_iii=g.dynCall_iii=U.ve)(a,b,c),Gf=g.dynCall_ii=(a,b)=>(Gf=g.dynCall_ii=\nU.we)(a,b),Hf=g.dynCall_iiiiiii=(a,b,c,d,e,f,h)=>(Hf=g.dynCall_iiiiiii=U.xe)(a,b,c,d,e,f,h),dynCall_vi=g.dynCall_vi=(a,b)=>(dynCall_vi=g.dynCall_vi=U.ye)(a,b),dynCall_v=g.dynCall_v=a=>(dynCall_v=g.dynCall_v=U.ze)(a),If=g.dynCall_iiiiii=(a,b,c,d,e,f)=>(If=g.dynCall_iiiiii=U.Ae)(a,b,c,d,e,f),Jf=g.dynCall_iiij=(a,b,c,d)=>(Jf=g.dynCall_iiij=U.Be)(a,b,c,d),Kf=g.dynCall_iiiii=(a,b,c,d,e)=>(Kf=g.dynCall_iiiii=U.Ce)(a,b,c,d,e),Lf=g.dynCall_viii=(a,b,c,d)=>(Lf=g.dynCall_viii=U.De)(a,b,c,d),Mf=g.dynCall_viiiii=\n(a,b,c,d,e,f)=>(Mf=g.dynCall_viiiii=U.Ee)(a,b,c,d,e,f),Nf=g.dynCall_viiii=(a,b,c,d,e)=>(Nf=g.dynCall_viiii=U.Fe)(a,b,c,d,e),Of=g.dynCall_viiiiii=(a,b,c,d,e,f,h)=>(Of=g.dynCall_viiiiii=U.Ge)(a,b,c,d,e,f,h),Pf=g.dynCall_viiji=(a,b,c,d,e)=>(Pf=g.dynCall_viiji=U.He)(a,b,c,d,e),Qf=g.dynCall_viiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q)=>(Qf=g.dynCall_viiiiiiiiiii=U.Ie)(a,b,c,d,e,f,h,k,l,m,n,q),Rf=g.dynCall_viiijjjii=(a,b,c,d,e,f,h,k,l)=>(Rf=g.dynCall_viiijjjii=U.Je)(a,b,c,d,e,f,h,k,l),Sf=g.dynCall_iid=(a,b,c)=>\n(Sf=g.dynCall_iid=U.Ke)(a,b,c),Tf=g.dynCall_iif=(a,b,c)=>(Tf=g.dynCall_iif=U.Le)(a,b,c),Uf=g.dynCall_iij=(a,b,c)=>(Uf=g.dynCall_iij=U.Me)(a,b,c),Vf=g.dynCall_jii=(a,b,c)=>(Vf=g.dynCall_jii=U.Ne)(a,b,c),Wf=g.dynCall_i=a=>(Wf=g.dynCall_i=U.Oe)(a),Xf=g.dynCall_viiiiiiii=(a,b,c,d,e,f,h,k,l)=>(Xf=g.dynCall_viiiiiiii=U.Pe)(a,b,c,d,e,f,h,k,l),Yf=g.dynCall_viiiiij=(a,b,c,d,e,f,h)=>(Yf=g.dynCall_viiiiij=U.Qe)(a,b,c,d,e,f,h),Zf=g.dynCall_ji=(a,b)=>(Zf=g.dynCall_ji=U.Re)(a,b),$f=g.dynCall_viij=(a,b,c,d)=>($f=\ng.dynCall_viij=U.Se)(a,b,c,d),ag=g.dynCall_iiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q)=>(ag=g.dynCall_iiiiiiiiiiii=U.Te)(a,b,c,d,e,f,h,k,l,m,n,q),bg=g.dynCall_viiiiiiiii=(a,b,c,d,e,f,h,k,l,m)=>(bg=g.dynCall_viiiiiiiii=U.Ue)(a,b,c,d,e,f,h,k,l,m),cg=g.dynCall_ij=(a,b)=>(cg=g.dynCall_ij=U.Ve)(a,b),dg=g.dynCall_iiiiij=(a,b,c,d,e,f)=>(dg=g.dynCall_iiiiij=U.We)(a,b,c,d,e,f),eg=g.dynCall_j=a=>(eg=g.dynCall_j=U.Xe)(a),fg=g.dynCall_vij=(a,b,c)=>(fg=g.dynCall_vij=U.Ye)(a,b,c),gg=g.dynCall_viijjjiiiiii=(a,b,c,d,\ne,f,h,k,l,m,n,q)=>(gg=g.dynCall_viijjjiiiiii=U.Ze)(a,b,c,d,e,f,h,k,l,m,n,q),hg=g.dynCall_viiijiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q)=>(hg=g.dynCall_viiijiiiiiii=U._e)(a,b,c,d,e,f,h,k,l,m,n,q),ig=g.dynCall_iiiiiiii=(a,b,c,d,e,f,h,k)=>(ig=g.dynCall_iiiiiiii=U.$e)(a,b,c,d,e,f,h,k),jg=g.dynCall_viiiiiii=(a,b,c,d,e,f,h,k)=>(jg=g.dynCall_viiiiiii=U.af)(a,b,c,d,e,f,h,k),kg=g.dynCall_iiiiiiiij=(a,b,c,d,e,f,h,k,l)=>(kg=g.dynCall_iiiiiiiij=U.bf)(a,b,c,d,e,f,h,k,l),lg=g.dynCall_viiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,\nm,n,q,r,p)=>(lg=g.dynCall_viiiiiiiiiiiii=U.cf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),mg=g.dynCall_iiiiiiiii=(a,b,c,d,e,f,h,k,l)=>(mg=g.dynCall_iiiiiiiii=U.df)(a,b,c,d,e,f,h,k,l),ng=g.dynCall_iiiiijiiiii=(a,b,c,d,e,f,h,k,l,m,n)=>(ng=g.dynCall_iiiiijiiiii=U.ef)(a,b,c,d,e,f,h,k,l,m,n),og=g.dynCall_vijjjiiij=(a,b,c,d,e,f,h,k,l)=>(og=g.dynCall_vijjjiiij=U.ff)(a,b,c,d,e,f,h,k,l),pg=g.dynCall_fi=(a,b)=>(pg=g.dynCall_fi=U.gf)(a,b),qg=g.dynCall_fii=(a,b,c)=>(qg=g.dynCall_fii=U.hf)(a,b,c),rg=g.dynCall_di=(a,b)=>(rg=\ng.dynCall_di=U.jf)(a,b),sg=g.dynCall_dii=(a,b,c)=>(sg=g.dynCall_dii=U.kf)(a,b,c),tg=g.dynCall_vijj=(a,b,c,d)=>(tg=g.dynCall_vijj=U.lf)(a,b,c,d),ug=g.dynCall_iiiiiiiiii=(a,b,c,d,e,f,h,k,l,m)=>(ug=g.dynCall_iiiiiiiiii=U.mf)(a,b,c,d,e,f,h,k,l,m),vg=g.dynCall_viijiii=(a,b,c,d,e,f,h)=>(vg=g.dynCall_viijiii=U.nf)(a,b,c,d,e,f,h),wg=g.dynCall_viid=(a,b,c,d)=>(wg=g.dynCall_viid=U.of)(a,b,c,d),xg=g.dynCall_viffiii=(a,b,c,d,e,f,h)=>(xg=g.dynCall_viffiii=U.pf)(a,b,c,d,e,f,h),yg=g.dynCall_viifiii=(a,b,c,d,e,f,\nh)=>(yg=g.dynCall_viifiii=U.qf)(a,b,c,d,e,f,h),zg=g.dynCall_viiiiidiidi=(a,b,c,d,e,f,h,k,l,m,n)=>(zg=g.dynCall_viiiiidiidi=U.rf)(a,b,c,d,e,f,h,k,l,m,n),Ag=g.dynCall_viiiiiiiiidi=(a,b,c,d,e,f,h,k,l,m,n,q)=>(Ag=g.dynCall_viiiiiiiiidi=U.sf)(a,b,c,d,e,f,h,k,l,m,n,q),Bg=g.dynCall_jiii=(a,b,c,d)=>(Bg=g.dynCall_jiii=U.tf)(a,b,c,d),Cg=g.dynCall_vjiiiiii=(a,b,c,d,e,f,h,k)=>(Cg=g.dynCall_vjiiiiii=U.uf)(a,b,c,d,e,f,h,k),Dg=g.dynCall_viiid=(a,b,c,d,e)=>(Dg=g.dynCall_viiid=U.vf)(a,b,c,d,e),Eg=g.dynCall_viiiiiiiiiji=\n(a,b,c,d,e,f,h,k,l,m,n,q)=>(Eg=g.dynCall_viiiiiiiiiji=U.wf)(a,b,c,d,e,f,h,k,l,m,n,q),Fg=g.dynCall_viji=(a,b,c,d)=>(Fg=g.dynCall_viji=U.xf)(a,b,c,d),Gg=g.dynCall_vijjjjjjjjjjjjji=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>(Gg=g.dynCall_vijjjjjjjjjjjjji=U.yf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y),Hg=g.dynCall_viiiji=(a,b,c,d,e,f)=>(Hg=g.dynCall_viiiji=U.zf)(a,b,c,d,e,f),Ig=g.dynCall_vijjjiiji=(a,b,c,d,e,f,h,k,l)=>(Ig=g.dynCall_vijjjiiji=U.Af)(a,b,c,d,e,f,h,k,l),Jg=g.dynCall_iiiji=(a,b,c,d,e)=>(Jg=g.dynCall_iiiji=\nU.Bf)(a,b,c,d,e),Kg=g.dynCall_iiijiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(Kg=g.dynCall_iiijiiiiiiiiii=U.Cf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),Lg=g.dynCall_vj=(a,b)=>(Lg=g.dynCall_vj=U.Df)(a,b),Mg=g.dynCall_jjj=(a,b,c)=>(Mg=g.dynCall_jjj=U.Ef)(a,b,c),Ng=g.dynCall_iiijiiiiii=(a,b,c,d,e,f,h,k,l,m)=>(Ng=g.dynCall_iiijiiiiii=U.Ff)(a,b,c,d,e,f,h,k,l,m),Og=g.dynCall_vfiii=(a,b,c,d,e)=>(Og=g.dynCall_vfiii=U.Gf)(a,b,c,d,e),Pg=g.dynCall_viiiiff=(a,b,c,d,e,f,h)=>(Pg=g.dynCall_viiiiff=U.Hf)(a,b,c,d,e,f,h),Qg=g.dynCall_viiiiiff=\n(a,b,c,d,e,f,h,k)=>(Qg=g.dynCall_viiiiiff=U.If)(a,b,c,d,e,f,h,k),Rg=g.dynCall_viiff=(a,b,c,d,e)=>(Rg=g.dynCall_viiff=U.Jf)(a,b,c,d,e),Sg=g.dynCall_viiiiiiiiifiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(Sg=g.dynCall_viiiiiiiiifiii=U.Kf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),Tg=g.dynCall_viiiiiiiijj=(a,b,c,d,e,f,h,k,l,m,n)=>(Tg=g.dynCall_viiiiiiiijj=U.Lf)(a,b,c,d,e,f,h,k,l,m,n),Ug=g.dynCall_iiiiiiiiiiiiiifii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)=>(Ug=g.dynCall_iiiiiiiiiiiiiifii=U.Mf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A),\nVg=g.dynCall_viiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Vg=g.dynCall_viiiiiiiiiiii=U.Nf)(a,b,c,d,e,f,h,k,l,m,n,q,r),Wg=g.dynCall_iiiiiiiiiiiiiiiiifii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)=>(Wg=g.dynCall_iiiiiiiiiiiiiiiiifii=U.Of)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D),Xg=g.dynCall_vijjiiiiii=(a,b,c,d,e,f,h,k,l,m)=>(Xg=g.dynCall_vijjiiiiii=U.Pf)(a,b,c,d,e,f,h,k,l,m),Yg=g.dynCall_iiiijjj=(a,b,c,d,e,f,h)=>(Yg=g.dynCall_iiiijjj=U.Qf)(a,b,c,d,e,f,h),Zg=g.dynCall_viiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,\nn)=>(Zg=g.dynCall_viiiiiiiiii=U.Rf)(a,b,c,d,e,f,h,k,l,m,n),$g=g.dynCall_iiijjj=(a,b,c,d,e,f)=>($g=g.dynCall_iiijjj=U.Sf)(a,b,c,d,e,f),ah=g.dynCall_fffffff=(a,b,c,d,e,f,h)=>(ah=g.dynCall_fffffff=U.Tf)(a,b,c,d,e,f,h),bh=g.dynCall_viiiij=(a,b,c,d,e,f)=>(bh=g.dynCall_viiiij=U.Uf)(a,b,c,d,e,f),ch=g.dynCall_viiiiiijiifiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(ch=g.dynCall_viiiiiijiifiii=U.Vf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),dh=g.dynCall_vjjjjjjffjifiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B)=>(dh=g.dynCall_vjjjjjjffjifiiiiii=\nU.Wf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B),eh=g.dynCall_viiiiiiffjifiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)=>(eh=g.dynCall_viiiiiiffjifiiiii=U.Xf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A),fh=g.dynCall_viiiiiiffjfiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>(fh=g.dynCall_viiiiiiffjfiiiii=U.Yf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y),gh=g.dynCall_viiiiiiffjiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>(gh=g.dynCall_viiiiiiffjiiiii=U.Zf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u),hh=g.dynCall_vjjjjjjjjfffiiifiiiii=(a,b,c,d,e,f,h,k,l,\nm,n,q,r,p,u,y,A,B,C,D,F)=>(hh=g.dynCall_vjjjjjjjjfffiiifiiiii=U._f)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F),ih=g.dynCall_vjjjjjjfffifijiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C)=>(ih=g.dynCall_vjjjjjjfffifijiiiii=U.$f)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C),jh=g.dynCall_vjjjjjjfffifiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B)=>(jh=g.dynCall_vjjjjjjfffifiiiiii=U.ag)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B),kh=g.dynCall_vjjjjjjjjfffjifiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F)=>(kh=g.dynCall_vjjjjjjjjfffjifiiiiii=\nU.bg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F),lh=g.dynCall_vijiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(lh=g.dynCall_vijiiiiiiiiii=U.cg)(a,b,c,d,e,f,h,k,l,m,n,q,r),mh=g.dynCall_vijjfffiii=(a,b,c,d,e,f,h,k,l,m)=>(mh=g.dynCall_vijjfffiii=U.dg)(a,b,c,d,e,f,h,k,l,m),nh=g.dynCall_viiiiiiijiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(nh=g.dynCall_viiiiiiijiiii=U.eg)(a,b,c,d,e,f,h,k,l,m,n,q,r),oh=g.dynCall_vijjjjjjifiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>(oh=g.dynCall_vijjjjjjifiiiii=U.fg)(a,b,c,d,e,f,h,k,l,m,n,\nq,r,p,u),ph=g.dynCall_viifi=(a,b,c,d,e)=>(ph=g.dynCall_viifi=U.gg)(a,b,c,d,e),qh=g.dynCall_vjjjjjiiii=(a,b,c,d,e,f,h,k,l,m)=>(qh=g.dynCall_vjjjjjiiii=U.hg)(a,b,c,d,e,f,h,k,l,m),rh=g.dynCall_vjjjjfiii=(a,b,c,d,e,f,h,k,l)=>(rh=g.dynCall_vjjjjfiii=U.ig)(a,b,c,d,e,f,h,k,l),sh=g.dynCall_viiiiiijiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(sh=g.dynCall_viiiiiijiiiiii=U.jg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),th=g.dynCall_vijjii=(a,b,c,d,e,f)=>(th=g.dynCall_vijjii=U.kg)(a,b,c,d,e,f),uh=g.dynCall_viiiiijjiiiii=(a,b,c,\nd,e,f,h,k,l,m,n,q,r)=>(uh=g.dynCall_viiiiijjiiiii=U.lg)(a,b,c,d,e,f,h,k,l,m,n,q,r),vh=g.dynCall_iiiiiji=(a,b,c,d,e,f,h)=>(vh=g.dynCall_iiiiiji=U.mg)(a,b,c,d,e,f,h),wh=g.dynCall_iiiiji=(a,b,c,d,e,f)=>(wh=g.dynCall_iiiiji=U.ng)(a,b,c,d,e,f),xh=g.dynCall_viiiiijiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(xh=g.dynCall_viiiiijiiiiii=U.og)(a,b,c,d,e,f,h,k,l,m,n,q,r),yh=g.dynCall_viiijiiiiii=(a,b,c,d,e,f,h,k,l,m,n)=>(yh=g.dynCall_viiijiiiiii=U.pg)(a,b,c,d,e,f,h,k,l,m,n),zh=g.dynCall_viijj=(a,b,c,d,e)=>(zh=g.dynCall_viijj=\nU.qg)(a,b,c,d,e),Ah=g.dynCall_viiiijii=(a,b,c,d,e,f,h,k)=>(Ah=g.dynCall_viiiijii=U.rg)(a,b,c,d,e,f,h,k),Bh=g.dynCall_viijjiii=(a,b,c,d,e,f,h,k)=>(Bh=g.dynCall_viijjiii=U.sg)(a,b,c,d,e,f,h,k),Ch=g.dynCall_ijii=(a,b,c,d)=>(Ch=g.dynCall_ijii=U.tg)(a,b,c,d),Dh=g.dynCall_viiiiijjji=(a,b,c,d,e,f,h,k,l,m)=>(Dh=g.dynCall_viiiiijjji=U.ug)(a,b,c,d,e,f,h,k,l,m),Eh=g.dynCall_vijjjjiij=(a,b,c,d,e,f,h,k,l)=>(Eh=g.dynCall_vijjjjiij=U.vg)(a,b,c,d,e,f,h,k,l),Fh=g.dynCall_viiiiijij=(a,b,c,d,e,f,h,k,l)=>(Fh=g.dynCall_viiiiijij=\nU.wg)(a,b,c,d,e,f,h,k,l),Gh=g.dynCall_viiiiiijij=(a,b,c,d,e,f,h,k,l,m)=>(Gh=g.dynCall_viiiiiijij=U.xg)(a,b,c,d,e,f,h,k,l,m),Hh=g.dynCall_vijiii=(a,b,c,d,e,f)=>(Hh=g.dynCall_vijiii=U.yg)(a,b,c,d,e,f),Ih=g.dynCall_viiiiiiiiifi=(a,b,c,d,e,f,h,k,l,m,n,q)=>(Ih=g.dynCall_viiiiiiiiifi=U.zg)(a,b,c,d,e,f,h,k,l,m,n,q),Jh=g.dynCall_iiijiiii=(a,b,c,d,e,f,h,k)=>(Jh=g.dynCall_iiijiiii=U.Ag)(a,b,c,d,e,f,h,k),Kh=g.dynCall_viiiiiijjiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(Kh=g.dynCall_viiiiiijjiiiii=U.Bg)(a,b,c,d,e,\nf,h,k,l,m,n,q,r,p),Lh=g.dynCall_viiiiiiijiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>(Lh=g.dynCall_viiiiiiijiiiiii=U.Cg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u),Mh=g.dynCall_vif=(a,b,c)=>(Mh=g.dynCall_vif=U.Dg)(a,b,c),Nh=g.dynCall_viif=(a,b,c,d)=>(Nh=g.dynCall_viif=U.Eg)(a,b,c,d),Oh=g.dynCall_fiii=(a,b,c,d)=>(Oh=g.dynCall_fiii=U.Fg)(a,b,c,d),Ph=g.dynCall_diii=(a,b,c,d)=>(Ph=g.dynCall_diii=U.Gg)(a,b,c,d),Qh=g.dynCall_viiiiiifii=(a,b,c,d,e,f,h,k,l,m)=>(Qh=g.dynCall_viiiiiifii=U.Hg)(a,b,c,d,e,f,h,k,l,m),Rh=g.dynCall_viiiiijiiiiiiiiiiiiiiiiiii=\n(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F,H,K,Va,Wa,Xa)=>(Rh=g.dynCall_viiiiijiiiiiiiiiiiiiiiiiii=U.Ig)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F,H,K,Va,Wa,Xa),Sh=g.dynCall_viijji=(a,b,c,d,e,f)=>(Sh=g.dynCall_viijji=U.Jg)(a,b,c,d,e,f),Th=g.dynCall_iiiiiiiiiiiji=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Th=g.dynCall_iiiiiiiiiiiji=U.Kg)(a,b,c,d,e,f,h,k,l,m,n,q,r),Uh=g.dynCall_viifiifijjjii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Uh=g.dynCall_viifiifijjjii=U.Lg)(a,b,c,d,e,f,h,k,l,m,n,q,r),Vh=g.dynCall_viiiiiiiiiiiiiiiiiiii=\n(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F)=>(Vh=g.dynCall_viiiiiiiiiiiiiiiiiiii=U.Mg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F),Wh=g.dynCall_viiiiifiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Wh=g.dynCall_viiiiifiiiiii=U.Ng)(a,b,c,d,e,f,h,k,l,m,n,q,r),Xh=g.dynCall_vijiiiiiiijjii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(Xh=g.dynCall_vijiiiiiiijjii=U.Og)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),Yh=g.dynCall_viiiiiiiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C)=>(Yh=g.dynCall_viiiiiiiiiiiiiiiiii=U.Pg)(a,b,c,d,e,f,h,k,l,\nm,n,q,r,p,u,y,A,B,C),Zh=g.dynCall_viiiiiiiiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)=>(Zh=g.dynCall_viiiiiiiiiiiiiiiiiii=U.Qg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D),$h=g.dynCall_viiiiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>($h=g.dynCall_viiiiiiiiiiiiiii=U.Rg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y),ai=g.dynCall_viiiiiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)=>(ai=g.dynCall_viiiiiiiiiiiiiiii=U.Sg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A),bi=g.dynCall_viiiijjj=(a,b,c,d,e,f,h,k)=>(bi=\ng.dynCall_viiiijjj=U.Tg)(a,b,c,d,e,f,h,k),ci=g.dynCall_iiiiid=(a,b,c,d,e,f)=>(ci=g.dynCall_iiiiid=U.Ug)(a,b,c,d,e,f),di=g.dynCall_viiiiiiijjj=(a,b,c,d,e,f,h,k,l,m,n)=>(di=g.dynCall_viiiiiiijjj=U.Vg)(a,b,c,d,e,f,h,k,l,m,n),ei=g.dynCall_iiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n)=>(ei=g.dynCall_iiiiiiiiiii=U.Wg)(a,b,c,d,e,f,h,k,l,m,n),fi=g.dynCall_iiiiiiiiiiiiiiiiiifi=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)=>(fi=g.dynCall_iiiiiiiiiiiiiiiiiifi=U.Xg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D),gi=g.dynCall_viiif=\n(a,b,c,d,e)=>(gi=g.dynCall_viiif=U.Yg)(a,b,c,d,e),hi=g.dynCall_viiijiiiii=(a,b,c,d,e,f,h,k,l,m)=>(hi=g.dynCall_viiijiiiii=U.Zg)(a,b,c,d,e,f,h,k,l,m),ii=g.dynCall_viiij=(a,b,c,d,e)=>(ii=g.dynCall_viiij=U._g)(a,b,c,d,e),ji=g.dynCall_iijjj=(a,b,c,d,e)=>(ji=g.dynCall_iijjj=U.$g)(a,b,c,d,e),ki=g.dynCall_viiiiji=(a,b,c,d,e,f,h)=>(ki=g.dynCall_viiiiji=U.ah)(a,b,c,d,e,f,h),li=g.dynCall_iijjji=(a,b,c,d,e,f)=>(li=g.dynCall_iijjji=U.bh)(a,b,c,d,e,f),mi=g.dynCall_ijijji=(a,b,c,d,e,f)=>(mi=g.dynCall_ijijji=U.ch)(a,\nb,c,d,e,f),ni=g.dynCall_viiijjiii=(a,b,c,d,e,f,h,k,l)=>(ni=g.dynCall_viiijjiii=U.dh)(a,b,c,d,e,f,h,k,l),oi=g.dynCall_iiiiijji=(a,b,c,d,e,f,h,k)=>(oi=g.dynCall_iiiiijji=U.eh)(a,b,c,d,e,f,h,k),pi=g.dynCall_iiiifi=(a,b,c,d,e,f)=>(pi=g.dynCall_iiiifi=U.fh)(a,b,c,d,e,f),qi=g.dynCall_iiijii=(a,b,c,d,e,f)=>(qi=g.dynCall_iiijii=U.gh)(a,b,c,d,e,f),ri=g.dynCall_iiiiiiiiijii=(a,b,c,d,e,f,h,k,l,m,n,q)=>(ri=g.dynCall_iiiiiiiiijii=U.hh)(a,b,c,d,e,f,h,k,l,m,n,q),si=g.dynCall_iiiijjii=(a,b,c,d,e,f,h,k)=>(si=g.dynCall_iiiijjii=\nU.ih)(a,b,c,d,e,f,h,k),ti=g.dynCall_iiiiiijjjii=(a,b,c,d,e,f,h,k,l,m,n)=>(ti=g.dynCall_iiiiiijjjii=U.jh)(a,b,c,d,e,f,h,k,l,m,n),ui=g.dynCall_iiijiii=(a,b,c,d,e,f,h)=>(ui=g.dynCall_iiijiii=U.kh)(a,b,c,d,e,f,h),vi=g.dynCall_iiiiiiiijjjfi=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(vi=g.dynCall_iiiiiiiijjjfi=U.lh)(a,b,c,d,e,f,h,k,l,m,n,q,r),wi=g.dynCall_iijiiii=(a,b,c,d,e,f,h)=>(wi=g.dynCall_iijiiii=U.mh)(a,b,c,d,e,f,h),xi=g.dynCall_iijjjii=(a,b,c,d,e,f,h)=>(xi=g.dynCall_iijjjii=U.nh)(a,b,c,d,e,f,h),yi=g.dynCall_jij=\n(a,b,c)=>(yi=g.dynCall_jij=U.oh)(a,b,c),zi=g.dynCall_iiji=(a,b,c,d)=>(zi=g.dynCall_iiji=U.ph)(a,b,c,d),Ai=g.dynCall_iiif=(a,b,c,d)=>(Ai=g.dynCall_iiif=U.qh)(a,b,c,d),Bi=g.dynCall_vidi=(a,b,c,d)=>(Bi=g.dynCall_vidi=U.rh)(a,b,c,d),Ci=g.dynCall_vjiii=(a,b,c,d,e)=>(Ci=g.dynCall_vjiii=U.sh)(a,b,c,d,e),Di=g.dynCall_diiii=(a,b,c,d,e)=>(Di=g.dynCall_diiii=U.th)(a,b,c,d,e),Ei=g.dynCall_diiiii=(a,b,c,d,e,f)=>(Ei=g.dynCall_diiiii=U.uh)(a,b,c,d,e,f),Fi=g.dynCall_viiijjiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q)=>(Fi=g.dynCall_viiijjiiiiii=\nU.vh)(a,b,c,d,e,f,h,k,l,m,n,q),Gi=g.dynCall_viijjijjjjiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Gi=g.dynCall_viijjijjjjiii=U.wh)(a,b,c,d,e,f,h,k,l,m,n,q,r),Hi=g.dynCall_iiiij=(a,b,c,d,e)=>(Hi=g.dynCall_iiiij=U.xh)(a,b,c,d,e),Ii=g.dynCall_viiijii=(a,b,c,d,e,f,h)=>(Ii=g.dynCall_viiijii=U.yh)(a,b,c,d,e,f,h),Ji=g.dynCall_viijiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Ji=g.dynCall_viijiiiiiiiii=U.zh)(a,b,c,d,e,f,h,k,l,m,n,q,r),Ki=g.dynCall_fiiii=(a,b,c,d,e)=>(Ki=g.dynCall_fiiii=U.Ah)(a,b,c,d,e),Li=g.dynCall_jfi=\n(a,b,c)=>(Li=g.dynCall_jfi=U.Bh)(a,b,c),Mi=g.dynCall_viiiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>(Mi=g.dynCall_viiiiiiiiiiiiii=U.Ch)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u),Ni=g.dynCall_jiij=(a,b,c,d)=>(Ni=g.dynCall_jiij=U.Dh)(a,b,c,d),Mb=a=>(Mb=U.Eh)(a),Bb=()=>(Bb=U.Fh)(),Lb=a=>(Lb=U.Gh)(a),Nb=()=>(Nb=U.Hh)();g.___start_em_js=1275044;g.___stop_em_js=1275205;function Dc(a,b,c,d){var e=Z();try{return Ff(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}\nfunction Bc(a,b,c){var d=Z();try{return dynCall_iii(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function Jd(a,b,c){var d=Z();try{dynCall_vii(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function yc(a,b){var c=Z();try{return Gf(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}function Fd(a,b){var c=Z();try{dynCall_vi(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}function dd(a,b,c,d){var e=Z();try{return Jf(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}\nfunction Dd(a){var b=Z();try{dynCall_v(a)}catch(c){Y(b);if(c!==c+0)throw c;X(1,0)}}function Ic(a,b,c,d,e,f,h){var k=Z();try{return Hf(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Hc(a,b,c,d,e,f){var h=Z();try{return If(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Fc(a,b,c,d,e){var f=Z();try{return Kf(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Qd(a,b,c,d){var e=Z();try{Lf(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}\nfunction Td(a,b,c,d,e){var f=Z();try{Nf(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Vd(a,b,c,d,e,f){var h=Z();try{Mf(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Zd(a,b,c,d,e,f,h){var k=Z();try{Of(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function ke(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{Qf(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function zc(a,b,c){var d=Z();try{return Sf(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}\nfunction Ac(a,b,c){var d=Z();try{return Tf(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function md(a,b,c){var d=Z();try{return Uf(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function yd(a,b,c){var d=Z();try{return Vf(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0);return 0n}}function ee(a,b,c,d,e,f,h,k,l){var m=Z();try{Xf(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}function xc(a){var b=Z();try{return Wf(a)}catch(c){Y(b);if(c!==c+0)throw c;X(1,0)}}\nfunction df(a,b,c){var d=Z();try{fg(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function We(a,b,c,d,e){var f=Z();try{Pf(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Ce(a,b,c,d,e,f,h){var k=Z();try{Yf(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function cf(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{gg(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}\nfunction Re(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{hg(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function Jc(a,b,c,d,e,f,h,k){var l=Z();try{return ig(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function de(a,b,c,d,e,f,h,k){var l=Z();try{jg(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function Nc(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{return ag(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}\nfunction fe(a,b,c,d,e,f,h,k,l,m){var n=Z();try{bg(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function me(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{lg(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}function Yc(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{return ng(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}function Kc(a,b,c,d,e,f,h,k,l){var m=Z();try{return mg(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}\nfunction nf(a,b,c,d,e,f,h,k,l){var m=Z();try{og(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}function Ve(a,b,c,d){var e=Z();try{$f(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function tc(a,b){var c=Z();try{return pg(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}function xd(a,b){var c=Z();try{return Zf(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0);return 0n}}function nc(a,b){var c=Z();try{return rg(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}\nfunction jf(a,b,c,d){var e=Z();try{tg(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function Oe(a,b,c,d,e,f,h){var k=Z();try{Ii(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Ze(a,b,c,d,e){var f=Z();try{zh(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Lc(a,b,c,d,e,f,h,k,l,m){var n=Z();try{return ug(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function Xe(a,b,c,d,e,f,h){var k=Z();try{vg(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}\nfunction Kd(a,b,c,d){var e=Z();try{wg(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function Tc(a,b,c,d,e,f,h,k,l){var m=Z();try{return kg(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}function Id(a,b,c,d,e,f,h){var k=Z();try{xg(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Ue(a,b,c,d,e,f,h,k,l){var m=Z();try{Rf(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}\nfunction Pd(a,b,c,d,e,f,h){var k=Z();try{yg(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Wd(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{zg(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}function zd(a,b,c,d){var e=Z();try{return Bg(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0);return 0n}}function uf(a,b,c,d,e,f,h,k){var l=Z();try{Cg(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}\nfunction Rd(a,b,c,d,e){var f=Z();try{Dg(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function ef(a,b,c,d){var e=Z();try{Fg(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function rf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y){var A=Z();try{Gg(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)}catch(B){Y(A);if(B!==B+0)throw B;X(1,0)}}function Ne(a,b,c,d,e,f){var h=Z();try{Hg(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}\nfunction of(a,b,c,d,e,f,h,k,l){var m=Z();try{Ig(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}function ed(a,b,c,d,e){var f=Z();try{return Jg(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function kd(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{return Kg(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}function sf(a,b){var c=Z();try{Lg(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}\nfunction Cd(a,b,c){var d=Z();try{return Mg(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0);return 0n}}function jd(a,b,c,d,e,f,h,k,l,m){var n=Z();try{return Ng(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function ie(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{Sg(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}function Ed(a,b,c,d,e){var f=Z();try{Og(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}\nfunction Ud(a,b,c,d,e,f,h){var k=Z();try{Pg(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Md(a,b,c,d,e){var f=Z();try{Rg(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Xd(a,b,c,d,e,f,h,k){var l=Z();try{Qg(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function ue(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{Tg(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}\nfunction Oc(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A){var B=Z();try{return Ug(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)}catch(C){Y(B);if(C!==C+0)throw C;X(1,0)}}function le(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{Vg(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function sd(a,b){var c=Z();try{return cg(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}function wc(a,b,c,d,e){var f=Z();try{return Ki(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}\nfunction Pc(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D){var F=Z();try{return Wg(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)}catch(H){Y(F);if(H!==H+0)throw H;X(1,0)}}function mf(a,b,c,d,e,f,h,k,l,m){var n=Z();try{Xg(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function cd(a,b,c,d,e,f,h){var k=Z();try{return Yg(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function je(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{Zg(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}\nfunction ld(a,b,c,d,e,f){var h=Z();try{return $g(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Ie(a,b,c,d,e,f){var h=Z();try{bh(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function ye(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{ch(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}function zf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B){var C=Z();try{dh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B)}catch(D){Y(C);if(D!==D+0)throw D;X(1,0)}}\nfunction ae(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A){var B=Z();try{eh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)}catch(C){Y(B);if(C!==C+0)throw C;X(1,0)}}function $d(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y){var A=Z();try{fh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)}catch(B){Y(A);if(B!==B+0)throw B;X(1,0)}}function be(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u){var y=Z();try{gh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)}catch(A){Y(y);if(A!==A+0)throw A;X(1,0)}}\nfunction Af(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F){var H=Z();try{hh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F)}catch(K){Y(H);if(K!==K+0)throw K;X(1,0)}}function yf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C){var D=Z();try{ih(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C)}catch(F){Y(D);if(F!==F+0)throw F;X(1,0)}}function xf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B){var C=Z();try{jh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B)}catch(D){Y(C);if(D!==D+0)throw D;X(1,0)}}\nfunction Bf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F){var H=Z();try{kh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F)}catch(K){Y(H);if(K!==K+0)throw K;X(1,0)}}function gf(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{lh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function kf(a,b,c,d,e,f,h,k,l,m){var n=Z();try{mh(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}\nfunction ve(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{nh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function qf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u){var y=Z();try{oh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)}catch(A){Y(y);if(A!==A+0)throw A;X(1,0)}}function wf(a,b,c,d,e,f,h,k,l,m){var n=Z();try{qh(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function vf(a,b,c,d,e,f,h,k,l){var m=Z();try{rh(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}\nfunction sc(a,b,c,d,e,f,h){var k=Z();try{return ah(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Nd(a,b,c,d,e){var f=Z();try{ph(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function wd(a,b,c){var d=Z();try{return Li(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0);return 0n}}function ze(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{sh(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}\nfunction Ge(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{uh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function Xc(a,b,c,d,e,f,h){var k=Z();try{return vh(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function ad(a,b,c,d,e,f){var h=Z();try{return wh(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function De(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{xh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}\nfunction lf(a,b,c,d,e,f){var h=Z();try{th(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Qe(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{yh(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}function Ke(a,b,c,d,e,f,h,k){var l=Z();try{Ah(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function af(a,b,c,d,e,f,h,k){var l=Z();try{Bh(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}\nfunction td(a,b,c,d){var e=Z();try{return Ch(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function He(a,b,c,d,e,f,h,k,l,m){var n=Z();try{Dh(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function pf(a,b,c,d,e,f,h,k,l){var m=Z();try{Eh(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}function Fe(a,b,c,d,e,f,h,k,l){var m=Z();try{Fh(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}\nfunction Ae(a,b,c,d,e,f,h,k,l,m){var n=Z();try{Gh(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function ff(a,b,c,d,e,f){var h=Z();try{Hh(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function he(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{Ih(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function hd(a,b,c,d,e,f,h,k){var l=Z();try{return Jh(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}\nfunction ne(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u){var y=Z();try{Mi(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)}catch(A){Y(y);if(A!==A+0)throw A;X(1,0)}}function Be(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{Kh(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}function we(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u){var y=Z();try{Lh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)}catch(A){Y(y);if(A!==A+0)throw A;X(1,0)}}function Hd(a,b,c){var d=Z();try{Mh(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}\nfunction vc(a,b,c,d){var e=Z();try{return Oh(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function pc(a,b,c,d){var e=Z();try{return Ph(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function ce(a,b,c,d,e,f,h,k,l,m){var n=Z();try{Qh(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function Ee(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F,H,K,Va,Wa,Xa){var Qi=Z();try{Rh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F,H,K,Va,Wa,Xa)}catch(Ya){Y(Qi);if(Ya!==Ya+0)throw Ya;X(1,0)}}\nfunction $e(a,b,c,d,e,f){var h=Z();try{Sh(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Rc(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{return Th(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function Od(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{Uh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}\nfunction se(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F){var H=Z();try{Vh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F)}catch(K){Y(H);if(K!==K+0)throw K;X(1,0)}}function Yd(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{Wh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function hf(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{Xh(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}\nfunction re(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D){var F=Z();try{Zh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)}catch(H){Y(F);if(H!==H+0)throw H;X(1,0)}}function pe(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A){var B=Z();try{ai(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)}catch(C){Y(B);if(C!==C+0)throw C;X(1,0)}}function qe(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C){var D=Z();try{Yh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C)}catch(F){Y(D);if(F!==F+0)throw F;X(1,0)}}\nfunction Le(a,b,c,d,e,f,h,k){var l=Z();try{bi(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function xe(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{di(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}function Mc(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{return ei(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}\nfunction Qc(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D){var F=Z();try{return fi(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)}catch(H){Y(F);if(H!==H+0)throw H;X(1,0)}}function Sd(a,b,c,d,e){var f=Z();try{gi(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function ge(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{Ag(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function Pe(a,b,c,d,e,f,h,k,l,m){var n=Z();try{hi(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}\nfunction Me(a,b,c,d,e){var f=Z();try{ii(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Ye(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{Ji(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function pd(a,b,c,d,e){var f=Z();try{return ji(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Ad(a,b,c,d){var e=Z();try{return Ni(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0);return 0n}}\nfunction Je(a,b,c,d,e,f,h){var k=Z();try{ki(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function qd(a,b,c,d,e,f){var h=Z();try{return li(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function ud(a,b,c,d,e,f){var h=Z();try{return mi(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Se(a,b,c,d,e,f,h,k,l){var m=Z();try{ni(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}\nfunction Ld(a,b,c,d){var e=Z();try{Nh(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function Zc(a,b,c,d,e,f,h,k){var l=Z();try{return oi(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function Ec(a,b,c,d,e,f){var h=Z();try{return pi(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function fd(a,b,c,d,e,f){var h=Z();try{return qi(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}\nfunction Sc(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{return ri(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function bd(a,b,c,d,e,f,h,k){var l=Z();try{return si(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function Vc(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{return ti(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}function gd(a,b,c,d,e,f,h){var k=Z();try{return ui(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}\nfunction Uc(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{return vi(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function od(a,b,c,d,e,f,h){var k=Z();try{return wi(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function rd(a,b,c,d,e,f,h){var k=Z();try{return xi(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Bd(a,b,c){var d=Z();try{return yi(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0);return 0n}}\nfunction nd(a,b,c,d){var e=Z();try{return zi(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function Gd(a,b,c,d){var e=Z();try{Bi(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function Cc(a,b,c,d){var e=Z();try{return Ai(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function tf(a,b,c,d,e){var f=Z();try{Ci(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function qc(a,b,c,d,e){var f=Z();try{return Di(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}\nfunction rc(a,b,c,d,e,f){var h=Z();try{return Ei(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Te(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{Fi(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function bf(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{Gi(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function te(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{Eg(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}\nfunction $c(a,b,c,d,e){var f=Z();try{return Hi(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function vd(a){var b=Z();try{return eg(a)}catch(c){Y(b);if(c!==c+0)throw c;X(1,0);return 0n}}function Wc(a,b,c,d,e,f){var h=Z();try{return dg(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Gc(a,b,c,d,e,f){var h=Z();try{return ci(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}\nfunction oe(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y){var A=Z();try{$h(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)}catch(B){Y(A);if(B!==B+0)throw B;X(1,0)}}function uc(a,b,c){var d=Z();try{return qg(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function oc(a,b,c){var d=Z();try{return sg(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function Df(){var a=U;a=Object.assign({},a);var b=c=>d=>c(d)>>>0;a.Fd=b(a.Fd);a.he=b(a.he);a.ne=b(a.ne);a.oe=(c=>()=>c()>>>0)(a.oe);return a}g.stackSave=()=>Z();g.stackRestore=a=>Y(a);\ng.stackAlloc=a=>Ef(a);g.UTF8ToString=J;g.stringToUTF8=(a,b,c)=>M(a,E,b,c);g.lengthBytesUTF8=bb;var Oi;Fa=function Pi(){Oi||Ri();Oi||(Fa=Pi)};function Ri(){if(!(0<Da)){if(g.preRun)for(\"function\"==typeof g.preRun&&(g.preRun=[g.preRun]);g.preRun.length;){var a=g.preRun.shift();Aa.unshift(a)}for(;0<Aa.length;)Aa.shift()(g);if(!(0<Da||Oi||(Oi=!0,g.calledRun=!0,x))){for(;0<Ba.length;)Ba.shift()(g);for(aa(g);0<Ca.length;)Ca.shift()(g)}}}Ri();\n\n\n  return readyPromise\n}\n);\n})();\nif (typeof exports === 'object' && typeof module === 'object')\n  module.exports = ortWasm;\nelse if (typeof define === 'function' && define['amd'])\n  define([], () => ortWasm);\n", "", "", "export const cpus = undefined;", "\nvar ortWasmThreaded = (() => {\n  var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;\n  if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename;\n  return (\nfunction(moduleArg = {}) {\n\nfunction d(){l.buffer!=p.buffer&&t();return p}function v(){l.buffer!=p.buffer&&t();return aa}function z(){l.buffer!=p.buffer&&t();return ba}function A(){l.buffer!=p.buffer&&t();return ca}function da(){l.buffer!=p.buffer&&t();return ea}var B=moduleArg,fa,C;B.ready=new Promise((a,b)=>{fa=a;C=b});\"use strict\";\nB.jsepInit=(a,b,c,e,f,h,k,q)=>{B.Qb=a;B.wb=b;B.yb=c;B.jb=e;B.xb=f;B.Ea=h;B.zb=k;B.Ab=q;b=(n,m,r)=>(...w)=>{const x=D,g=m?.();w=n(...w);const u=m?.();g!==u&&(n=u,r(g),m=r=null);return D!=x?ha():w};c=n=>async(...m)=>{try{if(B.bb)throw Error(\"Session already started\");const r=B.bb={Fb:m[0],errors:[]},w=await n(...m);if(B.bb!==r)throw Error(\"Session mismatch\");a.flush();const x=r.errors;if(0<x.length){let g=await Promise.all(x);g=g.filter(u=>u);if(0<g.length)throw Error(g.join(\"\\n\"));}return w}finally{B.bb=\nnull}};B._OrtRun=c(b(B._OrtRun,()=>B._OrtRun,n=>B._OrtRun=n));B._OrtRunWithBinding=c(b(B._OrtRunWithBinding,()=>B._OrtRunWithBinding,n=>B._OrtRunWithBinding=n));B._OrtBindInput=b(B._OrtBindInput,()=>B._OrtBindInput,n=>B._OrtBindInput=n);B.jsepRegisterBuffer=(n,m,r,w)=>a.registerBuffer(n,m,r,w);B.jsepUnregisterBuffers=n=>{a.unregisterBuffers(n)};B.jsepGetBuffer=n=>a.getBuffer(n);B.jsepCreateDownloader=(n,m,r)=>a.createDownloader(n,m,r)};\nvar ia=Object.assign({},B),ja=\"./this.program\",E=(a,b)=>{throw b;},ka=\"object\"==typeof window,F=\"function\"==typeof importScripts,G=\"object\"==typeof process&&\"object\"==typeof process.versions&&\"string\"==typeof process.versions.node,H=B.ENVIRONMENT_IS_PTHREAD||!1,I=\"\";function la(a){return B.locateFile?B.locateFile(a,I):I+a}var ma,J,na;\nif(G){var fs=require(\"fs\"),oa=require(\"path\");I=F?oa.dirname(I)+\"/\":__dirname+\"/\";ma=(b,c)=>{b=b.startsWith(\"file://\")?new URL(b):oa.normalize(b);return fs.readFileSync(b,c?void 0:\"utf8\")};na=b=>{b=ma(b,!0);b.buffer||(b=new Uint8Array(b));return b};J=(b,c,e,f=!0)=>{b=b.startsWith(\"file://\")?new URL(b):oa.normalize(b);fs.readFile(b,f?void 0:\"utf8\",(h,k)=>{h?e(h):c(f?k.buffer:k)})};!B.thisProgram&&1<process.argv.length&&(ja=process.argv[1].replace(/\\\\/g,\"/\"));process.argv.slice(2);E=(b,c)=>{process.exitCode=\nb;throw c;};B.inspect=()=>\"[Emscripten Module object]\";let a;try{a=require(\"worker_threads\")}catch(b){throw console.error('The \"worker_threads\" module is not supported in this node.js build - perhaps a newer version is needed?'),b;}global.Worker=a.Worker}else if(ka||F)F?I=self.location.href:\"undefined\"!=typeof document&&document.currentScript&&(I=document.currentScript.src),(typeof _scriptDir !== \"undefined\" && _scriptDir)&&(I=_scriptDir),0!==I.indexOf(\"blob:\")?I=I.substr(0,I.replace(/[?#].*/,\"\").lastIndexOf(\"/\")+1):I=\"\",G||(ma=a=>{var b=\nnew XMLHttpRequest;b.open(\"GET\",a,!1);b.send(null);return b.responseText},F&&(na=a=>{var b=new XMLHttpRequest;b.open(\"GET\",a,!1);b.responseType=\"arraybuffer\";b.send(null);return new Uint8Array(b.response)}),J=(a,b,c)=>{var e=new XMLHttpRequest;e.open(\"GET\",a,!0);e.responseType=\"arraybuffer\";e.onload=()=>{200==e.status||0==e.status&&e.response?b(e.response):c()};e.onerror=c;e.send(null)});G&&\"undefined\"==typeof performance&&(global.performance=require(\"perf_hooks\").performance);\nvar pa=console.log.bind(console),qa=console.error.bind(console);G&&(pa=(...a)=>fs.writeSync(1,a.join(\" \")+\"\\n\"),qa=(...a)=>fs.writeSync(2,a.join(\" \")+\"\\n\"));var ra=B.print||pa,K=B.printErr||qa;Object.assign(B,ia);ia=null;B.thisProgram&&(ja=B.thisProgram);B.quit&&(E=B.quit);var L;B.wasmBinary&&(L=B.wasmBinary);var noExitRuntime=B.noExitRuntime||!0;\"object\"!=typeof WebAssembly&&M(\"no native wasm support detected\");var l,N,sa,P=!1,Q,p,aa,ba,ca,ea;\nfunction t(){var a=l.buffer;B.HEAP8=p=new Int8Array(a);B.HEAP16=new Int16Array(a);B.HEAP32=ba=new Int32Array(a);B.HEAPU8=aa=new Uint8Array(a);B.HEAPU16=new Uint16Array(a);B.HEAPU32=ca=new Uint32Array(a);B.HEAPF32=new Float32Array(a);B.HEAPF64=ea=new Float64Array(a)}var ta=B.INITIAL_MEMORY||16777216;5242880<=ta||M(\"INITIAL_MEMORY should be larger than STACK_SIZE, was \"+ta+\"! (STACK_SIZE=5242880)\");\nif(H)l=B.wasmMemory;else if(B.wasmMemory)l=B.wasmMemory;else if(l=new WebAssembly.Memory({initial:ta/65536,maximum:65536,shared:!0}),!(l.buffer instanceof SharedArrayBuffer))throw K(\"requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag\"),G&&K(\"(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and/or recent version)\"),\nError(\"bad memory\");t();ta=l.buffer.byteLength;var ua=[],va=[],wa=[],xa=0;function ya(){return noExitRuntime||0<xa}var R=0,za=null,S=null;function Aa(){R++;B.monitorRunDependencies&&B.monitorRunDependencies(R)}function Ba(){R--;B.monitorRunDependencies&&B.monitorRunDependencies(R);if(0==R&&(null!==za&&(clearInterval(za),za=null),S)){var a=S;S=null;a()}}\nfunction M(a){if(B.onAbort)B.onAbort(a);a=\"Aborted(\"+a+\")\";K(a);P=!0;Q=1;a=new WebAssembly.RuntimeError(a+\". Build with -sASSERTIONS for more info.\");C(a);throw a;}function Ca(a){return a.startsWith(\"data:application/octet-stream;base64,\")}var T;T=\"ort-wasm-simd-threaded.wasm\";Ca(T)||(T=la(T));function Da(a){if(a==T&&L)return new Uint8Array(L);if(na)return na(a);throw\"both async and sync fetching of the wasm failed\";}\nfunction Ea(a){if(!L&&(ka||F)){if(\"function\"==typeof fetch&&!a.startsWith(\"file://\"))return fetch(a,{credentials:\"same-origin\"}).then(b=>{if(!b.ok)throw\"failed to load wasm binary file at '\"+a+\"'\";return b.arrayBuffer()}).catch(()=>Da(a));if(J)return new Promise((b,c)=>{J(a,e=>b(new Uint8Array(e)),c)})}return Promise.resolve().then(()=>Da(a))}function Fa(a,b,c){return Ea(a).then(e=>WebAssembly.instantiate(e,b)).then(e=>e).then(c,e=>{K(\"failed to asynchronously prepare wasm: \"+e);M(e)})}\nfunction Ga(a,b){var c=T;return L||\"function\"!=typeof WebAssembly.instantiateStreaming||Ca(c)||c.startsWith(\"file://\")||G||\"function\"!=typeof fetch?Fa(c,a,b):fetch(c,{credentials:\"same-origin\"}).then(e=>WebAssembly.instantiateStreaming(e,a).then(b,function(f){K(\"wasm streaming compile failed: \"+f);K(\"falling back to ArrayBuffer instantiation\");return Fa(c,a,b)}))}\nvar U,Ha={906828:a=>{B.Ea(\"Abs\",a,void 0)},906879:a=>{B.Ea(\"Neg\",a,void 0)},906930:a=>{B.Ea(\"Floor\",a,void 0)},906983:a=>{B.Ea(\"Ceil\",a,void 0)},907035:a=>{B.Ea(\"Reciprocal\",a,void 0)},907093:a=>{B.Ea(\"Sqrt\",a,void 0)},907145:a=>{B.Ea(\"Exp\",a,void 0)},907196:a=>{B.Ea(\"Erf\",a,void 0)},907247:a=>{B.Ea(\"Sigmoid\",a,void 0)},907302:a=>{B.Ea(\"Log\",a,void 0)},907353:a=>{B.Ea(\"Sin\",a,void 0)},907404:a=>{B.Ea(\"Cos\",a,void 0)},907455:a=>{B.Ea(\"Tan\",a,void 0)},907506:a=>{B.Ea(\"Asin\",a,void 0)},907558:a=>{B.Ea(\"Acos\",\na,void 0)},907610:a=>{B.Ea(\"Atan\",a,void 0)},907662:a=>{B.Ea(\"Sinh\",a,void 0)},907714:a=>{B.Ea(\"Cosh\",a,void 0)},907766:a=>{B.Ea(\"Asinh\",a,void 0)},907819:a=>{B.Ea(\"Acosh\",a,void 0)},907872:a=>{B.Ea(\"Atanh\",a,void 0)},907925:a=>{B.Ea(\"Tanh\",a,void 0)},907977:a=>{B.Ea(\"Not\",a,void 0)},908028:(a,b,c)=>{B.Ea(\"ClipV10\",a,{min:b,max:c})},908100:a=>{B.Ea(\"Clip\",a,void 0)},908152:(a,b)=>{B.Ea(\"Elu\",a,{alpha:b})},908210:a=>{B.Ea(\"Relu\",a,void 0)},908262:(a,b)=>{B.Ea(\"LeakyRelu\",a,{alpha:b})},908326:(a,b)=>\n{B.Ea(\"ThresholdedRelu\",a,{alpha:b})},908396:(a,b)=>{B.Ea(\"Cast\",a,{to:b})},908454:a=>{B.Ea(\"Add\",a,void 0)},908505:a=>{B.Ea(\"Sub\",a,void 0)},908556:a=>{B.Ea(\"Mul\",a,void 0)},908607:a=>{B.Ea(\"Div\",a,void 0)},908658:a=>{B.Ea(\"Pow\",a,void 0)},908709:a=>{B.Ea(\"Equal\",a,void 0)},908762:a=>{B.Ea(\"Greater\",a,void 0)},908817:a=>{B.Ea(\"GreaterOrEqual\",a,void 0)},908879:a=>{B.Ea(\"Less\",a,void 0)},908931:a=>{B.Ea(\"LessOrEqual\",a,void 0)},908990:(a,b,c,e,f)=>{B.Ea(\"ReduceMean\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,\naxes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909154:(a,b,c,e,f)=>{B.Ea(\"ReduceMax\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909317:(a,b,c,e,f)=>{B.Ea(\"ReduceMin\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909480:(a,b,c,e,f)=>{B.Ea(\"ReduceProd\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909644:(a,b,c,e,f)=>{B.Ea(\"ReduceSum\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,\naxes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909807:(a,b,c,e,f)=>{B.Ea(\"ReduceL1\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909969:(a,b,c,e,f)=>{B.Ea(\"ReduceL2\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},910131:(a,b,c,e,f)=>{B.Ea(\"ReduceLogSum\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},910297:(a,b,c,e,f)=>{B.Ea(\"ReduceSumSquare\",a,{keepDims:!!b,\nnoopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},910466:(a,b,c,e,f)=>{B.Ea(\"ReduceLogSumExp\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},910635:a=>{B.Ea(\"Where\",a,void 0)},910688:(a,b,c)=>{B.Ea(\"Transpose\",a,{perm:b?Array.from(z().subarray(c>>>0,c+b>>>0)):[]})},910801:(a,b,c,e,f,h,k,q,n,m)=>{B.Ea(\"Conv\",a,{format:n?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c],group:e,kernel_shape:[f],pads:[h,k],strides:[q],w_is_const:()=>!!d()[m>>>\n0]})},911029:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u)=>{B.Ea(\"Conv\",a,{format:g?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c,e],group:f,kernel_shape:[h,k],pads:[q,n,m,r],strides:[w,x],w_is_const:()=>!!d()[u>>>0]})},911288:(a,b,c,e,f,h,k,q,n,m)=>{B.Ea(\"Conv\",a,{format:n?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c],group:e,kernel_shape:[f],pads:[h,k],strides:[q],w_is_const:()=>!!d()[m>>>0]})},911516:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u)=>{B.Ea(\"Conv\",a,{format:g?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c,e],group:f,kernel_shape:[h,\nk],pads:[q,n,m,r],strides:[w,x],w_is_const:()=>!!d()[u>>>0]})},911775:(a,b,c,e,f,h,k,q,n,m,r,w,x,g)=>{B.Ea(\"ConvTranspose\",a,{format:n?\"NHWC\":\"NCHW\",autoPad:b,dilations:[c],group:e,kernel_shape:[f],pads:[h,k],strides:[q],wIsConst:()=>!!d()[m>>>0],outputPadding:r?Array.from(z().subarray(w>>>0,w+r>>>0)):[],outputShape:x?Array.from(z().subarray(g>>>0,g+x>>>0)):[]})},912155:(a,b,c,e,f,h,k,q,n,m,r,w,x)=>{B.Ea(\"ConvTranspose\",a,{format:q?\"NHWC\":\"NCHW\",autoPad:b,dilations:Array.from(z().subarray(c>>>0,c+\n2>>>0)),group:e,kernelShape:Array.from(z().subarray(f>>>0,f+2>>>0)),pads:Array.from(z().subarray(h>>>0,h+4>>>0)),strides:Array.from(z().subarray(k>>>0,k+2>>>0)),wIsConst:()=>!!d()[n>>>0],outputPadding:0<m?Array.from(z().subarray(r>>>0,r+m>>>0)):[],outputShape:0<w?Array.from(z().subarray(x>>>0,x+w>>>0)):[]})},912678:(a,b,c,e,f,h,k,q,n,m,r,w,x,g)=>{B.Ea(\"ConvTranspose\",a,{format:n?\"NHWC\":\"NCHW\",autoPad:b,dilations:[c],group:e,kernel_shape:[f],pads:[h,k],strides:[q],wIsConst:()=>!!d()[m>>>0],outputPadding:r?\nArray.from(z().subarray(w>>>0,w+r>>>0)):[],outputShape:x?Array.from(z().subarray(g>>>0,g+x>>>0)):[]})},913058:(a,b,c,e,f,h,k,q,n,m,r,w,x)=>{B.Ea(\"ConvTranspose\",a,{format:q?\"NHWC\":\"NCHW\",autoPad:b,dilations:Array.from(z().subarray(c>>>0,c+2>>>0)),group:e,kernelShape:Array.from(z().subarray(f>>>0,f+2>>>0)),pads:Array.from(z().subarray(h>>>0,h+4>>>0)),strides:Array.from(z().subarray(k>>>0,k+2>>>0)),wIsConst:()=>!!d()[n>>>0],outputPadding:0<m?Array.from(z().subarray(r>>>0,r+m>>>0)):[],outputShape:0<\nw?Array.from(z().subarray(x>>>0,x+w>>>0)):[]})},913581:(a,b)=>{B.Ea(\"GlobalAveragePool\",a,{format:b?\"NHWC\":\"NCHW\"})},913672:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u,y)=>{B.Ea(\"AveragePool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:e,storage_order:f,dilations:[h,k],kernel_shape:[q,n],pads:[m,r,w,x],strides:[g,u]})},913956:(a,b)=>{B.Ea(\"GlobalAveragePool\",a,{format:b?\"NHWC\":\"NCHW\"})},914047:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u,y)=>{B.Ea(\"AveragePool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,\ncount_include_pad:e,storage_order:f,dilations:[h,k],kernel_shape:[q,n],pads:[m,r,w,x],strides:[g,u]})},914331:(a,b)=>{B.Ea(\"GlobalMaxPool\",a,{format:b?\"NHWC\":\"NCHW\"})},914418:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u,y)=>{B.Ea(\"MaxPool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:e,storage_order:f,dilations:[h,k],kernel_shape:[q,n],pads:[m,r,w,x],strides:[g,u]})},914698:(a,b)=>{B.Ea(\"GlobalMaxPool\",a,{format:b?\"NHWC\":\"NCHW\"})},914785:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u,y)=>{B.Ea(\"MaxPool\",\na,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:e,storage_order:f,dilations:[h,k],kernel_shape:[q,n],pads:[m,r,w,x],strides:[g,u]})},915065:(a,b,c,e,f)=>{B.Ea(\"Gemm\",a,{alpha:b,beta:c,transA:e,transB:f})},915169:a=>{B.Ea(\"MatMul\",a,void 0)},915223:(a,b,c,e)=>{B.Ea(\"ArgMax\",a,{keepDims:!!b,selectLastIndex:!!c,axis:e})},915331:(a,b,c,e)=>{B.Ea(\"ArgMin\",a,{keepDims:!!b,selectLastIndex:!!c,axis:e})},915439:(a,b)=>{B.Ea(\"Softmax\",a,{axis:b})},915502:(a,b)=>{B.Ea(\"Concat\",a,{axis:b})},\n915562:(a,b,c,e,f)=>{B.Ea(\"Split\",a,{axis:b,numOutputs:c,splitSizes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},915707:a=>{B.Ea(\"Expand\",a,void 0)},915761:(a,b)=>{B.Ea(\"Gather\",a,{axis:Number(b)})},915832:(a,b)=>{B.Ea(\"GatherElements\",a,{axis:Number(b)})},915911:(a,b,c,e,f,h,k,q,n,m,r)=>{B.Ea(\"Resize\",a,{antialias:b,axes:c?Array.from(z().subarray(e>>>0,e+c>>>0)):[],coordinateTransformMode:V(f),cubicCoeffA:h,excludeOutside:k,extrapolationValue:q,keepAspectRatioPolicy:V(n),mode:V(m),nearestMode:V(r)})},\n916262:(a,b,c,e,f,h,k)=>{B.Ea(\"Slice\",a,{starts:b?Array.from(z().subarray(c>>>0,c+b>>>0)):[],ends:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[],axes:h?Array.from(z().subarray(k>>>0,k+h>>>0)):[]})},916493:a=>{B.Ea(\"Tile\",a,void 0)},916545:(a,b,c)=>{B.Ea(\"LayerNormalization\",a,{axis:Number(b),epsilon:Number(c)})},916652:(a,b,c)=>{B.Ea(\"InstanceNormalization\",a,{epsilon:b,format:c?\"NHWC\":\"NCHW\"})},916766:(a,b,c)=>{B.Ea(\"InstanceNormalization\",a,{epsilon:b,format:c?\"NHWC\":\"NCHW\"})},916880:a=>{B.Ea(\"Range\",\na,void 0)},916933:(a,b)=>{B.Ea(\"Einsum\",a,{equation:V(b)})},917014:(a,b,c,e,f)=>{B.Ea(\"Pad\",a,{mode:b,value:c,pads:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},917146:a=>{B.Ea(\"Gelu\",a,void 0)},917198:a=>{B.Ea(\"BiasAdd\",a,void 0)},917253:a=>{B.Ea(\"BiasSplitGelu\",a,void 0)},917314:(a,b)=>{B.Ea(\"SkipLayerNormalization\",a,{epsilon:b})},917395:a=>{B.zb(a)},917429:(a,b)=>B.Ab(a,b,B.bb.Fb,B.bb.errors),917541:a=>B.wb(a),917574:a=>B.yb(a),917606:(a,b,c)=>{B.jb(a,b,c,!0)},917645:(a,b,c)=>{B.jb(a,b,c)}};\nfunction Ia(a){this.name=\"ExitStatus\";this.message=`Program terminated with exit(${a})`;this.status=a}function Ja(a){a.terminate();a.onmessage=()=>{}}function Ka(a){(a=W.Qa[a])||M();W.Eb(a)}function La(a){var b=W.tb();if(!b)return 6;W.Ya.push(b);W.Qa[a.Xa]=b;b.Xa=a.Xa;var c={cmd:\"run\",start_routine:a.Gb,arg:a.rb,pthread_ptr:a.Xa};G&&b.unref();b.postMessage(c,a.Mb);return 0}\nvar Ma=\"undefined\"!=typeof TextDecoder?new TextDecoder(\"utf8\"):void 0,Na=(a,b,c)=>{b>>>=0;var e=b+c;for(c=b;a[c]&&!(c>=e);)++c;if(16<c-b&&a.buffer&&Ma)return Ma.decode(a.buffer instanceof SharedArrayBuffer?a.slice(b,c):a.subarray(b,c));for(e=\"\";b<c;){var f=a[b++];if(f&128){var h=a[b++]&63;if(192==(f&224))e+=String.fromCharCode((f&31)<<6|h);else{var k=a[b++]&63;f=224==(f&240)?(f&15)<<12|h<<6|k:(f&7)<<18|h<<12|k<<6|a[b++]&63;65536>f?e+=String.fromCharCode(f):(f-=65536,e+=String.fromCharCode(55296|f>>\n10,56320|f&1023))}}else e+=String.fromCharCode(f)}return e},V=(a,b)=>(a>>>=0)?Na(v(),a,b):\"\";function Oa(a){if(H)return X(1,1,a);Q=a;if(!ya()){W.Hb();if(B.onExit)B.onExit(a);P=!0}E(a,new Ia(a))}\nvar Qa=a=>{Q=a;if(H)throw Pa(a),\"unwind\";Oa(a)},W={ab:[],Ya:[],mb:[],Qa:{},gb:function(){H?W.vb():W.ub()},ub:function(){ua.unshift(()=>{Aa();W.Bb(()=>Ba())})},vb:function(){W.receiveObjectTransfer=W.Db;W.threadInitTLS=W.lb;W.setExitStatus=W.kb;noExitRuntime=!1},kb:function(a){Q=a},Sb:[\"$terminateWorker\"],Hb:function(){for(var a of W.Ya)Ja(a);for(a of W.ab)Ja(a);W.ab=[];W.Ya=[];W.Qa=[]},Eb:function(a){var b=a.Xa;delete W.Qa[b];W.ab.push(a);W.Ya.splice(W.Ya.indexOf(a),1);a.Xa=0;Ra(b)},Db:function(){},\nlb:function(){W.mb.forEach(a=>a())},Cb:a=>new Promise(b=>{a.onmessage=h=>{h=h.data;var k=h.cmd;if(h.targetThread&&h.targetThread!=Sa()){var q=W.Qa[h.Rb];q?q.postMessage(h,h.transferList):K('Internal error! Worker sent a message \"'+k+'\" to target pthread '+h.targetThread+\", but that thread no longer exists!\")}else if(\"checkMailbox\"===k)Ta();else if(\"spawnThread\"===k)La(h);else if(\"cleanupThread\"===k)Ka(h.thread);else if(\"killThread\"===k)h=h.thread,k=W.Qa[h],delete W.Qa[h],Ja(k),Ra(h),W.Ya.splice(W.Ya.indexOf(k),\n1),k.Xa=0;else if(\"cancelThread\"===k)W.Qa[h.thread].postMessage({cmd:\"cancel\"});else if(\"loaded\"===k)a.loaded=!0,b(a);else if(\"alert\"===k)alert(\"Thread \"+h.threadId+\": \"+h.text);else if(\"setimmediate\"===h.target)a.postMessage(h);else if(\"callHandler\"===k)B[h.handler](...h.args);else k&&K(\"worker sent an unknown command \"+k)};a.onerror=h=>{K(\"worker sent an error! \"+h.filename+\":\"+h.lineno+\": \"+h.message);throw h;};G&&(a.on(\"message\",function(h){a.onmessage({data:h})}),a.on(\"error\",function(h){a.onerror(h)}));\nvar c=[],e=[\"onExit\",\"onAbort\",\"print\",\"printErr\"],f;for(f of e)B.hasOwnProperty(f)&&c.push(f);a.postMessage({cmd:\"load\",handlers:c,urlOrBlob:B.mainScriptUrlOrBlob||_scriptDir,wasmMemory:l,wasmModule:sa})}),Bb:function(a){a()},qb:function(){var a=la(\"ort-wasm-simd-threaded.worker.js\");a=new Worker(a);W.ab.push(a)},tb:function(){0==W.ab.length&&(W.qb(),W.Cb(W.ab[0]));return W.ab.pop()}};B.PThread=W;var Ua=a=>{for(;0<a.length;)a.shift()(B)};\nB.establishStackSpace=function(){var a=Sa(),b=z()[a+52>>2>>>0];a=z()[a+56>>2>>>0];Va(b,b-a);Wa(b)};function Pa(a){if(H)return X(2,0,a);Qa(a)}B.invokeEntryPoint=function(a,b){a=Xa.apply(null,[a,b]);ya()?W.kb(a):Ya(a)};function Za(a){this.fb=a-24;this.pb=function(b){A()[this.fb+4>>2>>>0]=b};this.ob=function(b){A()[this.fb+8>>2>>>0]=b};this.gb=function(b,c){this.nb();this.pb(b);this.ob(c)};this.nb=function(){A()[this.fb+16>>2>>>0]=0}}var $a=0,ab=0;\nfunction bb(a,b,c,e){return H?X(3,1,a,b,c,e):cb(a,b,c,e)}function cb(a,b,c,e){a>>>=0;b>>>=0;c>>>=0;e>>>=0;if(\"undefined\"==typeof SharedArrayBuffer)return K(\"Current environment does not support SharedArrayBuffer, pthreads are not available!\"),6;var f=[];if(H&&0===f.length)return bb(a,b,c,e);a={Gb:c,Xa:a,rb:e,Mb:f};return H?(a.Ob=\"spawnThread\",postMessage(a,f),0):La(a)}function db(a,b,c){return H?X(4,1,a,b,c):0}function eb(a,b){if(H)return X(5,1,a,b)}\nvar fb=a=>{for(var b=0,c=0;c<a.length;++c){var e=a.charCodeAt(c);127>=e?b++:2047>=e?b+=2:55296<=e&&57343>=e?(b+=4,++c):b+=3}return b},gb=(a,b,c,e)=>{c>>>=0;if(!(0<e))return 0;var f=c;e=c+e-1;for(var h=0;h<a.length;++h){var k=a.charCodeAt(h);if(55296<=k&&57343>=k){var q=a.charCodeAt(++h);k=65536+((k&1023)<<10)|q&1023}if(127>=k){if(c>=e)break;b[c++>>>0]=k}else{if(2047>=k){if(c+1>=e)break;b[c++>>>0]=192|k>>6}else{if(65535>=k){if(c+2>=e)break;b[c++>>>0]=224|k>>12}else{if(c+3>=e)break;b[c++>>>0]=240|k>>\n18;b[c++>>>0]=128|k>>12&63}b[c++>>>0]=128|k>>6&63}b[c++>>>0]=128|k&63}}b[c>>>0]=0;return c-f},hb=(a,b,c)=>gb(a,v(),b,c);function ib(a,b){if(H)return X(6,1,a,b)}function jb(a,b,c){if(H)return X(7,1,a,b,c)}function kb(a,b,c){return H?X(8,1,a,b,c):0}function lb(a,b){if(H)return X(9,1,a,b)}function mb(a,b,c){if(H)return X(10,1,a,b,c)}function nb(a,b,c,e){if(H)return X(11,1,a,b,c,e)}function ob(a,b,c,e){if(H)return X(12,1,a,b,c,e)}function pb(a,b,c,e){if(H)return X(13,1,a,b,c,e)}\nfunction qb(a){if(H)return X(14,1,a)}function rb(a,b){if(H)return X(15,1,a,b)}function sb(a,b,c){if(H)return X(16,1,a,b,c)}var tb=a=>{if(!P)try{if(a(),!ya())try{H?Ya(Q):Qa(Q)}catch(b){b instanceof Ia||\"unwind\"==b||E(1,b)}}catch(b){b instanceof Ia||\"unwind\"==b||E(1,b)}};function ub(a){a>>>=0;\"function\"===typeof Atomics.Nb&&(Atomics.Nb(z(),a>>2,a).value.then(Ta),a+=128,Atomics.store(z(),a>>2,1))}B.__emscripten_thread_mailbox_await=ub;function Ta(){var a=Sa();a&&(ub(a),tb(()=>vb()))}B.checkMailbox=Ta;\nvar Y=a=>0===a%4&&(0!==a%100||0===a%400),wb=[0,31,60,91,121,152,182,213,244,274,305,335],xb=[0,31,59,90,120,151,181,212,243,273,304,334];function yb(a,b,c,e,f,h,k,q){return H?X(17,1,a,b,c,e,f,h,k,q):-52}function zb(a,b,c,e,f,h,k){if(H)return X(18,1,a,b,c,e,f,h,k)}var Bb=a=>{var b=fb(a)+1,c=Ab(b);c&&hb(a,c,b);return c},Cb=[],Db=(a,b)=>{Cb.length=0;var c;for(b>>=2;c=v()[a++>>>0];)b+=105!=c&b,Cb.push(105==c?z()[b>>>0]:da()[b++>>>1]),++b;return Cb},Fb=a=>{var b=Eb();a=a();Wa(b);return a};\nfunction X(a,b){var c=arguments.length-2,e=arguments;return Fb(()=>{for(var f=Gb(8*c),h=f>>3,k=0;k<c;k++){var q=e[2+k];da()[h+k>>>0]=q}return Hb(a,c,f,b)})}\nvar Ib=[],Jb={},Lb=()=>{if(!Kb){var a={USER:\"web_user\",LOGNAME:\"web_user\",PATH:\"/\",PWD:\"/\",HOME:\"/home/web_user\",LANG:(\"object\"==typeof navigator&&navigator.languages&&navigator.languages[0]||\"C\").replace(\"-\",\"_\")+\".UTF-8\",_:ja||\"./this.program\"},b;for(b in Jb)void 0===Jb[b]?delete a[b]:a[b]=Jb[b];var c=[];for(b in a)c.push(`${b}=${a[b]}`);Kb=c}return Kb},Kb;\nfunction Mb(a,b){if(H)return X(19,1,a,b);a>>>=0;b>>>=0;var c=0;Lb().forEach(function(e,f){var h=b+c;f=A()[a+4*f>>2>>>0]=h;for(h=0;h<e.length;++h)d()[f++>>0>>>0]=e.charCodeAt(h);d()[f>>0>>>0]=0;c+=e.length+1});return 0}function Nb(a,b){if(H)return X(20,1,a,b);a>>>=0;b>>>=0;var c=Lb();A()[a>>2>>>0]=c.length;var e=0;c.forEach(function(f){e+=f.length+1});A()[b>>2>>>0]=e;return 0}function Ob(a){return H?X(21,1,a):52}function Pb(a,b,c,e){return H?X(22,1,a,b,c,e):52}\nfunction Qb(a,b,c,e,f){return H?X(23,1,a,b,c,e,f):70}var Rb=[null,[],[]];function Tb(a,b,c,e){if(H)return X(24,1,a,b,c,e);b>>>=0;c>>>=0;e>>>=0;for(var f=0,h=0;h<c;h++){var k=A()[b>>2>>>0],q=A()[b+4>>2>>>0];b+=8;for(var n=0;n<q;n++){var m=v()[k+n>>>0],r=Rb[a];0===m||10===m?((1===a?ra:K)(Na(r,0)),r.length=0):r.push(m)}f+=q}A()[e>>2>>>0]=f;return 0}var Ub=[31,29,31,30,31,30,31,31,30,31,30,31],Vb=[31,28,31,30,31,30,31,31,30,31,30,31];function Wb(a){var b=Array(fb(a)+1);gb(a,b,0,b.length);return b}\nvar Xb=(a,b)=>{d().set(a,b>>>0)};\nfunction Yb(a,b,c,e){function f(g,u,y){for(g=\"number\"==typeof g?g.toString():g||\"\";g.length<u;)g=y[0]+g;return g}function h(g,u){return f(g,u,\"0\")}function k(g,u){function y(Sb){return 0>Sb?-1:0<Sb?1:0}var O;0===(O=y(g.getFullYear()-u.getFullYear()))&&0===(O=y(g.getMonth()-u.getMonth()))&&(O=y(g.getDate()-u.getDate()));return O}function q(g){switch(g.getDay()){case 0:return new Date(g.getFullYear()-1,11,29);case 1:return g;case 2:return new Date(g.getFullYear(),0,3);case 3:return new Date(g.getFullYear(),\n0,2);case 4:return new Date(g.getFullYear(),0,1);case 5:return new Date(g.getFullYear()-1,11,31);case 6:return new Date(g.getFullYear()-1,11,30)}}function n(g){var u=g.Za;for(g=new Date((new Date(g.$a+1900,0,1)).getTime());0<u;){var y=g.getMonth(),O=(Y(g.getFullYear())?Ub:Vb)[y];if(u>O-g.getDate())u-=O-g.getDate()+1,g.setDate(1),11>y?g.setMonth(y+1):(g.setMonth(0),g.setFullYear(g.getFullYear()+1));else{g.setDate(g.getDate()+u);break}}y=new Date(g.getFullYear()+1,0,4);u=q(new Date(g.getFullYear(),\n0,4));y=q(y);return 0>=k(u,g)?0>=k(y,g)?g.getFullYear()+1:g.getFullYear():g.getFullYear()-1}a>>>=0;b>>>=0;c>>>=0;e>>>=0;var m=z()[e+40>>2>>>0];e={Kb:z()[e>>2>>>0],Jb:z()[e+4>>2>>>0],cb:z()[e+8>>2>>>0],ib:z()[e+12>>2>>>0],eb:z()[e+16>>2>>>0],$a:z()[e+20>>2>>>0],Wa:z()[e+24>>2>>>0],Za:z()[e+28>>2>>>0],Tb:z()[e+32>>2>>>0],Ib:z()[e+36>>2>>>0],Lb:m?V(m):\"\"};c=V(c);m={\"%c\":\"%a %b %d %H:%M:%S %Y\",\"%D\":\"%m/%d/%y\",\"%F\":\"%Y-%m-%d\",\"%h\":\"%b\",\"%r\":\"%I:%M:%S %p\",\"%R\":\"%H:%M\",\"%T\":\"%H:%M:%S\",\"%x\":\"%m/%d/%y\",\"%X\":\"%H:%M:%S\",\n\"%Ec\":\"%c\",\"%EC\":\"%C\",\"%Ex\":\"%m/%d/%y\",\"%EX\":\"%H:%M:%S\",\"%Ey\":\"%y\",\"%EY\":\"%Y\",\"%Od\":\"%d\",\"%Oe\":\"%e\",\"%OH\":\"%H\",\"%OI\":\"%I\",\"%Om\":\"%m\",\"%OM\":\"%M\",\"%OS\":\"%S\",\"%Ou\":\"%u\",\"%OU\":\"%U\",\"%OV\":\"%V\",\"%Ow\":\"%w\",\"%OW\":\"%W\",\"%Oy\":\"%y\"};for(var r in m)c=c.replace(new RegExp(r,\"g\"),m[r]);var w=\"Sunday Monday Tuesday Wednesday Thursday Friday Saturday\".split(\" \"),x=\"January February March April May June July August September October November December\".split(\" \");m={\"%a\":g=>w[g.Wa].substring(0,3),\"%A\":g=>w[g.Wa],\"%b\":g=>\nx[g.eb].substring(0,3),\"%B\":g=>x[g.eb],\"%C\":g=>h((g.$a+1900)/100|0,2),\"%d\":g=>h(g.ib,2),\"%e\":g=>f(g.ib,2,\" \"),\"%g\":g=>n(g).toString().substring(2),\"%G\":g=>n(g),\"%H\":g=>h(g.cb,2),\"%I\":g=>{g=g.cb;0==g?g=12:12<g&&(g-=12);return h(g,2)},\"%j\":g=>{for(var u=0,y=0;y<=g.eb-1;u+=(Y(g.$a+1900)?Ub:Vb)[y++]);return h(g.ib+u,3)},\"%m\":g=>h(g.eb+1,2),\"%M\":g=>h(g.Jb,2),\"%n\":()=>\"\\n\",\"%p\":g=>0<=g.cb&&12>g.cb?\"AM\":\"PM\",\"%S\":g=>h(g.Kb,2),\"%t\":()=>\"\\t\",\"%u\":g=>g.Wa||7,\"%U\":g=>h(Math.floor((g.Za+7-g.Wa)/7),2),\"%V\":g=>\n{var u=Math.floor((g.Za+7-(g.Wa+6)%7)/7);2>=(g.Wa+371-g.Za-2)%7&&u++;if(u)53==u&&(y=(g.Wa+371-g.Za)%7,4==y||3==y&&Y(g.$a)||(u=1));else{u=52;var y=(g.Wa+7-g.Za-1)%7;(4==y||5==y&&Y(g.$a%400-1))&&u++}return h(u,2)},\"%w\":g=>g.Wa,\"%W\":g=>h(Math.floor((g.Za+7-(g.Wa+6)%7)/7),2),\"%y\":g=>(g.$a+1900).toString().substring(2),\"%Y\":g=>g.$a+1900,\"%z\":g=>{g=g.Ib;var u=0<=g;g=Math.abs(g)/60;return(u?\"+\":\"-\")+String(\"0000\"+(g/60*100+g%60)).slice(-4)},\"%Z\":g=>g.Lb,\"%%\":()=>\"%\"};c=c.replace(/%%/g,\"\\x00\\x00\");for(r in m)c.includes(r)&&\n(c=c.replace(new RegExp(r,\"g\"),m[r](e)));c=c.replace(/\\0\\0/g,\"%\");r=Wb(c);if(r.length>b)return 0;Xb(r,a);return r.length-1}function Zb(a){try{a()}catch(b){M(b)}}function $b(a){var b={},c;for(c in a)(function(e){var f=a[e];b[e]=\"function\"==typeof f?function(){ac.push(e);try{return f.apply(null,arguments)}finally{P||(ac.pop()===e||M(),D&&1===Z&&0===ac.length&&(Z=0,xa+=1,Zb(bc),\"undefined\"!=typeof Fibers&&Fibers.Ub()))}}:f})(c);return b}var Z=0,D=null,cc=0,ac=[],dc={},ec={},fc=0,gc=null,hc=[];\nfunction ha(){return new Promise((a,b)=>{gc={resolve:a,reject:b}})}function ic(){var a=Ab(65548),b=a+12;A()[a>>2>>>0]=b;A()[a+4>>2>>>0]=b+65536;b=ac[0];var c=dc[b];void 0===c&&(c=fc++,dc[b]=c,ec[c]=b);b=c;z()[a+8>>2>>>0]=b;return a}function jc(){var a=z()[D+8>>2>>>0];a=N[ec[a]];--xa;return a()}\nfunction kc(a){if(!P){if(0===Z){var b=!1,c=!1;a((e=0)=>{if(!P&&(cc=e,b=!0,c)){Z=2;Zb(()=>lc(D));\"undefined\"!=typeof Browser&&Browser.hb.sb&&Browser.hb.resume();e=!1;try{var f=jc()}catch(q){f=q,e=!0}var h=!1;if(!D){var k=gc;k&&(gc=null,(e?k.reject:k.resolve)(f),h=!0)}if(e&&!h)throw f;}});c=!0;b||(Z=1,D=ic(),\"undefined\"!=typeof Browser&&Browser.hb.sb&&Browser.hb.pause(),Zb(()=>mc(D)))}else 2===Z?(Z=0,Zb(nc),oc(D),D=null,hc.forEach(e=>tb(e))):M(`invalid state: ${Z}`);return cc}}\nfunction pc(a){return kc(b=>{a().then(b)})}W.gb();\nvar qc=[null,Oa,Pa,bb,db,eb,ib,jb,kb,lb,mb,nb,ob,pb,qb,rb,sb,yb,zb,Mb,Nb,Ob,Pb,Qb,Tb],tc={r:function(a,b,c){return pc(async()=>{await B.xb(a,b,c)})},b:function(a,b,c){a>>>=0;(new Za(a)).gb(b>>>0,c>>>0);$a=a;ab++;throw $a;},O:function(a){rc(a>>>0,!F,1,!ka,131072,!1);W.lb()},l:function(a){a>>>=0;H?postMessage({cmd:\"cleanupThread\",thread:a}):Ka(a)},I:cb,i:db,U:eb,E:ib,G:jb,V:kb,S:lb,K:mb,R:nb,p:ob,F:pb,C:qb,T:rb,D:sb,q:()=>!0,A:function(a,b){a>>>=0;a==b>>>0?setTimeout(()=>Ta()):H?postMessage({targetThread:a,\ncmd:\"checkMailbox\"}):(a=W.Qa[a])&&a.postMessage({cmd:\"checkMailbox\"})},M:function(){return-1},N:ub,X:function(a){G&&W.Qa[a>>>0].ref()},u:function(a,b,c){a=b+2097152>>>0<4194305-!!a?(a>>>0)+4294967296*b:NaN;c>>>=0;a=new Date(1E3*a);z()[c>>2>>>0]=a.getUTCSeconds();z()[c+4>>2>>>0]=a.getUTCMinutes();z()[c+8>>2>>>0]=a.getUTCHours();z()[c+12>>2>>>0]=a.getUTCDate();z()[c+16>>2>>>0]=a.getUTCMonth();z()[c+20>>2>>>0]=a.getUTCFullYear()-1900;z()[c+24>>2>>>0]=a.getUTCDay();a=(a.getTime()-Date.UTC(a.getUTCFullYear(),\n0,1,0,0,0,0))/864E5|0;z()[c+28>>2>>>0]=a},v:function(a,b,c){a=b+2097152>>>0<4194305-!!a?(a>>>0)+4294967296*b:NaN;c>>>=0;a=new Date(1E3*a);z()[c>>2>>>0]=a.getSeconds();z()[c+4>>2>>>0]=a.getMinutes();z()[c+8>>2>>>0]=a.getHours();z()[c+12>>2>>>0]=a.getDate();z()[c+16>>2>>>0]=a.getMonth();z()[c+20>>2>>>0]=a.getFullYear()-1900;z()[c+24>>2>>>0]=a.getDay();b=(Y(a.getFullYear())?wb:xb)[a.getMonth()]+a.getDate()-1|0;z()[c+28>>2>>>0]=b;z()[c+36>>2>>>0]=-(60*a.getTimezoneOffset());b=(new Date(a.getFullYear(),\n6,1)).getTimezoneOffset();var e=(new Date(a.getFullYear(),0,1)).getTimezoneOffset();a=(b!=e&&a.getTimezoneOffset()==Math.min(e,b))|0;z()[c+32>>2>>>0]=a},w:function(a){a>>>=0;var b=new Date(z()[a+20>>2>>>0]+1900,z()[a+16>>2>>>0],z()[a+12>>2>>>0],z()[a+8>>2>>>0],z()[a+4>>2>>>0],z()[a>>2>>>0],0),c=z()[a+32>>2>>>0],e=b.getTimezoneOffset(),f=(new Date(b.getFullYear(),6,1)).getTimezoneOffset(),h=(new Date(b.getFullYear(),0,1)).getTimezoneOffset(),k=Math.min(h,f);0>c?z()[a+32>>2>>>0]=Number(f!=h&&k==e):\n0<c!=(k==e)&&(f=Math.max(h,f),b.setTime(b.getTime()+6E4*((0<c?k:f)-e)));z()[a+24>>2>>>0]=b.getDay();c=(Y(b.getFullYear())?wb:xb)[b.getMonth()]+b.getDate()-1|0;z()[a+28>>2>>>0]=c;z()[a>>2>>>0]=b.getSeconds();z()[a+4>>2>>>0]=b.getMinutes();z()[a+8>>2>>>0]=b.getHours();z()[a+12>>2>>>0]=b.getDate();z()[a+16>>2>>>0]=b.getMonth();z()[a+20>>2>>>0]=b.getYear();a=b.getTime()/1E3;return sc((U=a,1<=+Math.abs(U)?0<U?+Math.floor(U/4294967296)>>>0:~~+Math.ceil((U-+(~~U>>>0))/4294967296)>>>0:0)),a>>>0},s:yb,t:zb,\nz:function(a,b,c){function e(m){return(m=m.toTimeString().match(/\\(([A-Za-z ]+)\\)$/))?m[1]:\"GMT\"}a>>>=0;b>>>=0;c>>>=0;var f=(new Date).getFullYear(),h=new Date(f,0,1),k=new Date(f,6,1);f=h.getTimezoneOffset();var q=k.getTimezoneOffset(),n=Math.max(f,q);A()[a>>2>>>0]=60*n;z()[b>>2>>>0]=Number(f!=q);a=e(h);b=e(k);a=Bb(a);b=Bb(b);q<f?(A()[c>>2>>>0]=a,A()[c+4>>2>>>0]=b):(A()[c>>2>>>0]=b,A()[c+4>>2>>>0]=a)},d:()=>{M(\"\")},c:function(a,b,c){a>>>=0;b=Db(b>>>0,c>>>0);return Ha[a].apply(null,b)},k:function(a,\nb,c){a>>>=0;b=Db(b>>>0,c>>>0);return Ha[a].apply(null,b)},m:function(){},j:function(){return Date.now()},W:()=>{xa+=1;throw\"unwind\";},B:function(){return 4294901760},f:()=>performance.timeOrigin+performance.now(),g:function(){return G?require(\"os\").cpus().length:navigator.hardwareConcurrency},L:function(a,b,c,e){W.Pb=b>>>0;Ib.length=c;b=e>>>0>>3;for(e=0;e<c;e++)Ib[e]=da()[b+e>>>0];return(0>a?Ha[-a-1]:qc[a]).apply(null,Ib)},y:function(a){a>>>=0;var b=v().length;if(a<=b||4294901760<a)return!1;for(var c=\n1;4>=c;c*=2){var e=b*(1+.2/c);e=Math.min(e,a+100663296);var f=Math;e=Math.max(a,e);a:{f=f.min.call(f,4294901760,e+(65536-e%65536)%65536)-l.buffer.byteLength+65535>>>16;try{l.grow(f);t();var h=1;break a}catch(k){}h=void 0}if(h)return!0}return!1},P:Mb,Q:Nb,H:Qa,h:Ob,o:Pb,x:Qb,n:Tb,a:l||B.wasmMemory,J:Yb,e:function(a,b,c,e){return Yb(a>>>0,b>>>0,c>>>0,e>>>0)}};\n(function(){function a(c,e){c=c.exports;c=$b(c);N=c=uc(c);W.mb.push(N.Da);va.unshift(N.Y);sa=e;Ba();return c}var b={a:tc};Aa();if(B.instantiateWasm)try{return B.instantiateWasm(b,a)}catch(c){K(\"Module.instantiateWasm callback failed with error: \"+c),C(c)}Ga(b,function(c){a(c.instance,c.module)}).catch(C);return{}})();B._OrtInit=(a,b)=>(B._OrtInit=N.Z)(a,b);B._OrtGetLastError=(a,b)=>(B._OrtGetLastError=N._)(a,b);\nB._OrtCreateSessionOptions=(a,b,c,e,f,h,k,q,n,m)=>(B._OrtCreateSessionOptions=N.$)(a,b,c,e,f,h,k,q,n,m);B._OrtAppendExecutionProvider=(a,b)=>(B._OrtAppendExecutionProvider=N.aa)(a,b);B._OrtAddFreeDimensionOverride=(a,b,c)=>(B._OrtAddFreeDimensionOverride=N.ba)(a,b,c);B._OrtAddSessionConfigEntry=(a,b,c)=>(B._OrtAddSessionConfigEntry=N.ca)(a,b,c);B._OrtReleaseSessionOptions=a=>(B._OrtReleaseSessionOptions=N.da)(a);B._OrtCreateSession=(a,b,c)=>(B._OrtCreateSession=N.ea)(a,b,c);\nB._OrtReleaseSession=a=>(B._OrtReleaseSession=N.fa)(a);B._OrtGetInputOutputCount=(a,b,c)=>(B._OrtGetInputOutputCount=N.ga)(a,b,c);B._OrtGetInputName=(a,b)=>(B._OrtGetInputName=N.ha)(a,b);B._OrtGetOutputName=(a,b)=>(B._OrtGetOutputName=N.ia)(a,b);B._OrtFree=a=>(B._OrtFree=N.ja)(a);B._OrtCreateTensor=(a,b,c,e,f,h)=>(B._OrtCreateTensor=N.ka)(a,b,c,e,f,h);B._OrtGetTensorData=(a,b,c,e,f)=>(B._OrtGetTensorData=N.la)(a,b,c,e,f);B._OrtReleaseTensor=a=>(B._OrtReleaseTensor=N.ma)(a);\nB._OrtCreateRunOptions=(a,b,c,e)=>(B._OrtCreateRunOptions=N.na)(a,b,c,e);B._OrtAddRunConfigEntry=(a,b,c)=>(B._OrtAddRunConfigEntry=N.oa)(a,b,c);B._OrtReleaseRunOptions=a=>(B._OrtReleaseRunOptions=N.pa)(a);B._OrtCreateBinding=a=>(B._OrtCreateBinding=N.qa)(a);B._OrtBindInput=(a,b,c)=>(B._OrtBindInput=N.ra)(a,b,c);B._OrtBindOutput=(a,b,c,e)=>(B._OrtBindOutput=N.sa)(a,b,c,e);B._OrtClearBoundOutputs=a=>(B._OrtClearBoundOutputs=N.ta)(a);B._OrtReleaseBinding=a=>(B._OrtReleaseBinding=N.ua)(a);\nB._OrtRunWithBinding=(a,b,c,e,f)=>(B._OrtRunWithBinding=N.va)(a,b,c,e,f);B._OrtRun=(a,b,c,e,f,h,k,q)=>(B._OrtRun=N.wa)(a,b,c,e,f,h,k,q);B._OrtEndProfiling=a=>(B._OrtEndProfiling=N.xa)(a);B._JsepOutput=(a,b,c)=>(B._JsepOutput=N.ya)(a,b,c);B._JsepGetNodeName=a=>(B._JsepGetNodeName=N.za)(a);var Sa=B._pthread_self=()=>(Sa=B._pthread_self=N.Aa)(),Ab=B._malloc=a=>(Ab=B._malloc=N.Ba)(a),oc=B._free=a=>(oc=B._free=N.Ca)(a);B.__emscripten_tls_init=()=>(B.__emscripten_tls_init=N.Da)();\nvar rc=B.__emscripten_thread_init=(a,b,c,e,f,h)=>(rc=B.__emscripten_thread_init=N.Fa)(a,b,c,e,f,h);B.__emscripten_thread_crashed=()=>(B.__emscripten_thread_crashed=N.Ga)();\nvar Hb=(a,b,c,e)=>(Hb=N.Ha)(a,b,c,e),Ra=a=>(Ra=N.Ia)(a),Ya=B.__emscripten_thread_exit=a=>(Ya=B.__emscripten_thread_exit=N.Ja)(a),vb=B.__emscripten_check_mailbox=()=>(vb=B.__emscripten_check_mailbox=N.Ka)(),sc=a=>(sc=N.La)(a),Va=(a,b)=>(Va=N.Ma)(a,b),Eb=()=>(Eb=N.Na)(),Wa=a=>(Wa=N.Oa)(a),Gb=a=>(Gb=N.Pa)(a),Xa=B.dynCall_ii=(a,b)=>(Xa=B.dynCall_ii=N.Ra)(a,b),mc=a=>(mc=N.Sa)(a),bc=()=>(bc=N.Ta)(),lc=a=>(lc=N.Ua)(a),nc=()=>(nc=N.Va)();B.___start_em_js=917678;B.___stop_em_js=917839;\nfunction uc(a){a=Object.assign({},a);var b=e=>()=>e()>>>0,c=e=>f=>e(f)>>>0;a.__errno_location=b(a.__errno_location);a.pthread_self=b(a.pthread_self);a.malloc=c(a.malloc);a.stackSave=b(a.stackSave);a.stackAlloc=c(a.stackAlloc);return a}B.keepRuntimeAlive=ya;B.wasmMemory=l;B.stackAlloc=Gb;B.stackSave=Eb;B.stackRestore=Wa;B.UTF8ToString=V;B.stringToUTF8=hb;B.lengthBytesUTF8=fb;B.ExitStatus=Ia;B.PThread=W;var vc;S=function wc(){vc||xc();vc||(S=wc)};\nfunction xc(){function a(){if(!vc&&(vc=!0,B.calledRun=!0,!P)){H||Ua(va);fa(B);if(B.onRuntimeInitialized)B.onRuntimeInitialized();if(!H){if(B.postRun)for(\"function\"==typeof B.postRun&&(B.postRun=[B.postRun]);B.postRun.length;){var b=B.postRun.shift();wa.unshift(b)}Ua(wa)}}}if(!(0<R))if(H)fa(B),H||Ua(va),startWorker(B);else{if(B.preRun)for(\"function\"==typeof B.preRun&&(B.preRun=[B.preRun]);B.preRun.length;)ua.unshift(B.preRun.shift());Ua(ua);0<R||(B.setStatus?(B.setStatus(\"Running...\"),setTimeout(function(){setTimeout(function(){B.setStatus(\"\")},\n1);a()},1)):a())}}if(B.preInit)for(\"function\"==typeof B.preInit&&(B.preInit=[B.preInit]);0<B.preInit.length;)B.preInit.pop()();xc();\n\n\n  return moduleArg.ready\n}\n\n);\n})();\nif (typeof exports === 'object' && typeof module === 'object')\n  module.exports = ortWasmThreaded;\nelse if (typeof define === 'function' && define['amd'])\n  define([], () => ortWasmThreaded);\n", "\"use strict\";var Module={};var ENVIRONMENT_IS_NODE=typeof process==\"object\"&&typeof process.versions==\"object\"&&typeof process.versions.node==\"string\";if(ENVIRONMENT_IS_NODE){var nodeWorkerThreads=require(\"worker_threads\");var parentPort=nodeWorkerThreads.parentPort;parentPort.on(\"message\",data=>onmessage({data:data}));var fs=require(\"fs\");Object.assign(global,{self:global,require:require,Module:Module,location:{href:__filename},Worker:nodeWorkerThreads.Worker,importScripts:f=>(0,eval)(fs.readFileSync(f,\"utf8\")+\"//# sourceURL=\"+f),postMessage:msg=>parentPort.postMessage(msg),performance:global.performance||{now:Date.now}})}var initializedJS=false;function threadPrintErr(){var text=Array.prototype.slice.call(arguments).join(\" \");if(ENVIRONMENT_IS_NODE){fs.writeSync(2,text+\"\\n\");return}console.error(text)}function threadAlert(){var text=Array.prototype.slice.call(arguments).join(\" \");postMessage({cmd:\"alert\",text:text,threadId:Module[\"_pthread_self\"]()})}var err=threadPrintErr;self.alert=threadAlert;Module[\"instantiateWasm\"]=(info,receiveInstance)=>{var module=Module[\"wasmModule\"];Module[\"wasmModule\"]=null;var instance=new WebAssembly.Instance(module,info);return receiveInstance(instance)};self.onunhandledrejection=e=>{throw e.reason??e};function handleMessage(e){try{if(e.data.cmd===\"load\"){let messageQueue=[];self.onmessage=e=>messageQueue.push(e);self.startWorker=instance=>{Module=instance;postMessage({\"cmd\":\"loaded\"});for(let msg of messageQueue){handleMessage(msg)}self.onmessage=handleMessage};Module[\"wasmModule\"]=e.data.wasmModule;for(const handler of e.data.handlers){Module[handler]=(...args)=>{postMessage({cmd:\"callHandler\",handler:handler,args:args})}}Module[\"wasmMemory\"]=e.data.wasmMemory;Module[\"buffer\"]=Module[\"wasmMemory\"].buffer;Module[\"ENVIRONMENT_IS_PTHREAD\"]=true;if(typeof e.data.urlOrBlob==\"string\"){importScripts(e.data.urlOrBlob)}else{var objectUrl=URL.createObjectURL(e.data.urlOrBlob);importScripts(objectUrl);URL.revokeObjectURL(objectUrl)}ortWasmThreaded(Module)}else if(e.data.cmd===\"run\"){Module[\"__emscripten_thread_init\"](e.data.pthread_ptr,/*isMainBrowserThread=*/0,/*isMainRuntimeThread=*/0,/*canBlock=*/1);Module[\"__emscripten_thread_mailbox_await\"](e.data.pthread_ptr);Module[\"establishStackSpace\"]();Module[\"PThread\"].receiveObjectTransfer(e.data);Module[\"PThread\"].threadInitTLS();if(!initializedJS){initializedJS=true}try{Module[\"invokeEntryPoint\"](e.data.start_routine,e.data.arg)}catch(ex){if(ex!=\"unwind\"){throw ex}}}else if(e.data.cmd===\"cancel\"){if(Module[\"_pthread_self\"]()){Module[\"__emscripten_thread_exit\"](-1)}}else if(e.data.target===\"setimmediate\"){}else if(e.data.cmd===\"checkMailbox\"){if(initializedJS){Module[\"checkMailbox\"]()}}else if(e.data.cmd){err(\"worker.js received unknown command \"+e.data.cmd);err(e.data)}}catch(ex){if(Module[\"__emscripten_thread_crashed\"]){Module[\"__emscripten_thread_crashed\"]()}throw ex}}self.onmessage=handleMessage;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Tensor} from 'onnxruntime-common';\n\n// a dummy type declaration for Float16Array in case any polyfill is available.\ndeclare global {\n  // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any\n  const Float16Array: any;\n}\n\n// This file includes common definitions. They do NOT have dependency on the WebAssembly instance.\n\n/**\n * Copied from ONNX definition. Use this to drop dependency 'onnx_proto' to decrease compiled .js file size.\n */\nexport const enum DataType {\n  undefined = 0,\n  float = 1,\n  uint8 = 2,\n  int8 = 3,\n  uint16 = 4,\n  int16 = 5,\n  int32 = 6,\n  int64 = 7,\n  string = 8,\n  bool = 9,\n  float16 = 10,\n  double = 11,\n  uint32 = 12,\n  uint64 = 13,\n  complex64 = 14,\n  complex128 = 15,\n  bfloat16 = 16\n}\n\n/**\n * Map string tensor data to enum value\n */\nexport const tensorDataTypeStringToEnum = (type: string): DataType => {\n  switch (type) {\n    case 'int8':\n      return DataType.int8;\n    case 'uint8':\n      return DataType.uint8;\n    case 'bool':\n      return DataType.bool;\n    case 'int16':\n      return DataType.int16;\n    case 'uint16':\n      return DataType.uint16;\n    case 'int32':\n      return DataType.int32;\n    case 'uint32':\n      return DataType.uint32;\n    case 'float16':\n      return DataType.float16;\n    case 'float32':\n      return DataType.float;\n    case 'float64':\n      return DataType.double;\n    case 'string':\n      return DataType.string;\n    case 'int64':\n      return DataType.int64;\n    case 'uint64':\n      return DataType.uint64;\n\n    default:\n      throw new Error(`unsupported data type: ${type}`);\n  }\n};\n\n/**\n * Map enum value to string tensor data\n */\nexport const tensorDataTypeEnumToString = (typeProto: DataType): Tensor.Type => {\n  switch (typeProto) {\n    case DataType.int8:\n      return 'int8';\n    case DataType.uint8:\n      return 'uint8';\n    case DataType.bool:\n      return 'bool';\n    case DataType.int16:\n      return 'int16';\n    case DataType.uint16:\n      return 'uint16';\n    case DataType.int32:\n      return 'int32';\n    case DataType.uint32:\n      return 'uint32';\n    case DataType.float16:\n      return 'float16';\n    case DataType.float:\n      return 'float32';\n    case DataType.double:\n      return 'float64';\n    case DataType.string:\n      return 'string';\n    case DataType.int64:\n      return 'int64';\n    case DataType.uint64:\n      return 'uint64';\n\n    default:\n      throw new Error(`unsupported data type: ${typeProto}`);\n  }\n};\n\n/**\n * get tensor element size in bytes by the given data type\n * @returns size in integer or undefined if the data type is not supported\n */\nexport const getTensorElementSize = (dateType: number): number|\n    undefined => [undefined, 4, 1, 1, 2, 2, 4, 8, undefined, 1, 2, 8, 4, 8, undefined, undefined, undefined][dateType];\n\n/**\n * get typed array constructor by the given tensor type\n */\nexport const tensorTypeToTypedArrayConstructor = (type: Tensor.Type): Float32ArrayConstructor|Uint8ArrayConstructor|\n    Int8ArrayConstructor|Uint16ArrayConstructor|Int16ArrayConstructor|Int32ArrayConstructor|BigInt64ArrayConstructor|\n    Uint8ArrayConstructor|Float64ArrayConstructor|Uint32ArrayConstructor|BigUint64ArrayConstructor => {\n      switch (type) {\n        case 'float16':\n          // allow Float16Array polyfill.\n          return typeof Float16Array !== 'undefined' && Float16Array.from ? Float16Array : Uint16Array;\n        case 'float32':\n          return Float32Array;\n        case 'uint8':\n          return Uint8Array;\n        case 'int8':\n          return Int8Array;\n        case 'uint16':\n          return Uint16Array;\n        case 'int16':\n          return Int16Array;\n        case 'int32':\n          return Int32Array;\n        case 'bool':\n          return Uint8Array;\n        case 'float64':\n          return Float64Array;\n        case 'uint32':\n          return Uint32Array;\n        case 'int64':\n          return BigInt64Array;\n        case 'uint64':\n          return BigUint64Array;\n        default:\n          throw new Error(`unsupported type: ${type}`);\n      }\n    };\n\n/**\n * Map string log level to integer value\n */\nexport const logLevelStringToEnum = (logLevel?: 'verbose'|'info'|'warning'|'error'|'fatal'): number => {\n  switch (logLevel) {\n    case 'verbose':\n      return 0;\n    case 'info':\n      return 1;\n    case 'warning':\n      return 2;\n    case 'error':\n      return 3;\n    case 'fatal':\n      return 4;\n    default:\n      throw new Error(`unsupported logging level: ${logLevel}`);\n  }\n};\n\n/**\n * Check whether the given tensor type is supported by GPU buffer\n */\nexport const isGpuBufferSupportedType = (type: Tensor.Type): type is Tensor.GpuBufferDataTypes => type === 'float32' ||\n    type === 'float16' || type === 'int32' || type === 'int64' || type === 'uint32' || type === 'uint8' ||\n    type === 'bool';\n\n/**\n * Map string data location to integer value\n */\nexport const dataLocationStringToEnum = (location: Tensor.DataLocation): number => {\n  switch (location) {\n    case 'none':\n      return 0;\n    case 'cpu':\n      return 1;\n    case 'cpu-pinned':\n      return 2;\n    case 'texture':\n      return 3;\n    case 'gpu-buffer':\n      return 4;\n    default:\n      throw new Error(`unsupported data location: ${location}`);\n  }\n};\n\n/**\n * Map integer data location to string value\n */\nexport const dataLocationEnumToString = (location: number): Tensor.DataLocation|undefined =>\n    (['none', 'cpu', 'cpu-pinned', 'texture', 'gpu-buffer'] as const)[location];\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Backend} from './backend.js';\nimport {InferenceSession} from './inference-session.js';\n\ninterface BackendInfo {\n  backend: Backend;\n  priority: number;\n\n  initPromise?: Promise<void>;\n  initialized?: boolean;\n  aborted?: boolean;\n  error?: string;\n}\n\nconst backends: Map<string, BackendInfo> = new Map();\nconst backendsSortedByPriority: string[] = [];\n\n/**\n * Register a backend.\n *\n * @param name - the name as a key to lookup as an execution provider.\n * @param backend - the backend object.\n * @param priority - an integer indicating the priority of the backend. Higher number means higher priority. if priority\n * < 0, it will be considered as a 'beta' version and will not be used as a fallback backend by default.\n *\n * @ignore\n */\nexport const registerBackend = (name: string, backend: Backend, priority: number): void => {\n  if (backend && typeof backend.init === 'function' && typeof backend.createInferenceSessionHandler === 'function') {\n    const currentBackend = backends.get(name);\n    if (currentBackend === undefined) {\n      backends.set(name, {backend, priority});\n    } else if (currentBackend.priority > priority) {\n      // same name is already registered with a higher priority. skip registeration.\n      return;\n    } else if (currentBackend.priority === priority) {\n      if (currentBackend.backend !== backend) {\n        throw new Error(`cannot register backend \"${name}\" using priority ${priority}`);\n      }\n    }\n\n    if (priority >= 0) {\n      const i = backendsSortedByPriority.indexOf(name);\n      if (i !== -1) {\n        backendsSortedByPriority.splice(i, 1);\n      }\n\n      for (let i = 0; i < backendsSortedByPriority.length; i++) {\n        if (backends.get(backendsSortedByPriority[i])!.priority <= priority) {\n          backendsSortedByPriority.splice(i, 0, name);\n          return;\n        }\n      }\n      backendsSortedByPriority.push(name);\n    }\n    return;\n  }\n\n  throw new TypeError('not a valid backend');\n};\n\n/**\n * Try to resolve and initialize a backend.\n *\n * @param backendName - the name of the backend.\n * @returns the backend instance if resolved and initialized successfully, or an error message if failed.\n */\nconst tryResolveAndInitializeBackend = async(backendName: string): Promise<Backend|string> => {\n  const backendInfo = backends.get(backendName);\n  if (!backendInfo) {\n    return 'backend not found.';\n  }\n\n  if (backendInfo.initialized) {\n    return backendInfo.backend;\n  } else if (backendInfo.aborted) {\n    return backendInfo.error!;\n  } else {\n    const isInitializing = !!backendInfo.initPromise;\n    try {\n      if (!isInitializing) {\n        backendInfo.initPromise = backendInfo.backend.init(backendName);\n      }\n      await backendInfo.initPromise;\n      backendInfo.initialized = true;\n      return backendInfo.backend;\n    } catch (e) {\n      if (!isInitializing) {\n        backendInfo.error = `${e}`;\n        backendInfo.aborted = true;\n      }\n      return backendInfo.error!;\n    } finally {\n      delete backendInfo.initPromise;\n    }\n  }\n};\n\n/**\n * Resolve execution providers from the specific session options.\n *\n * @param options - the session options object.\n * @returns a promise that resolves to a tuple of an initialized backend instance and a session options object with\n * filtered EP list.\n *\n * @ignore\n */\nexport const resolveBackendAndExecutionProviders = async(options: InferenceSession.SessionOptions):\n    Promise<[backend: Backend, options: InferenceSession.SessionOptions]> => {\n      // extract backend hints from session options\n      const eps = options.executionProviders || [];\n      const backendHints = eps.map(i => typeof i === 'string' ? i : i.name);\n      const backendNames = backendHints.length === 0 ? backendsSortedByPriority : backendHints;\n\n      // try to resolve and initialize all requested backends\n      let backend: Backend|undefined;\n      const errors = [];\n      const availableBackendNames = new Set<string>();\n      for (const backendName of backendNames) {\n        const resolveResult = await tryResolveAndInitializeBackend(backendName);\n        if (typeof resolveResult === 'string') {\n          errors.push({name: backendName, err: resolveResult});\n        } else {\n          if (!backend) {\n            backend = resolveResult;\n          }\n          if (backend === resolveResult) {\n            availableBackendNames.add(backendName);\n          }\n        }\n      }\n\n      // if no backend is available, throw error.\n      if (!backend) {\n        throw new Error(`no available backend found. ERR: ${errors.map(e => `[${e.name}] ${e.err}`).join(', ')}`);\n      }\n\n      // for each explicitly requested backend, if it's not available, output warning message.\n      for (const {name, err} of errors) {\n        if (backendHints.includes(name)) {\n          // eslint-disable-next-line no-console\n          console.warn(`removing requested execution provider \"${\n              name}\" from session options because it is not available: ${err}`);\n        }\n      }\n\n      const filteredEps = eps.filter(i => availableBackendNames.has(typeof i === 'string' ? i : i.name));\n\n      return [\n        backend, new Proxy(options, {\n          get: (target, prop) => {\n            if (prop === 'executionProviders') {\n              return filteredEps;\n            }\n            return Reflect.get(target, prop);\n          }\n        })\n      ];\n    };\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {InferenceSession} from './inference-session.js';\nimport {OnnxValue} from './onnx-value.js';\nimport {TrainingSession} from './training-session.js';\n\n/**\n * @ignore\n */\nexport declare namespace SessionHandler {\n  type FeedsType = {[name: string]: OnnxValue};\n  type FetchesType = {[name: string]: OnnxValue | null};\n  type ReturnType = {[name: string]: OnnxValue};\n}\n\n/**\n * Represents shared SessionHandler functionality\n *\n * @ignore\n */\ninterface SessionHandler {\n  dispose(): Promise<void>;\n\n  readonly inputNames: readonly string[];\n  readonly outputNames: readonly string[];\n}\n\n/**\n * Represent a handler instance of an inference session.\n *\n * @ignore\n */\nexport interface InferenceSessionHandler extends SessionHandler {\n  startProfiling(): void;\n  endProfiling(): void;\n\n  run(feeds: SessionHandler.FeedsType, fetches: SessionHandler.FetchesType,\n      options: InferenceSession.RunOptions): Promise<SessionHandler.ReturnType>;\n}\n\n/**\n * Represent a handler instance of a training inference session.\n *\n * @ignore\n */\nexport interface TrainingSessionHandler extends SessionHandler {\n  readonly evalInputNames: readonly string[];\n  readonly evalOutputNames: readonly string[];\n\n  lazyResetGrad(): Promise<void>;\n  runTrainStep(\n      feeds: SessionHandler.FeedsType, fetches: SessionHandler.FetchesType,\n      options: InferenceSession.RunOptions): Promise<SessionHandler.ReturnType>;\n  runOptimizerStep(options: InferenceSession.RunOptions): Promise<void>;\n  runEvalStep(\n      feeds: SessionHandler.FeedsType, fetches: SessionHandler.FetchesType,\n      options: InferenceSession.RunOptions): Promise<SessionHandler.ReturnType>;\n\n  getParametersSize(trainableOnly: boolean): Promise<number>;\n  loadParametersBuffer(buffer: Uint8Array, trainableOnly: boolean): Promise<void>;\n  getContiguousParameters(trainableOnly: boolean): Promise<OnnxValue>;\n}\n\n/**\n * Represent a backend that provides implementation of model inferencing.\n *\n * @ignore\n */\nexport interface Backend {\n  /**\n   * Initialize the backend asynchronously. Should throw when failed.\n   */\n  init(backendName: string): Promise<void>;\n\n  createInferenceSessionHandler(uriOrBuffer: string|Uint8Array, options?: InferenceSession.SessionOptions):\n      Promise<InferenceSessionHandler>;\n\n  createTrainingSessionHandler?\n      (checkpointStateUriOrBuffer: TrainingSession.UriOrBuffer, trainModelUriOrBuffer: TrainingSession.UriOrBuffer,\n       evalModelUriOrBuffer: TrainingSession.UriOrBuffer, optimizerModelUriOrBuffer: TrainingSession.UriOrBuffer,\n       options: InferenceSession.SessionOptions): Promise<TrainingSessionHandler>;\n}\n\nexport {registerBackend} from './backend-impl.js';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// This file is generated by /js/scripts/update-version.ts\n// Do not modify file content manually.\n\nexport const version = '1.18.0';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Env} from './env.js';\nimport {version} from './version.js';\n\ntype LogLevelType = Env['logLevel'];\n\nlet logLevelValue: Required<LogLevelType> = 'warning';\n\nexport const env: Env = {\n  wasm: {} as Env.WebAssemblyFlags,\n  webgl: {} as Env.WebGLFlags,\n  webgpu: {} as Env.WebGpuFlags,\n  versions: {common: version},\n\n  set logLevel(value: LogLevelType) {\n    if (value === undefined) {\n      return;\n    }\n    if (typeof value !== 'string' || ['verbose', 'info', 'warning', 'error', 'fatal'].indexOf(value) === -1) {\n      throw new Error(`Unsupported logging level: ${value}`);\n    }\n    logLevelValue = value;\n  },\n  get logLevel(): Required<LogLevelType> {\n    return logLevelValue;\n  },\n};\n\n// set property 'logLevel' so that they can be correctly transferred to worker by `postMessage()`.\nObject.defineProperty(env, 'logLevel', {enumerable: true});\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {env as envImpl} from './env-impl.js';\n\nexport declare namespace Env {\n  export type WasmPrefixOrFilePaths = string|{\n    /* eslint-disable @typescript-eslint/naming-convention */\n    'ort-wasm.wasm'?: string;\n    'ort-wasm-threaded.wasm'?: string;\n    'ort-wasm-simd.wasm'?: string;\n    'ort-training-wasm-simd.wasm'?: string;\n    'ort-wasm-simd-threaded.wasm'?: string;\n    /* eslint-enable @typescript-eslint/naming-convention */\n  };\n  export interface WebAssemblyFlags {\n    /**\n     * set or get number of thread(s). If omitted or set to 0, number of thread(s) will be determined by system. If set\n     * to 1, no worker thread will be spawned.\n     *\n     * This setting is available only when WebAssembly multithread feature is available in current context.\n     *\n     * @defaultValue `0`\n     */\n    numThreads?: number;\n\n    /**\n     * set or get a boolean value indicating whether to enable SIMD. If set to false, SIMD will be forcely disabled.\n     *\n     * This setting is available only when WebAssembly SIMD feature is available in current context.\n     *\n     * @defaultValue `true`\n     */\n    simd?: boolean;\n\n    /**\n     * set or get a boolean value indicating whether to enable trace.\n     *\n     * @deprecated Use `env.trace` instead. If `env.trace` is set, this property will be ignored.\n     * @defaultValue `false`\n     */\n    trace?: boolean;\n\n    /**\n     * Set or get a number specifying the timeout for initialization of WebAssembly backend, in milliseconds. A zero\n     * value indicates no timeout is set.\n     *\n     * @defaultValue `0`\n     */\n    initTimeout?: number;\n\n    /**\n     * Set a custom URL prefix to the .wasm files or a set of overrides for each .wasm file. The override path should be\n     * an absolute path.\n     */\n    wasmPaths?: WasmPrefixOrFilePaths;\n\n    /**\n     * Set or get a boolean value indicating whether to proxy the execution of main thread to a worker thread.\n     *\n     * @defaultValue `false`\n     */\n    proxy?: boolean;\n  }\n\n  export interface WebGLFlags {\n    /**\n     * Set or get the WebGL Context ID (webgl or webgl2).\n     *\n     * @defaultValue `'webgl2'`\n     */\n    contextId?: 'webgl'|'webgl2';\n    /**\n     * Get the WebGL rendering context.\n     */\n    readonly context: WebGLRenderingContext;\n    /**\n     * Set or get the maximum batch size for matmul. 0 means to disable batching.\n     *\n     * @deprecated\n     */\n    matmulMaxBatchSize?: number;\n    /**\n     * Set or get the texture cache mode.\n     *\n     * @defaultValue `'full'`\n     */\n    textureCacheMode?: 'initializerOnly'|'full';\n    /**\n     * Set or get the packed texture mode\n     *\n     * @defaultValue `false`\n     */\n    pack?: boolean;\n    /**\n     * Set or get whether enable async download.\n     *\n     * @defaultValue `false`\n     */\n    async?: boolean;\n  }\n\n  export interface WebGpuProfilingDataV1TensorMetadata {\n    dims: readonly number[];\n    dataType: string;\n  }\n  export interface WebGpuProfilingDataV1 {\n    version: 1;\n    inputsMetadata: readonly WebGpuProfilingDataV1TensorMetadata[];\n    outputsMetadata: readonly WebGpuProfilingDataV1TensorMetadata[];\n    kernelId: number;\n    kernelType: string;\n    kernelName: string;\n    programName: string;\n    startTime: number;\n    endTime: number;\n  }\n\n  export type WebGpuProfilingData = WebGpuProfilingDataV1;\n\n  export interface WebGpuFlags {\n    /**\n     * Set or get the profiling mode.\n     *\n     * @deprecated Use `env.webgpu.profiling.mode` instead. If `env.webgpu.profiling.mode` is set, this property will be\n     * ignored.\n     */\n    profilingMode?: 'off'|'default';\n    /**\n     * Set or get the profiling configuration.\n     */\n    profiling?: {\n      /**\n       * Set or get the profiling mode.\n       *\n       * @defaultValue `'off'`\n       */\n      mode?: 'off'|'default';\n\n      /**\n       * Set or get a callback function when a profiling data is received. If not set, the profiling data will be\n       * printed to console.\n       */\n      ondata?: (data: WebGpuProfilingData) => void;\n    };\n    /**\n     * Set or get the power preference.\n     *\n     * Setting this property only has effect before the first WebGPU inference session is created. The value will be\n     * used as options for `navigator.gpu.requestAdapter()`.\n     *\n     * See {@link https://gpuweb.github.io/gpuweb/#dictdef-gpurequestadapteroptions} for more details.\n     *\n     * @defaultValue `undefined`\n     */\n    powerPreference?: 'low-power'|'high-performance';\n    /**\n     * Set or get the force fallback adapter flag.\n     *\n     * Setting this property only has effect before the first WebGPU inference session is created. The value will be\n     * used as options for `navigator.gpu.requestAdapter()`.\n     *\n     * See {@link https://gpuweb.github.io/gpuweb/#dictdef-gpurequestadapteroptions} for more details.\n     *\n     * @defaultValue `undefined`\n     */\n    forceFallbackAdapter?: boolean;\n    /**\n     * Set or get the adapter for WebGPU.\n     *\n     * Setting this property only has effect before the first WebGPU inference session is created. The value will be\n     * used as the GPU adapter for the underlying WebGPU backend to create GPU device.\n     *\n     * If this property is not set, it will be available to get after the first WebGPU inference session is created. The\n     * value will be the GPU adapter that created by the underlying WebGPU backend.\n     *\n     * When use with TypeScript, the type of this property is `GPUAdapter` defined in \"@webgpu/types\".\n     * Use `const adapter = env.webgpu.adapter as GPUAdapter;` in TypeScript to access this property with correct type.\n     *\n     * see comments on {@link Tensor.GpuBufferType}\n     */\n    adapter: unknown;\n    /**\n     * Get the device for WebGPU.\n     *\n     * This property is only available after the first WebGPU inference session is created.\n     *\n     * When use with TypeScript, the type of this property is `GPUDevice` defined in \"@webgpu/types\".\n     * Use `const device = env.webgpu.device as GPUDevice;` in TypeScript to access this property with correct type.\n     *\n     * see comments on {@link Tensor.GpuBufferType} for more details about why not use types defined in \"@webgpu/types\".\n     */\n    readonly device: unknown;\n    /**\n     * Set or get whether validate input content.\n     *\n     * @defaultValue `false`\n     */\n    validateInputContent?: boolean;\n  }\n}\n\nexport interface Env {\n  /**\n   * set the severity level for logging.\n   *\n   * @defaultValue `'warning'`\n   */\n  logLevel?: 'verbose'|'info'|'warning'|'error'|'fatal';\n\n  /**\n   * Indicate whether run in debug mode.\n   *\n   * @defaultValue `false`\n   */\n  debug?: boolean;\n\n  /**\n   * set or get a boolean value indicating whether to enable trace.\n   *\n   * @defaultValue `false`\n   */\n  trace?: boolean;\n\n  /**\n   * Get version of the current package.\n   */\n  readonly versions: {\n    readonly common: string;\n    readonly web?: string;\n    readonly node?: string;\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    readonly 'react-native'?: string;\n  };\n\n  /**\n   * Represent a set of flags for WebAssembly\n   */\n  readonly wasm: Env.WebAssemblyFlags;\n\n  /**\n   * Represent a set of flags for WebGL\n   */\n  readonly webgl: Env.WebGLFlags;\n\n  /**\n   * Represent a set of flags for WebGPU\n   */\n  readonly webgpu: Env.WebGpuFlags;\n\n  [name: string]: unknown;\n}\n\n/**\n * Represent a set of flags as a global singleton.\n */\nexport const env: Env = envImpl;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorToDataUrlOptions, TensorToImageDataOptions} from './tensor-conversion.js';\nimport {Tensor} from './tensor.js';\n\n/**\n * implementation of Tensor.toDataURL()\n */\nexport const tensorToDataURL = (tensor: Tensor, options?: TensorToDataUrlOptions): string => {\n  const canvas = typeof document !== 'undefined' ? document.createElement('canvas') : (new OffscreenCanvas(1, 1));\n  canvas.width = tensor.dims[3];\n  canvas.height = tensor.dims[2];\n  const pixels2DContext =\n      canvas.getContext('2d') as (CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | null);\n\n  if (pixels2DContext != null) {\n    // Default values for height and width & format\n    let width: number;\n    let height: number;\n    if (options?.tensorLayout !== undefined && options.tensorLayout === 'NHWC') {\n      width = tensor.dims[2];\n      height = tensor.dims[3];\n    } else {  // Default layout is NCWH\n      width = tensor.dims[3];\n      height = tensor.dims[2];\n    }\n\n    const inputformat = options?.format !== undefined ? options.format : 'RGB';\n\n    const norm = options?.norm;\n    let normMean: [number, number, number, number];\n    let normBias: [number, number, number, number];\n    if (norm === undefined || norm.mean === undefined) {\n      normMean = [255, 255, 255, 255];\n    } else {\n      if (typeof (norm.mean) === 'number') {\n        normMean = [norm.mean, norm.mean, norm.mean, norm.mean];\n      } else {\n        normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 0];\n        if (norm.mean[3] !== undefined) {\n          normMean[3] = norm.mean[3];\n        }\n      }\n    }\n    if (norm === undefined || norm.bias === undefined) {\n      normBias = [0, 0, 0, 0];\n    } else {\n      if (typeof (norm.bias) === 'number') {\n        normBias = [norm.bias, norm.bias, norm.bias, norm.bias];\n      } else {\n        normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];\n        if (norm.bias[3] !== undefined) {\n          normBias[3] = norm.bias[3];\n        }\n      }\n    }\n\n    const stride = height * width;\n    // Default pointer assignments\n    let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;\n\n    // Updating the pointer assignments based on the input image format\n    if (inputformat === 'RGBA') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n      aTensorPointer = stride * 3;\n    } else if (inputformat === 'RGB') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n    } else if (inputformat === 'RBG') {\n      rTensorPointer = 0;\n      bTensorPointer = stride;\n      gTensorPointer = stride * 2;\n    }\n\n    for (let i = 0; i < height; i++) {\n      for (let j = 0; j < width; j++) {\n        const R = ((tensor.data[rTensorPointer++] as number) - normBias[0]) * normMean[0];  // R value\n        const G = ((tensor.data[gTensorPointer++] as number) - normBias[1]) * normMean[1];  // G value\n        const B = ((tensor.data[bTensorPointer++] as number) - normBias[2]) * normMean[2];  // B value\n        const A = aTensorPointer === -1 ?\n            255 :\n            ((tensor.data[aTensorPointer++] as number) - normBias[3]) * normMean[3];  // A value\n        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n        pixels2DContext.fillStyle = 'rgba(' + R + ',' + G + ',' + B + ',' + A + ')';\n        pixels2DContext.fillRect(j, i, 1, 1);\n      }\n    }\n    if ('toDataURL' in canvas) {\n      return canvas.toDataURL();\n    } else {\n      throw new Error('toDataURL is not supported');\n    }\n  } else {\n    throw new Error('Can not access image data');\n  }\n};\n\n/**\n * implementation of Tensor.toImageData()\n */\nexport const tensorToImageData = (tensor: Tensor, options?: TensorToImageDataOptions): ImageData => {\n  const pixels2DContext = typeof document !== 'undefined' ?\n      document.createElement('canvas').getContext('2d') :\n      new OffscreenCanvas(1, 1).getContext('2d') as OffscreenCanvasRenderingContext2D;\n  let image: ImageData;\n  if (pixels2DContext != null) {\n    // Default values for height and width & format\n    let width: number;\n    let height: number;\n    let channels: number;\n    if (options?.tensorLayout !== undefined && options.tensorLayout === 'NHWC') {\n      width = tensor.dims[2];\n      height = tensor.dims[1];\n      channels = tensor.dims[3];\n    } else {  // Default layout is NCWH\n      width = tensor.dims[3];\n      height = tensor.dims[2];\n      channels = tensor.dims[1];\n    }\n    const inputformat = options !== undefined ? (options.format !== undefined ? options.format : 'RGB') : 'RGB';\n\n    const norm = options?.norm;\n    let normMean: [number, number, number, number];\n    let normBias: [number, number, number, number];\n    if (norm === undefined || norm.mean === undefined) {\n      normMean = [255, 255, 255, 255];\n    } else {\n      if (typeof (norm.mean) === 'number') {\n        normMean = [norm.mean, norm.mean, norm.mean, norm.mean];\n      } else {\n        normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 255];\n        if (norm.mean[3] !== undefined) {\n          normMean[3] = norm.mean[3];\n        }\n      }\n    }\n    if (norm === undefined || norm.bias === undefined) {\n      normBias = [0, 0, 0, 0];\n    } else {\n      if (typeof (norm.bias) === 'number') {\n        normBias = [norm.bias, norm.bias, norm.bias, norm.bias];\n      } else {\n        normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];\n        if (norm.bias[3] !== undefined) {\n          normBias[3] = norm.bias[3];\n        }\n      }\n    }\n\n    const stride = height * width;\n    if (options !== undefined) {\n      if (options.format !== undefined && (channels === 4 && options.format !== 'RGBA') ||\n          (channels === 3 && (options.format !== 'RGB' && options.format !== 'BGR'))) {\n        throw new Error('Tensor format doesn\\'t match input tensor dims');\n      }\n    }\n\n    // Default pointer assignments\n    const step = 4;\n    let rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;\n    let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;\n\n    // Updating the pointer assignments based on the input image format\n    if (inputformat === 'RGBA') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n      aTensorPointer = stride * 3;\n    } else if (inputformat === 'RGB') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n    } else if (inputformat === 'RBG') {\n      rTensorPointer = 0;\n      bTensorPointer = stride;\n      gTensorPointer = stride * 2;\n    }\n\n    image = pixels2DContext.createImageData(width, height);\n\n    for (let i = 0; i < height * width;\n         rImagePointer += step, gImagePointer += step, bImagePointer += step, aImagePointer += step, i++) {\n      image.data[rImagePointer] = ((tensor.data[rTensorPointer++] as number) - normBias[0]) * normMean[0];  // R value\n      image.data[gImagePointer] = ((tensor.data[gTensorPointer++] as number) - normBias[1]) * normMean[1];  // G value\n      image.data[bImagePointer] = ((tensor.data[bTensorPointer++] as number) - normBias[2]) * normMean[2];  // B value\n      image.data[aImagePointer] = aTensorPointer === -1 ?\n          255 :\n          ((tensor.data[aTensorPointer++] as number) - normBias[3]) * normMean[3];  // A value\n    }\n\n  } else {\n    throw new Error('Can not access image data');\n  }\n  return image;\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {OptionsDimensions, OptionsFormat, OptionsNormalizationParameters, OptionsTensorFormat, OptionsTensorLayout, TensorFromGpuBufferOptions, TensorFromImageBitmapOptions, TensorFromImageDataOptions, TensorFromImageElementOptions, TensorFromTextureOptions, TensorFromUrlOptions} from './tensor-factory.js';\nimport {Tensor} from './tensor-impl.js';\nimport {Tensor as TensorInterface} from './tensor.js';\n\ninterface BufferToTensorOptions extends OptionsDimensions, OptionsTensorLayout, OptionsNormalizationParameters,\n                                        OptionsFormat, OptionsTensorFormat {}\n\n/**\n * Create a new tensor object from image object\n *\n * @param buffer - Extracted image buffer data - assuming RGBA format\n * @param imageFormat - input image configuration - required configurations height, width, format\n * @param tensorFormat - output tensor configuration - Default is RGB format\n */\nexport const bufferToTensor = (buffer: Uint8ClampedArray|undefined, options: BufferToTensorOptions): Tensor => {\n  if (buffer === undefined) {\n    throw new Error('Image buffer must be defined');\n  }\n  if (options.height === undefined || options.width === undefined) {\n    throw new Error('Image height and width must be defined');\n  }\n  if (options.tensorLayout === 'NHWC') {\n    throw new Error('NHWC Tensor layout is not supported yet');\n  }\n\n  const {height, width} = options;\n\n  const norm = options.norm ?? {mean: 255, bias: 0};\n  let normMean: [number, number, number, number];\n  let normBias: [number, number, number, number];\n\n  if (typeof (norm.mean) === 'number') {\n    normMean = [norm.mean, norm.mean, norm.mean, norm.mean];\n  } else {\n    normMean = [norm.mean![0], norm.mean![1], norm.mean![2], norm.mean![3] ?? 255];\n  }\n\n  if (typeof (norm.bias) === 'number') {\n    normBias = [norm.bias, norm.bias, norm.bias, norm.bias];\n  } else {\n    normBias = [norm.bias![0], norm.bias![1], norm.bias![2], norm.bias![3] ?? 0];\n  }\n\n  const inputformat = options.format !== undefined ? options.format : 'RGBA';\n  // default value is RGBA since imagedata and HTMLImageElement uses it\n\n  const outputformat =\n      options.tensorFormat !== undefined ? (options.tensorFormat !== undefined ? options.tensorFormat : 'RGB') : 'RGB';\n  const stride = height * width;\n  const float32Data = outputformat === 'RGBA' ? new Float32Array(stride * 4) : new Float32Array(stride * 3);\n\n  // Default pointer assignments\n  let step = 4, rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;\n  let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;\n\n  // Updating the pointer assignments based on the input image format\n  if (inputformat === 'RGB') {\n    step = 3;\n    rImagePointer = 0;\n    gImagePointer = 1;\n    bImagePointer = 2;\n    aImagePointer = -1;\n  }\n\n  // Updating the pointer assignments based on the output tensor format\n  if (outputformat === 'RGBA') {\n    aTensorPointer = stride * 3;\n  } else if (outputformat === 'RBG') {\n    rTensorPointer = 0;\n    bTensorPointer = stride;\n    gTensorPointer = stride * 2;\n  } else if (outputformat === 'BGR') {\n    bTensorPointer = 0;\n    gTensorPointer = stride;\n    rTensorPointer = stride * 2;\n  }\n\n  for (let i = 0; i < stride;\n       i++, rImagePointer += step, bImagePointer += step, gImagePointer += step, aImagePointer += step) {\n    float32Data[rTensorPointer++] = (buffer[rImagePointer] + normBias[0]) / normMean[0];\n    float32Data[gTensorPointer++] = (buffer[gImagePointer] + normBias[1]) / normMean[1];\n    float32Data[bTensorPointer++] = (buffer[bImagePointer] + normBias[2]) / normMean[2];\n    if (aTensorPointer !== -1 && aImagePointer !== -1) {\n      float32Data[aTensorPointer++] = (buffer[aImagePointer] + normBias[3]) / normMean[3];\n    }\n  }\n\n  // Float32Array -> ort.Tensor\n  const outputTensor = outputformat === 'RGBA' ? new Tensor('float32', float32Data, [1, 4, height, width]) :\n                                                 new Tensor('float32', float32Data, [1, 3, height, width]);\n  return outputTensor;\n};\n\n/**\n * implementation of Tensor.fromImage().\n */\nexport const tensorFromImage = async(\n    image: ImageData|HTMLImageElement|ImageBitmap|string,\n    options?: TensorFromImageDataOptions|TensorFromImageElementOptions|TensorFromImageBitmapOptions|\n    TensorFromUrlOptions): Promise<Tensor> => {\n  // checking the type of image object\n  const isHTMLImageEle = typeof (HTMLImageElement) !== 'undefined' && image instanceof HTMLImageElement;\n  const isImageDataEle = typeof (ImageData) !== 'undefined' && image instanceof ImageData;\n  const isImageBitmap = typeof (ImageBitmap) !== 'undefined' && image instanceof ImageBitmap;\n  const isString = typeof image === 'string';\n\n  let data: Uint8ClampedArray|undefined;\n  let bufferToTensorOptions: BufferToTensorOptions = options ?? {};\n\n  const createCanvas = () => {\n    if (typeof document !== 'undefined') {\n      return document.createElement('canvas');\n    } else if (typeof OffscreenCanvas !== 'undefined') {\n      return new OffscreenCanvas(1, 1);\n    } else {\n      throw new Error('Canvas is not supported');\n    }\n  };\n  const createCanvasContext = (canvas: HTMLCanvasElement|OffscreenCanvas) => {\n    if (canvas instanceof HTMLCanvasElement) {\n      return canvas.getContext('2d');\n    } else if (canvas instanceof OffscreenCanvas) {\n      return canvas.getContext('2d') as OffscreenCanvasRenderingContext2D;\n    } else {\n      return null;\n    }\n  };\n  // filling and checking image configuration options\n  if (isHTMLImageEle) {\n    // HTMLImageElement - image object - format is RGBA by default\n    const canvas = createCanvas();\n    canvas.width = image.width;\n    canvas.height = image.height;\n    const pixels2DContext = createCanvasContext(canvas);\n\n    if (pixels2DContext != null) {\n      let height = image.height;\n      let width = image.width;\n      if (options !== undefined && options.resizedHeight !== undefined && options.resizedWidth !== undefined) {\n        height = options.resizedHeight;\n        width = options.resizedWidth;\n      }\n\n      if (options !== undefined) {\n        bufferToTensorOptions = options;\n        if (options.tensorFormat !== undefined) {\n          throw new Error('Image input config format must be RGBA for HTMLImageElement');\n        } else {\n          bufferToTensorOptions.tensorFormat = 'RGBA';\n        }\n        bufferToTensorOptions.height = height;\n        bufferToTensorOptions.width = width;\n      } else {\n        bufferToTensorOptions.tensorFormat = 'RGBA';\n        bufferToTensorOptions.height = height;\n        bufferToTensorOptions.width = width;\n      }\n\n      pixels2DContext.drawImage(image, 0, 0);\n      data = pixels2DContext.getImageData(0, 0, width, height).data;\n    } else {\n      throw new Error('Can not access image data');\n    }\n  } else if (isImageDataEle) {\n    let height: number;\n    let width: number;\n\n    if (options !== undefined && options.resizedWidth !== undefined && options.resizedHeight !== undefined) {\n      height = options.resizedHeight;\n      width = options.resizedWidth;\n    } else {\n      height = image.height;\n      width = image.width;\n    }\n\n    if (options !== undefined) {\n      bufferToTensorOptions = options;\n    }\n    bufferToTensorOptions.format = 'RGBA';\n    bufferToTensorOptions.height = height;\n    bufferToTensorOptions.width = width;\n\n    if (options !== undefined) {\n      const tempCanvas = createCanvas();\n\n      tempCanvas.width = width;\n      tempCanvas.height = height;\n\n      const pixels2DContext = createCanvasContext(tempCanvas);\n\n      if (pixels2DContext != null) {\n        pixels2DContext.putImageData(image, 0, 0);\n        data = pixels2DContext.getImageData(0, 0, width, height).data;\n      } else {\n        throw new Error('Can not access image data');\n      }\n    } else {\n      data = image.data;\n    }\n  } else if (isImageBitmap) {\n    // ImageBitmap - image object - format must be provided by user\n    if (options === undefined) {\n      throw new Error('Please provide image config with format for Imagebitmap');\n    }\n\n    const canvas = createCanvas();\n    canvas.width = image.width;\n    canvas.height = image.height;\n    const pixels2DContext = createCanvasContext(canvas);\n\n    if (pixels2DContext != null) {\n      const height = image.height;\n      const width = image.width;\n      pixels2DContext.drawImage(image, 0, 0, width, height);\n      data = pixels2DContext.getImageData(0, 0, width, height).data;\n      bufferToTensorOptions.height = height;\n      bufferToTensorOptions.width = width;\n      return bufferToTensor(data, bufferToTensorOptions);\n    } else {\n      throw new Error('Can not access image data');\n    }\n  } else if (isString) {\n    return new Promise((resolve, reject) => {\n      const canvas = createCanvas();\n      const context = createCanvasContext(canvas);\n      if (!image || !context) {\n        return reject();\n      }\n      const newImage = new Image();\n      newImage.crossOrigin = 'Anonymous';\n      newImage.src = image;\n      newImage.onload = () => {\n        canvas.width = newImage.width;\n        canvas.height = newImage.height;\n        context.drawImage(newImage, 0, 0, canvas.width, canvas.height);\n        const img = context.getImageData(0, 0, canvas.width, canvas.height);\n\n        bufferToTensorOptions.height = canvas.height;\n        bufferToTensorOptions.width = canvas.width;\n        resolve(bufferToTensor(img.data, bufferToTensorOptions));\n      };\n    });\n  } else {\n    throw new Error('Input data provided is not supported - aborted tensor creation');\n  }\n\n  if (data !== undefined) {\n    return bufferToTensor(data, bufferToTensorOptions);\n  } else {\n    throw new Error('Input data provided is not supported - aborted tensor creation');\n  }\n};\n\n/**\n * implementation of Tensor.fromTexture().\n */\nexport const tensorFromTexture = <T extends TensorInterface.TextureDataTypes>(\n    texture: TensorInterface.TextureType, options: TensorFromTextureOptions<T>): Tensor => {\n  const {width, height, download, dispose} = options;\n  // Always assume RGBAF32. TODO: support different texture format\n  const dims = [1, height, width, 4];\n  return new Tensor({location: 'texture', type: 'float32', texture, dims, download, dispose});\n};\n\n/**\n * implementation of Tensor.fromGpuBuffer().\n */\nexport const tensorFromGpuBuffer = <T extends TensorInterface.GpuBufferDataTypes>(\n    gpuBuffer: TensorInterface.GpuBufferType, options: TensorFromGpuBufferOptions<T>): Tensor => {\n  const {dataType, dims, download, dispose} = options;\n  return new Tensor({location: 'gpu-buffer', type: dataType ?? 'float32', gpuBuffer, dims, download, dispose});\n};\n\n/**\n * implementation of Tensor.fromPinnedBuffer().\n */\nexport const tensorFromPinnedBuffer = <T extends TensorInterface.CpuPinnedDataTypes>(\n    type: T, buffer: TensorInterface.DataTypeMap[T], dims?: readonly number[]): Tensor =>\n    new Tensor({location: 'cpu-pinned', type, data: buffer, dims: dims ?? [buffer.length]});\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Tensor} from './tensor.js';\n\nexport type SupportedTypedArrayConstructors = Float32ArrayConstructor|Uint8ArrayConstructor|Int8ArrayConstructor|\n    Uint16ArrayConstructor|Int16ArrayConstructor|Int32ArrayConstructor|BigInt64ArrayConstructor|Uint8ArrayConstructor|\n    Float64ArrayConstructor|Uint32ArrayConstructor|BigUint64ArrayConstructor;\nexport type SupportedTypedArray = InstanceType<SupportedTypedArrayConstructors>;\n\n// a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.\nexport const NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP = new Map<string, SupportedTypedArrayConstructors>([\n  ['float32', Float32Array],\n  ['uint8', Uint8Array],\n  ['int8', Int8Array],\n  ['uint16', Uint16Array],\n  ['int16', Int16Array],\n  ['int32', Int32Array],\n  ['bool', Uint8Array],\n  ['float64', Float64Array],\n  ['uint32', Uint32Array],\n]);\n\n// a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.\nexport const NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP = new Map<SupportedTypedArrayConstructors, Tensor.Type>([\n  [Float32Array, 'float32'],\n  [Uint8Array, 'uint8'],\n  [Int8Array, 'int8'],\n  [Uint16Array, 'uint16'],\n  [Int16Array, 'int16'],\n  [Int32Array, 'int32'],\n  [Float64Array, 'float64'],\n  [Uint32Array, 'uint32'],\n]);\n\n// a dummy type declaration for Float16Array in case any polyfill is available.\ndeclare global {\n  // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any\n  const Float16Array: any;\n}\n\n// the following code allows delaying execution of BigInt/Float16Array checking. This allows lazy initialization for\n// NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP and NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP, which allows BigInt/Float16Array\n// polyfill if available.\nlet isTypedArrayChecked = false;\nexport const checkTypedArray = () => {\n  if (!isTypedArrayChecked) {\n    isTypedArrayChecked = true;\n    const isBigInt64ArrayAvailable = typeof BigInt64Array !== 'undefined' && BigInt64Array.from;\n    const isBigUint64ArrayAvailable = typeof BigUint64Array !== 'undefined' && BigUint64Array.from;\n    const isFloat16ArrayAvailable = typeof Float16Array !== 'undefined' && Float16Array.from;\n\n    if (isBigInt64ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('int64', BigInt64Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigInt64Array, 'int64');\n    }\n    if (isBigUint64ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('uint64', BigUint64Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigUint64Array, 'uint64');\n    }\n    if (isFloat16ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('float16', Float16Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(Float16Array, 'float16');\n    } else {\n      // if Float16Array is not available, use 'Uint16Array' to store the data.\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('float16', Uint16Array);\n    }\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {CpuPinnedConstructorParameters, GpuBufferConstructorParameters, TextureConstructorParameters} from './tensor-factory.js';\nimport {Tensor} from './tensor-impl.js';\n\n/**\n * calculate size from dims.\n *\n * @param dims the dims array. May be an illegal input.\n */\nexport const calculateSize = (dims: readonly unknown[]): number => {\n  let size = 1;\n  for (let i = 0; i < dims.length; i++) {\n    const dim = dims[i];\n    if (typeof dim !== 'number' || !Number.isSafeInteger(dim)) {\n      throw new TypeError(`dims[${i}] must be an integer, got: ${dim}`);\n    }\n    if (dim < 0) {\n      throw new RangeError(`dims[${i}] must be a non-negative integer, got: ${dim}`);\n    }\n    size *= dim;\n  }\n  return size;\n};\n\n/**\n * implementation of Tensor.reshape()\n */\nexport const tensorReshape = (tensor: Tensor, dims: readonly number[]): Tensor => {\n  switch (tensor.location) {\n    case 'cpu':\n      return new Tensor(tensor.type, tensor.data, dims);\n    case 'cpu-pinned':\n      return new Tensor({\n        location: 'cpu-pinned',\n        data: tensor.data as CpuPinnedConstructorParameters['data'],\n        type: tensor.type as CpuPinnedConstructorParameters['type'],\n        dims,\n      });\n    case 'texture':\n      return new Tensor({\n        location: 'texture',\n        texture: tensor.texture,\n        type: tensor.type as TextureConstructorParameters['type'],\n        dims,\n      });\n    case 'gpu-buffer':\n      return new Tensor({\n        location: 'gpu-buffer',\n        gpuBuffer: tensor.gpuBuffer,\n        type: tensor.type as GpuBufferConstructorParameters['type'],\n        dims,\n      });\n    default:\n      throw new Error(`tensorReshape: tensor location ${tensor.location} is not supported`);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {tensorToDataURL, tensorToImageData} from './tensor-conversion-impl.js';\nimport {TensorToDataUrlOptions, TensorToImageDataOptions} from './tensor-conversion.js';\nimport {tensorFromGpuBuffer, tensorFromImage, tensorFromPinnedBuffer, tensorFromTexture} from './tensor-factory-impl.js';\nimport {CpuPinnedConstructorParameters, GpuBufferConstructorParameters, TensorFromGpuBufferOptions, TensorFromImageBitmapOptions, TensorFromImageDataOptions, TensorFromImageElementOptions, TensorFromTextureOptions, TensorFromUrlOptions, TextureConstructorParameters} from './tensor-factory.js';\nimport {checkTypedArray, NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP, NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP, SupportedTypedArray, SupportedTypedArrayConstructors} from './tensor-impl-type-mapping.js';\nimport {calculateSize, tensorReshape} from './tensor-utils-impl.js';\nimport {Tensor as TensorInterface} from './tensor.js';\n\n// type aliases for those exported from Tensor interface\n\ntype TensorType = TensorInterface.Type;\ntype TensorDataType = TensorInterface.DataType;\ntype TensorDataLocation = TensorInterface.DataLocation;\ntype TensorTextureType = TensorInterface.TextureType;\ntype TensorGpuBufferType = TensorInterface.GpuBufferType;\n\n/**\n * the implementation of Tensor interface.\n *\n * @ignore\n */\nexport class Tensor implements TensorInterface {\n  // #region constructors\n\n  /**\n   * Construct a new CPU tensor object from the given type, data and dims.\n   */\n  constructor(\n      type: TensorType, data: TensorDataType|readonly string[]|readonly number[]|readonly boolean[],\n      dims?: readonly number[]);\n  /**\n   * Construct a new CPU tensor object from the given data and dims. Type is inferred from data.\n   */\n  constructor(data: TensorDataType|readonly string[]|readonly boolean[], dims?: readonly number[]);\n  /**\n   * Construct a new tensor object from the pinned CPU data with the given type and dims.\n   *\n   * Tensor's location will be set to 'cpu-pinned'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: CpuPinnedConstructorParameters);\n  /**\n   * Construct a new tensor object from the WebGL texture with the given type and dims.\n   *\n   * Tensor's location will be set to 'texture'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: TextureConstructorParameters);\n  /**\n   * Construct a new tensor object from the WebGPU buffer with the given type and dims.\n   *\n   * Tensor's location will be set to 'gpu-buffer'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: GpuBufferConstructorParameters);\n\n  /**\n   * implementation.\n   */\n  constructor(\n      arg0: TensorType|TensorDataType|readonly string[]|readonly boolean[]|CpuPinnedConstructorParameters|\n      TextureConstructorParameters|GpuBufferConstructorParameters,\n      arg1?: TensorDataType|readonly number[]|readonly string[]|readonly boolean[], arg2?: readonly number[]) {\n    // perform one-time check for BigInt/Float16Array support\n    checkTypedArray();\n\n    let type: TensorType;\n    let dims: readonly number[];\n\n    if (typeof arg0 === 'object' && 'location' in arg0) {\n      //\n      // constructing tensor from specific location\n      //\n      this.dataLocation = arg0.location;\n      type = arg0.type;\n      dims = arg0.dims;\n      switch (arg0.location) {\n        case 'cpu-pinned': {\n          const expectedTypedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(type);\n          if (!expectedTypedArrayConstructor) {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from pinned buffer`);\n          }\n          if (!(arg0.data instanceof expectedTypedArrayConstructor)) {\n            throw new TypeError(`buffer should be of type ${expectedTypedArrayConstructor.name}`);\n          }\n          this.cpuData = arg0.data;\n          break;\n        }\n        case 'texture': {\n          if (type !== 'float32') {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from texture`);\n          }\n          this.gpuTextureData = arg0.texture;\n          this.downloader = arg0.download;\n          this.disposer = arg0.dispose;\n          break;\n        }\n        case 'gpu-buffer': {\n          if ((type !== 'float32' && type !== 'float16' && type !== 'int32' && type !== 'int64' && type !== 'uint32' &&\n               type !== 'uint8' && type !== 'bool')) {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from gpu buffer`);\n          }\n          this.gpuBufferData = arg0.gpuBuffer;\n          this.downloader = arg0.download;\n          this.disposer = arg0.dispose;\n          break;\n        }\n        default:\n          throw new Error(`Tensor constructor: unsupported location '${this.dataLocation}'`);\n      }\n    } else {\n      //\n      // constructing tensor of location 'cpu'\n      //\n      let data: TensorDataType;\n      let maybeDims: typeof arg1|typeof arg2;\n      // check whether arg0 is type or data\n      if (typeof arg0 === 'string') {\n        //\n        // Override: constructor(type, data, ...)\n        //\n        type = arg0;\n        maybeDims = arg2;\n        if (arg0 === 'string') {\n          // string tensor\n          if (!Array.isArray(arg1)) {\n            throw new TypeError('A string tensor\\'s data must be a string array.');\n          }\n          // we don't check whether every element in the array is string; this is too slow. we assume it's correct and\n          // error will be populated at inference\n          data = arg1;\n        } else {\n          // numeric tensor\n          const typedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(arg0);\n          if (typedArrayConstructor === undefined) {\n            throw new TypeError(`Unsupported tensor type: ${arg0}.`);\n          }\n          if (Array.isArray(arg1)) {\n            if (arg0 === 'float16' && typedArrayConstructor === Uint16Array) {\n              // When no Float16Array polyfill is used, we cannot create 'float16' tensor from number array.\n              //\n              // Throw error here because when user try to use number array as data,\n              // e.g. new Tensor('float16', [1, 2, 3, 4], dims)), it will actually call\n              // Uint16Array.from(arg1) which generates wrong data.\n              throw new TypeError(\n                  'Creating a float16 tensor from number array is not supported. Please use Uint16Array as data.');\n            } else if (arg0 === 'uint64' || arg0 === 'int64') {\n              // use 'as any' here because:\n              // 1. TypeScript's check on type of 'Array.isArray()' does not work with readonly arrays.\n              // see https://github.com/microsoft/TypeScript/issues/17002\n              // 2. TypeScript's check on union type of '(BigInt64ArrayConstructor|BigUint64ArrayConstructor).from()'\n              // does not accept parameter mapFn.\n              // 3. parameters of 'SupportedTypedArrayConstructors.from()' does not match the requirement of the union\n              // type.\n\n              // assume 'arg1' is of type \"readonly number[]|readonly bigint[]\" here.\n\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              data = (typedArrayConstructor as any).from(arg1, BigInt);\n            } else {\n              // assume 'arg1' is of type \"readonly number[]\" here.\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              data = (typedArrayConstructor as any).from(arg1);\n            }\n          } else if (arg1 instanceof typedArrayConstructor) {\n            data = arg1;\n          } else {\n            throw new TypeError(`A ${type} tensor's data must be type of ${typedArrayConstructor}`);\n          }\n        }\n      } else {\n        //\n        // Override: constructor(data, ...)\n        //\n        maybeDims = arg1;\n        if (Array.isArray(arg0)) {\n          // only boolean[] and string[] is supported\n          if (arg0.length === 0) {\n            throw new TypeError('Tensor type cannot be inferred from an empty array.');\n          }\n          const firstElementType = typeof arg0[0];\n          if (firstElementType === 'string') {\n            type = 'string';\n            data = arg0;\n          } else if (firstElementType === 'boolean') {\n            type = 'bool';\n            // 'arg0' is of type 'boolean[]'. Uint8Array.from(boolean[]) actually works, but typescript thinks this is\n            // wrong type. We use 'as any' to make it happy.\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            data = Uint8Array.from(arg0 as any[]);\n          } else {\n            throw new TypeError(`Invalid element type of data array: ${firstElementType}.`);\n          }\n        } else {\n          // get tensor type from TypedArray\n          const mappedType =\n              NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.get(arg0.constructor as SupportedTypedArrayConstructors);\n          if (mappedType === undefined) {\n            throw new TypeError(`Unsupported type for tensor data: ${arg0.constructor}.`);\n          }\n          type = mappedType;\n          data = arg0 as SupportedTypedArray;\n        }\n      }\n\n      // type and data is processed, now processing dims\n      if (maybeDims === undefined) {\n        // assume 1-D tensor if dims omitted\n        maybeDims = [data.length];\n      } else if (!Array.isArray(maybeDims)) {\n        throw new TypeError('A tensor\\'s dims must be a number array');\n      }\n      dims = maybeDims as readonly number[];\n\n      this.cpuData = data;\n      this.dataLocation = 'cpu';\n    }\n\n    // perform check on dims\n    const size = calculateSize(dims);\n    // if data is on CPU, check whether data length matches tensor size\n    if (this.cpuData && size !== this.cpuData.length) {\n      throw new Error(`Tensor's size(${size}) does not match data length(${this.cpuData.length}).`);\n    }\n\n    this.type = type;\n    this.dims = dims;\n    this.size = size;\n  }\n  // #endregion\n\n  // #region factory\n  static async fromImage(\n      image: ImageData|HTMLImageElement|ImageBitmap|string,\n      options?: TensorFromImageDataOptions|TensorFromImageElementOptions|TensorFromImageBitmapOptions|\n      TensorFromUrlOptions): Promise<TensorInterface> {\n    return tensorFromImage(image, options);\n  }\n\n  static fromTexture<T extends TensorInterface.TextureDataTypes>(\n      texture: TensorTextureType, options: TensorFromTextureOptions<T>): TensorInterface {\n    return tensorFromTexture(texture, options);\n  }\n\n  static fromGpuBuffer<T extends TensorInterface.GpuBufferDataTypes>(\n      gpuBuffer: TensorGpuBufferType, options: TensorFromGpuBufferOptions<T>): TensorInterface {\n    return tensorFromGpuBuffer(gpuBuffer, options);\n  }\n\n  static fromPinnedBuffer<T extends TensorInterface.CpuPinnedDataTypes>(\n      type: T, buffer: TensorInterface.DataTypeMap[T], dims?: readonly number[]): Tensor {\n    return tensorFromPinnedBuffer(type, buffer, dims);\n  }\n\n  // #endregion\n\n  // #region conversions\n  toDataURL(options?: TensorToDataUrlOptions): string {\n    return tensorToDataURL(this, options);\n  }\n\n  toImageData(options?: TensorToImageDataOptions): ImageData {\n    return tensorToImageData(this, options);\n  }\n  // #endregion\n\n  // #region public fields\n  readonly dims: readonly number[];\n  readonly type: TensorType;\n  readonly size: number;\n  // #endregion\n\n  // #region private fields\n\n  /**\n   * stores the location of the data.\n   */\n  private dataLocation: TensorDataLocation;\n\n  /**\n   * stores the data on CPU, if location is 'cpu' or 'cpu-pinned'. otherwise empty.\n   */\n  private cpuData?: TensorDataType;\n\n  /**\n   * stores the underlying texture when location is 'texture'. otherwise empty.\n   */\n  private gpuTextureData?: TensorTextureType;\n\n  /**\n   * stores the underlying GPU buffer when location is 'gpu-buffer'. otherwise empty.\n   */\n  private gpuBufferData?: TensorGpuBufferType;\n\n  /**\n   * stores an optional downloader function to download data from GPU to CPU.\n   */\n  private downloader?(): Promise<TensorDataType>;\n\n  /**\n   * a flag indicating whether the data is being downloaded from GPU to CPU.\n   */\n  private isDownloading?: boolean;\n\n  /**\n   * stores an optional disposer function to dispose the underlying data.\n   */\n  private disposer?(): void;\n  // #endregion\n\n  // #region properties\n  get data(): TensorDataType {\n    this.ensureValid();\n    if (!this.cpuData) {\n      throw new Error(\n          'The data is not on CPU. Use `getData()` to download GPU data to CPU, ' +\n          'or use `texture` or `gpuBuffer` property to access the GPU data directly.');\n    }\n    return this.cpuData;\n  }\n\n  get location(): TensorDataLocation {\n    return this.dataLocation;\n  }\n\n  get texture(): TensorTextureType {\n    this.ensureValid();\n    if (!this.gpuTextureData) {\n      throw new Error('The data is not stored as a WebGL texture.');\n    }\n    return this.gpuTextureData;\n  }\n\n  get gpuBuffer(): TensorGpuBufferType {\n    this.ensureValid();\n    if (!this.gpuBufferData) {\n      throw new Error('The data is not stored as a WebGPU buffer.');\n    }\n    return this.gpuBufferData;\n  }\n  // #endregion\n\n  // #region methods\n\n  async getData(releaseData?: boolean): Promise<TensorDataType> {\n    this.ensureValid();\n    switch (this.dataLocation) {\n      case 'cpu':\n      case 'cpu-pinned':\n        return this.data;\n      case 'texture':\n      case 'gpu-buffer': {\n        if (!this.downloader) {\n          throw new Error('The current tensor is not created with a specified data downloader.');\n        }\n        if (this.isDownloading) {\n          throw new Error('The current tensor is being downloaded.');\n        }\n        try {\n          this.isDownloading = true;\n          const data = await this.downloader();\n          this.downloader = undefined;\n          this.dataLocation = 'cpu';\n          this.cpuData = data;\n\n          if (releaseData && this.disposer) {\n            this.disposer();\n            this.disposer = undefined;\n          }\n\n          return data;\n\n        } finally {\n          this.isDownloading = false;\n        }\n      }\n      default:\n        throw new Error(`cannot get data from location: ${this.dataLocation}`);\n    }\n  }\n\n  dispose(): void {\n    if (this.isDownloading) {\n      throw new Error('The current tensor is being downloaded.');\n    }\n\n    if (this.disposer) {\n      this.disposer();\n      this.disposer = undefined;\n    }\n    this.cpuData = undefined;\n    this.gpuTextureData = undefined;\n    this.gpuBufferData = undefined;\n    this.downloader = undefined;\n    this.isDownloading = undefined;\n\n    this.dataLocation = 'none';\n  }\n\n  // #endregion\n\n  // #region tensor utilities\n  private ensureValid(): void {\n    if (this.dataLocation === 'none') {\n      throw new Error('The tensor is disposed.');\n    }\n  }\n\n  reshape(dims: readonly number[]): TensorInterface {\n    this.ensureValid();\n    if (this.downloader || this.disposer) {\n      throw new Error('Cannot reshape a tensor that owns GPU resource.');\n    }\n    return tensorReshape(this, dims);\n  }\n  // #endregion\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorFactory} from './tensor-factory.js';\nimport {Tensor as TensorImpl} from './tensor-impl.js';\nimport {TypedTensorUtils} from './tensor-utils.js';\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\n/**\n * represent a basic tensor with specified dimensions and data type.\n */\ninterface TypedTensorBase<T extends Tensor.Type> {\n  /**\n   * Get the dimensions of the tensor.\n   */\n  readonly dims: readonly number[];\n  /**\n   * Get the data type of the tensor.\n   */\n  readonly type: T;\n  /**\n   * Get the buffer data of the tensor.\n   *\n   * If the data is not on CPU (eg. it's in the form of WebGL texture or WebGPU buffer), throw error.\n   */\n  readonly data: Tensor.DataTypeMap[T];\n  /**\n   * Get the location of the data.\n   */\n  readonly location: Tensor.DataLocation;\n  /**\n   * Get the WebGL texture that holds the tensor data.\n   *\n   * If the data is not on GPU as WebGL texture, throw error.\n   */\n  readonly texture: Tensor.TextureType;\n  /**\n   * Get the WebGPU buffer that holds the tensor data.\n   *\n   * If the data is not on GPU as WebGPU buffer, throw error.\n   */\n  readonly gpuBuffer: Tensor.GpuBufferType;\n\n  /**\n   * Get the buffer data of the tensor.\n   *\n   * If the data is on CPU, returns the data immediately.\n   * If the data is on GPU, downloads the data and returns the promise.\n   *\n   * @param releaseData - whether release the data on GPU. Ignore if data is already on CPU.\n   */\n  getData(releaseData?: boolean): Promise<Tensor.DataTypeMap[T]>;\n\n  /**\n   * Dispose the tensor data.\n   *\n   * If the data is on CPU, remove its internal reference to the underlying data.\n   * If the data is on GPU, release the data on GPU.\n   *\n   * After calling this function, the tensor is considered no longer valid. Its location will be set to 'none'.\n   */\n  dispose(): void;\n}\n\nexport declare namespace Tensor {\n  interface DataTypeMap {\n    float32: Float32Array;\n    uint8: Uint8Array;\n    int8: Int8Array;\n    uint16: Uint16Array;\n    int16: Int16Array;\n    int32: Int32Array;\n    int64: BigInt64Array;\n    string: string[];\n    bool: Uint8Array;\n    float16: Uint16Array;  // Keep using Uint16Array until we have a concrete solution for float 16.\n    float64: Float64Array;\n    uint32: Uint32Array;\n    uint64: BigUint64Array;\n    // complex64: never;\n    // complex128: never;\n    // bfloat16: never;\n  }\n\n  interface ElementTypeMap {\n    float32: number;\n    uint8: number;\n    int8: number;\n    uint16: number;\n    int16: number;\n    int32: number;\n    int64: bigint;\n    string: string;\n    bool: boolean;\n    float16: number;  // Keep using Uint16Array until we have a concrete solution for float 16.\n    float64: number;\n    uint32: number;\n    uint64: bigint;\n    // complex64: never;\n    // complex128: never;\n    // bfloat16: never;\n  }\n\n  type DataType = DataTypeMap[Type];\n  type ElementType = ElementTypeMap[Type];\n\n  /**\n   * supported data types for constructing a tensor from a pinned CPU buffer\n   */\n  export type CpuPinnedDataTypes = Exclude<Tensor.Type, 'string'>;\n\n  /**\n   * type alias for WebGL texture\n   */\n  export type TextureType = WebGLTexture;\n\n  /**\n   * supported data types for constructing a tensor from a WebGL texture\n   */\n  export type TextureDataTypes = 'float32';\n\n  /**\n   * type alias for WebGPU buffer\n   *\n   * The reason why we don't use type \"GPUBuffer\" defined in webgpu.d.ts from @webgpu/types is because \"@webgpu/types\"\n   * requires \"@types/dom-webcodecs\" as peer dependency when using TypeScript < v5.1 and its version need to be chosen\n   * carefully according to the TypeScript version being used. This means so far there is not a way to keep every\n   * TypeScript version happy. It turns out that we will easily broke users on some TypeScript version.\n   *\n   * for more info see https://github.com/gpuweb/types/issues/127\n   */\n  export type GpuBufferType = {size: number; mapState: 'unmapped' | 'pending' | 'mapped'};\n\n  /**\n   * supported data types for constructing a tensor from a WebGPU buffer\n   */\n  export type GpuBufferDataTypes = 'float32'|'float16'|'int32'|'int64'|'uint32'|'uint8'|'bool';\n\n  /**\n   * represent where the tensor data is stored\n   */\n  export type DataLocation = 'none'|'cpu'|'cpu-pinned'|'texture'|'gpu-buffer';\n\n  /**\n   * represent the data type of a tensor\n   */\n  export type Type = keyof DataTypeMap;\n}\n\n/**\n * Represent multi-dimensional arrays to feed to or fetch from model inferencing.\n */\nexport interface TypedTensor<T extends Tensor.Type> extends TypedTensorBase<T>, TypedTensorUtils<T> {}\n/**\n * Represent multi-dimensional arrays to feed to or fetch from model inferencing.\n */\nexport interface Tensor extends TypedTensorBase<Tensor.Type>, TypedTensorUtils<Tensor.Type> {}\n\n/**\n * type TensorConstructor defines the constructors of 'Tensor' to create CPU tensor instances.\n */\nexport interface TensorConstructor extends TensorFactory {\n  // #region CPU tensor - specify element type\n  /**\n   * Construct a new string tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(type: 'string', data: Tensor.DataTypeMap['string']|readonly string[],\n      dims?: readonly number[]): TypedTensor<'string'>;\n\n  /**\n   * Construct a new bool tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(type: 'bool', data: Tensor.DataTypeMap['bool']|readonly boolean[], dims?: readonly number[]): TypedTensor<'bool'>;\n\n  /**\n   * Construct a new 64-bit integer typed tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new<T extends 'uint64'|'int64'>(\n      type: T, data: Tensor.DataTypeMap[T]|readonly bigint[]|readonly number[],\n      dims?: readonly number[]): TypedTensor<T>;\n\n  /**\n   * Construct a new numeric tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new<T extends Exclude<Tensor.Type, 'string'|'bool'|'uint64'|'int64'>>(\n      type: T, data: Tensor.DataTypeMap[T]|readonly number[], dims?: readonly number[]): TypedTensor<T>;\n  // #endregion\n\n  // #region CPU tensor - infer element types\n\n  /**\n   * Construct a new float32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Float32Array, dims?: readonly number[]): TypedTensor<'float32'>;\n\n  /**\n   * Construct a new int8 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Int8Array, dims?: readonly number[]): TypedTensor<'int8'>;\n\n  /**\n   * Construct a new uint8 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Uint8Array, dims?: readonly number[]): TypedTensor<'uint8'>;\n\n  /**\n   * Construct a new uint16 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Uint16Array, dims?: readonly number[]): TypedTensor<'uint16'>;\n\n  /**\n   * Construct a new int16 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Int16Array, dims?: readonly number[]): TypedTensor<'int16'>;\n\n  /**\n   * Construct a new int32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Int32Array, dims?: readonly number[]): TypedTensor<'int32'>;\n\n  /**\n   * Construct a new int64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: BigInt64Array, dims?: readonly number[]): TypedTensor<'int64'>;\n\n  /**\n   * Construct a new string tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: readonly string[], dims?: readonly number[]): TypedTensor<'string'>;\n\n  /**\n   * Construct a new bool tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: readonly boolean[], dims?: readonly number[]): TypedTensor<'bool'>;\n\n  /**\n   * Construct a new float64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Float64Array, dims?: readonly number[]): TypedTensor<'float64'>;\n\n  /**\n   * Construct a new uint32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Uint32Array, dims?: readonly number[]): TypedTensor<'uint32'>;\n\n  /**\n   * Construct a new uint64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: BigUint64Array, dims?: readonly number[]): TypedTensor<'uint64'>;\n\n  // #endregion\n\n  // #region CPU tensor - fall back to non-generic tensor type declaration\n\n  /**\n   * Construct a new tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(type: Tensor.Type, data: Tensor.DataType|readonly number[]|readonly string[]|readonly bigint[]|readonly boolean[],\n      dims?: readonly number[]): Tensor;\n\n  /**\n   * Construct a new tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Tensor.DataType, dims?: readonly number[]): Tensor;\n  // #endregion\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const Tensor = TensorImpl as TensorConstructor;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {env} from './env-impl.js';\n\n/**\n * @ignore\n */\nexport const TRACE = (deviceType: string, label: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  // eslint-disable-next-line no-console\n  console.timeStamp(`${deviceType}::ORT::${label}`);\n};\n\nconst TRACE_FUNC = (msg: string, extraMsg?: string) => {\n  const stack = new Error().stack?.split(/\\r\\n|\\r|\\n/g) || [];\n  let hasTraceFunc = false;\n  for (let i = 0; i < stack.length; i++) {\n    if (hasTraceFunc && !stack[i].includes('TRACE_FUNC')) {\n      let label = `FUNC_${msg}::${stack[i].trim().split(' ')[1]}`;\n      if (extraMsg) {\n        label += `::${extraMsg}`;\n      }\n      TRACE('CPU', label);\n      return;\n    }\n    if (stack[i].includes('TRACE_FUNC')) {\n      hasTraceFunc = true;\n    }\n  }\n};\n\n/**\n * @ignore\n */\nexport const TRACE_FUNC_BEGIN = (extraMsg?: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  TRACE_FUNC('BEGIN', extraMsg);\n};\n\n/**\n * @ignore\n */\nexport const TRACE_FUNC_END = (extraMsg?: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  TRACE_FUNC('END', extraMsg);\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {resolveBackendAndExecutionProviders} from './backend-impl.js';\nimport {InferenceSessionHandler} from './backend.js';\nimport {InferenceSession as InferenceSessionInterface} from './inference-session.js';\nimport {OnnxValue} from './onnx-value.js';\nimport {Tensor} from './tensor.js';\nimport {TRACE_FUNC_BEGIN, TRACE_FUNC_END} from './trace.js';\n\ntype SessionOptions = InferenceSessionInterface.SessionOptions;\ntype RunOptions = InferenceSessionInterface.RunOptions;\ntype FeedsType = InferenceSessionInterface.FeedsType;\ntype FetchesType = InferenceSessionInterface.FetchesType;\ntype ReturnType = InferenceSessionInterface.ReturnType;\n\nexport class InferenceSession implements InferenceSessionInterface {\n  private constructor(handler: InferenceSessionHandler) {\n    this.handler = handler;\n  }\n  run(feeds: FeedsType, options?: RunOptions): Promise<ReturnType>;\n  run(feeds: FeedsType, fetches: FetchesType, options?: RunOptions): Promise<ReturnType>;\n  async run(feeds: FeedsType, arg1?: FetchesType|RunOptions, arg2?: RunOptions): Promise<ReturnType> {\n    TRACE_FUNC_BEGIN();\n    const fetches: {[name: string]: OnnxValue|null} = {};\n    let options: RunOptions = {};\n    // check inputs\n    if (typeof feeds !== 'object' || feeds === null || feeds instanceof Tensor || Array.isArray(feeds)) {\n      throw new TypeError(\n          '\\'feeds\\' must be an object that use input names as keys and OnnxValue as corresponding values.');\n    }\n\n    let isFetchesEmpty = true;\n    // determine which override is being used\n    if (typeof arg1 === 'object') {\n      if (arg1 === null) {\n        throw new TypeError('Unexpected argument[1]: cannot be null.');\n      }\n      if (arg1 instanceof Tensor) {\n        throw new TypeError('\\'fetches\\' cannot be a Tensor');\n      }\n\n      if (Array.isArray(arg1)) {\n        if (arg1.length === 0) {\n          throw new TypeError('\\'fetches\\' cannot be an empty array.');\n        }\n        isFetchesEmpty = false;\n        // output names\n        for (const name of arg1) {\n          if (typeof name !== 'string') {\n            throw new TypeError('\\'fetches\\' must be a string array or an object.');\n          }\n          if (this.outputNames.indexOf(name) === -1) {\n            throw new RangeError(`'fetches' contains invalid output name: ${name}.`);\n          }\n          fetches[name] = null;\n        }\n\n        if (typeof arg2 === 'object' && arg2 !== null) {\n          options = arg2;\n        } else if (typeof arg2 !== 'undefined') {\n          throw new TypeError('\\'options\\' must be an object.');\n        }\n      } else {\n        // decide whether arg1 is fetches or options\n        // if any output name is present and its value is valid OnnxValue, we consider it fetches\n        let isFetches = false;\n        const arg1Keys = Object.getOwnPropertyNames(arg1);\n        for (const name of this.outputNames) {\n          if (arg1Keys.indexOf(name) !== -1) {\n            const v = (arg1 as InferenceSessionInterface.NullableOnnxValueMapType)[name];\n            if (v === null || v instanceof Tensor) {\n              isFetches = true;\n              isFetchesEmpty = false;\n              fetches[name] = v;\n            }\n          }\n        }\n\n        if (isFetches) {\n          if (typeof arg2 === 'object' && arg2 !== null) {\n            options = arg2;\n          } else if (typeof arg2 !== 'undefined') {\n            throw new TypeError('\\'options\\' must be an object.');\n          }\n        } else {\n          options = arg1 as RunOptions;\n        }\n      }\n    } else if (typeof arg1 !== 'undefined') {\n      throw new TypeError('Unexpected argument[1]: must be \\'fetches\\' or \\'options\\'.');\n    }\n\n    // check if all inputs are in feed\n    for (const name of this.inputNames) {\n      if (typeof feeds[name] === 'undefined') {\n        throw new Error(`input '${name}' is missing in 'feeds'.`);\n      }\n    }\n\n    // if no fetches is specified, we use the full output names list\n    if (isFetchesEmpty) {\n      for (const name of this.outputNames) {\n        fetches[name] = null;\n      }\n    }\n\n    // feeds, fetches and options are prepared\n\n    const results = await this.handler.run(feeds, fetches, options);\n    const returnValue: {[name: string]: OnnxValue} = {};\n    for (const key in results) {\n      if (Object.hasOwnProperty.call(results, key)) {\n        const result = results[key];\n        if (result instanceof Tensor) {\n          returnValue[key] = result;\n        } else {\n          returnValue[key] = new Tensor(result.type, result.data, result.dims);\n        }\n      }\n    }\n    TRACE_FUNC_END();\n    return returnValue;\n  }\n\n  async release(): Promise<void> {\n    return this.handler.dispose();\n  }\n\n  static create(path: string, options?: SessionOptions): Promise<InferenceSessionInterface>;\n  static create(buffer: ArrayBufferLike, options?: SessionOptions): Promise<InferenceSessionInterface>;\n  static create(buffer: ArrayBufferLike, byteOffset: number, byteLength?: number, options?: SessionOptions):\n      Promise<InferenceSessionInterface>;\n  static create(buffer: Uint8Array, options?: SessionOptions): Promise<InferenceSessionInterface>;\n  static async create(\n      arg0: string|ArrayBufferLike|Uint8Array, arg1?: SessionOptions|number, arg2?: number,\n      arg3?: SessionOptions): Promise<InferenceSessionInterface> {\n    TRACE_FUNC_BEGIN();\n    // either load from a file or buffer\n    let filePathOrUint8Array: string|Uint8Array;\n    let options: SessionOptions = {};\n\n    if (typeof arg0 === 'string') {\n      filePathOrUint8Array = arg0;\n      if (typeof arg1 === 'object' && arg1 !== null) {\n        options = arg1;\n      } else if (typeof arg1 !== 'undefined') {\n        throw new TypeError('\\'options\\' must be an object.');\n      }\n    } else if (arg0 instanceof Uint8Array) {\n      filePathOrUint8Array = arg0;\n      if (typeof arg1 === 'object' && arg1 !== null) {\n        options = arg1;\n      } else if (typeof arg1 !== 'undefined') {\n        throw new TypeError('\\'options\\' must be an object.');\n      }\n    } else if (\n        arg0 instanceof ArrayBuffer ||\n        (typeof SharedArrayBuffer !== 'undefined' && arg0 instanceof SharedArrayBuffer)) {\n      const buffer = arg0;\n      let byteOffset = 0;\n      let byteLength = arg0.byteLength;\n      if (typeof arg1 === 'object' && arg1 !== null) {\n        options = arg1;\n      } else if (typeof arg1 === 'number') {\n        byteOffset = arg1;\n        if (!Number.isSafeInteger(byteOffset)) {\n          throw new RangeError('\\'byteOffset\\' must be an integer.');\n        }\n        if (byteOffset < 0 || byteOffset >= buffer.byteLength) {\n          throw new RangeError(`'byteOffset' is out of range [0, ${buffer.byteLength}).`);\n        }\n        byteLength = arg0.byteLength - byteOffset;\n        if (typeof arg2 === 'number') {\n          byteLength = arg2;\n          if (!Number.isSafeInteger(byteLength)) {\n            throw new RangeError('\\'byteLength\\' must be an integer.');\n          }\n          if (byteLength <= 0 || byteOffset + byteLength > buffer.byteLength) {\n            throw new RangeError(`'byteLength' is out of range (0, ${buffer.byteLength - byteOffset}].`);\n          }\n          if (typeof arg3 === 'object' && arg3 !== null) {\n            options = arg3;\n          } else if (typeof arg3 !== 'undefined') {\n            throw new TypeError('\\'options\\' must be an object.');\n          }\n        } else if (typeof arg2 !== 'undefined') {\n          throw new TypeError('\\'byteLength\\' must be a number.');\n        }\n      } else if (typeof arg1 !== 'undefined') {\n        throw new TypeError('\\'options\\' must be an object.');\n      }\n      filePathOrUint8Array = new Uint8Array(buffer, byteOffset, byteLength);\n    } else {\n      throw new TypeError('Unexpected argument[0]: must be \\'path\\' or \\'buffer\\'.');\n    }\n\n    // resolve backend, update session options with validated EPs, and create session handler\n    const [backend, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);\n    const handler = await backend.createInferenceSessionHandler(filePathOrUint8Array, optionsWithValidatedEPs);\n    TRACE_FUNC_END();\n    return new InferenceSession(handler);\n  }\n\n  startProfiling(): void {\n    this.handler.startProfiling();\n  }\n  endProfiling(): void {\n    this.handler.endProfiling();\n  }\n\n  get inputNames(): readonly string[] {\n    return this.handler.inputNames;\n  }\n  get outputNames(): readonly string[] {\n    return this.handler.outputNames;\n  }\n\n  private handler: InferenceSessionHandler;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {InferenceSession as InferenceSessionImpl} from './inference-session-impl.js';\nimport {OnnxModelOptions} from './onnx-model.js';\nimport {OnnxValue, OnnxValueDataLocation} from './onnx-value.js';\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\nexport declare namespace InferenceSession {\n  // #region input/output types\n\n  type OnnxValueMapType = {readonly [name: string]: OnnxValue};\n  type NullableOnnxValueMapType = {readonly [name: string]: OnnxValue | null};\n\n  /**\n   * A feeds (model inputs) is an object that uses input names as keys and OnnxValue as corresponding values.\n   */\n  type FeedsType = OnnxValueMapType;\n\n  /**\n   * A fetches (model outputs) could be one of the following:\n   *\n   * - Omitted. Use model's output names definition.\n   * - An array of string indicating the output names.\n   * - An object that use output names as keys and OnnxValue or null as corresponding values.\n   *\n   * @remark\n   * different from input argument, in output, OnnxValue is optional. If an OnnxValue is present it will be\n   * used as a pre-allocated value by the inference engine; if omitted, inference engine will allocate buffer\n   * internally.\n   */\n  type FetchesType = readonly string[]|NullableOnnxValueMapType;\n\n  /**\n   * A inferencing return type is an object that uses output names as keys and OnnxValue as corresponding values.\n   */\n  type ReturnType = OnnxValueMapType;\n\n  // #endregion\n\n  // #region session options\n\n  /**\n   * A set of configurations for session behavior.\n   */\n  export interface SessionOptions extends OnnxModelOptions {\n    /**\n     * An array of execution provider options.\n     *\n     * An execution provider option can be a string indicating the name of the execution provider,\n     * or an object of corresponding type.\n     */\n    executionProviders?: readonly ExecutionProviderConfig[];\n\n    /**\n     * The intra OP threads number.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native).\n     */\n    intraOpNumThreads?: number;\n\n    /**\n     * The inter OP threads number.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native).\n     */\n    interOpNumThreads?: number;\n\n    /**\n     * The free dimension override.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    freeDimensionOverrides?: {readonly [dimensionName: string]: number};\n\n    /**\n     * The optimization level.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    graphOptimizationLevel?: 'disabled'|'basic'|'extended'|'all';\n\n    /**\n     * Whether enable CPU memory arena.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    enableCpuMemArena?: boolean;\n\n    /**\n     * Whether enable memory pattern.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    enableMemPattern?: boolean;\n\n    /**\n     * Execution mode.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    executionMode?: 'sequential'|'parallel';\n\n    /**\n     * Optimized model file path.\n     *\n     * If this setting is specified, the optimized model will be dumped. In browser, a blob will be created\n     * with a pop-up window.\n     */\n    optimizedModelFilePath?: string;\n\n    /**\n     * Whether enable profiling.\n     *\n     * This setting is a placeholder for a future use.\n     */\n    enableProfiling?: boolean;\n\n    /**\n     * File prefix for profiling.\n     *\n     * This setting is a placeholder for a future use.\n     */\n    profileFilePrefix?: string;\n\n    /**\n     * Log ID.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    logId?: string;\n\n    /**\n     * Log severity level. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/common/logging/severity.h\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    logSeverityLevel?: 0|1|2|3|4;\n\n    /**\n     * Log verbosity level.\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     */\n    logVerbosityLevel?: number;\n\n    /**\n     * Specify string as a preferred data location for all outputs, or an object that use output names as keys and a\n     * preferred data location as corresponding values.\n     *\n     * This setting is available only in ONNXRuntime Web for WebGL and WebGPU EP.\n     */\n    preferredOutputLocation?: OnnxValueDataLocation|{readonly [outputName: string]: OnnxValueDataLocation};\n\n    /**\n     * Whether enable graph capture.\n     * This setting is available only in ONNXRuntime Web for WebGPU EP.\n     */\n    enableGraphCapture?: boolean;\n\n    /**\n     * Store configurations for a session. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/session/\n     * onnxruntime_session_options_config_keys.h\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     *\n     * @example\n     * ```js\n     * extra: {\n     *   session: {\n     *     set_denormal_as_zero: \"1\",\n     *     disable_prepacking: \"1\"\n     *   },\n     *   optimization: {\n     *     enable_gelu_approximation: \"1\"\n     *   }\n     * }\n     * ```\n     */\n    extra?: Record<string, unknown>;\n  }\n\n  // #region execution providers\n\n  // Currently, we have the following backends to support execution providers:\n  // Backend Node.js binding: supports 'cpu', 'dml' (win32), 'coreml' (macOS) and 'cuda' (linux).\n  // Backend WebAssembly: supports 'cpu', 'wasm', 'webgpu' and 'webnn'.\n  // Backend ONNX.js: supports 'webgl'.\n  // Backend React Native: supports 'cpu', 'xnnpack', 'coreml' (iOS), 'nnapi' (Android).\n  interface ExecutionProviderOptionMap {\n    coreml: CoreMLExecutionProviderOption;\n    cpu: CpuExecutionProviderOption;\n    cuda: CudaExecutionProviderOption;\n    dml: DmlExecutionProviderOption;\n    nnapi: NnapiExecutionProviderOption;\n    tensorrt: TensorRtExecutionProviderOption;\n    wasm: WebAssemblyExecutionProviderOption;\n    webgl: WebGLExecutionProviderOption;\n    webgpu: WebGpuExecutionProviderOption;\n    webnn: WebNNExecutionProviderOption;\n    xnnpack: XnnpackExecutionProviderOption;\n  }\n\n  type ExecutionProviderName = keyof ExecutionProviderOptionMap;\n  type ExecutionProviderConfig =\n      ExecutionProviderOptionMap[ExecutionProviderName]|ExecutionProviderOption|ExecutionProviderName|string;\n\n  export interface ExecutionProviderOption {\n    readonly name: string;\n  }\n  export interface CpuExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'cpu';\n    useArena?: boolean;\n  }\n  export interface CudaExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'cuda';\n    deviceId?: number;\n  }\n  export interface DmlExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'dml';\n    deviceId?: number;\n  }\n  export interface TensorRtExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'tensorrt';\n    deviceId?: number;\n  }\n  export interface WebAssemblyExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'wasm';\n  }\n  export interface WebGLExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'webgl';\n    // TODO: add flags\n  }\n  export interface XnnpackExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'xnnpack';\n  }\n  export interface WebGpuExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'webgpu';\n    preferredLayout?: 'NCHW'|'NHWC';\n  }\n  export interface WebNNExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'webnn';\n    deviceType?: 'cpu'|'gpu'|'npu';\n    numThreads?: number;\n    powerPreference?: 'default'|'low-power'|'high-performance';\n  }\n  export interface CoreMLExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'coreml';\n    /**\n     * The bit flags for CoreML execution provider.\n     *\n     * ```\n     * COREML_FLAG_USE_CPU_ONLY = 0x001\n     * COREML_FLAG_ENABLE_ON_SUBGRAPH = 0x002\n     * COREML_FLAG_ONLY_ENABLE_DEVICE_WITH_ANE = 0x004\n     * COREML_FLAG_ONLY_ALLOW_STATIC_INPUT_SHAPES = 0x008\n     * COREML_FLAG_CREATE_MLPROGRAM = 0x010\n     * ```\n     *\n     * See include/onnxruntime/core/providers/coreml/coreml_provider_factory.h for more details.\n     *\n     * This flag is available only in ONNXRuntime (Node.js binding).\n     */\n    coreMlFlags?: number;\n    /**\n     * Specify whether to use CPU only in CoreML EP.\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    useCPUOnly?: boolean;\n    /**\n     * Specify whether to enable CoreML EP on subgraph.\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    enableOnSubgraph?: boolean;\n    /**\n     * Specify whether to only enable CoreML EP for Apple devices with ANE (Apple Neural Engine).\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    onlyEnableDeviceWithANE?: boolean;\n  }\n  export interface NnapiExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'nnapi';\n    useFP16?: boolean;\n    useNCHW?: boolean;\n    cpuDisabled?: boolean;\n    cpuOnly?: boolean;\n  }\n  // #endregion\n\n  // #endregion\n\n  // #region run options\n\n  /**\n   * A set of configurations for inference run behavior\n   */\n  export interface RunOptions {\n    /**\n     * Log severity level. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/common/logging/severity.h\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    logSeverityLevel?: 0|1|2|3|4;\n\n    /**\n     * Log verbosity level.\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     */\n    logVerbosityLevel?: number;\n\n    /**\n     * Terminate all incomplete OrtRun calls as soon as possible if true\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     */\n    terminate?: boolean;\n\n    /**\n     * A tag for the Run() calls using this\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    tag?: string;\n\n    /**\n     * Set a single run configuration entry. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/session/\n     * onnxruntime_run_options_config_keys.h\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     *\n     * @example\n     *\n     * ```js\n     * extra: {\n     *   memory: {\n     *     enable_memory_arena_shrinkage: \"1\",\n     *   }\n     * }\n     * ```\n     */\n    extra?: Record<string, unknown>;\n  }\n\n  // #endregion\n\n  // #region value metadata\n\n  // eslint-disable-next-line @typescript-eslint/no-empty-interface\n  interface ValueMetadata {\n    // TBD\n  }\n\n  // #endregion\n}\n\n/**\n * Represent a runtime instance of an ONNX model.\n */\nexport interface InferenceSession {\n  // #region run()\n\n  /**\n   * Execute the model asynchronously with the given feeds and options.\n   *\n   * @param feeds - Representation of the model input. See type description of `InferenceSession.InputType` for detail.\n   * @param options - Optional. A set of options that controls the behavior of model inference.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding values.\n   */\n  run(feeds: InferenceSession.FeedsType, options?: InferenceSession.RunOptions): Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Execute the model asynchronously with the given feeds, fetches and options.\n   *\n   * @param feeds - Representation of the model input. See type description of `InferenceSession.InputType` for detail.\n   * @param fetches - Representation of the model output. See type description of `InferenceSession.OutputType` for\n   * detail.\n   * @param options - Optional. A set of options that controls the behavior of model inference.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding values.\n   */\n  run(feeds: InferenceSession.FeedsType, fetches: InferenceSession.FetchesType,\n      options?: InferenceSession.RunOptions): Promise<InferenceSession.ReturnType>;\n\n  // #endregion\n\n  // #region release()\n\n  /**\n   * Release the inference session and the underlying resources.\n   */\n  release(): Promise<void>;\n\n  // #endregion\n\n  // #region profiling\n\n  /**\n   * Start profiling.\n   */\n  startProfiling(): void;\n\n  /**\n   * End profiling.\n   */\n  endProfiling(): void;\n\n  // #endregion\n\n  // #region metadata\n\n  /**\n   * Get input names of the loaded model.\n   */\n  readonly inputNames: readonly string[];\n\n  /**\n   * Get output names of the loaded model.\n   */\n  readonly outputNames: readonly string[];\n\n  // /**\n  //  * Get input metadata of the loaded model.\n  //  */\n  // readonly inputMetadata: ReadonlyArray<Readonly<InferenceSession.ValueMetadata>>;\n\n  // /**\n  //  * Get output metadata of the loaded model.\n  //  */\n  // readonly outputMetadata: ReadonlyArray<Readonly<InferenceSession.ValueMetadata>>;\n\n  // #endregion\n}\n\nexport interface InferenceSessionFactory {\n  // #region create()\n\n  /**\n   * Create a new inference session and load model asynchronously from an ONNX model file.\n   *\n   * @param uri - The URI or file path of the model to load.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(uri: string, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from an array bufer.\n   *\n   * @param buffer - An ArrayBuffer representation of an ONNX model.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(buffer: ArrayBufferLike, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from segment of an array bufer.\n   *\n   * @param buffer - An ArrayBuffer representation of an ONNX model.\n   * @param byteOffset - The beginning of the specified portion of the array buffer.\n   * @param byteLength - The length in bytes of the array buffer.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(buffer: ArrayBufferLike, byteOffset: number, byteLength?: number, options?: InferenceSession.SessionOptions):\n      Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from a Uint8Array.\n   *\n   * @param buffer - A Uint8Array representation of an ONNX model.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(buffer: Uint8Array, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  // #endregion\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const InferenceSession: InferenceSessionFactory = InferenceSessionImpl;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {OptionsFormat, OptionsNormalizationParameters, OptionsTensorLayout} from './tensor-factory.js';\n\nexport interface TensorToDataUrlOptions extends OptionsTensorLayout, OptionsFormat, OptionsNormalizationParameters {}\n\nexport interface TensorToImageDataOptions extends OptionsTensorLayout, OptionsFormat, OptionsNormalizationParameters {}\n\nexport interface ConversionUtils {\n  /**\n   * creates a DataURL instance from tensor\n   *\n   * @param options - An optional object representing options for creating a DataURL instance from the tensor.\n   *\n   * The following default settings will be applied:\n   * - `format`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * @returns a DataURL string representing the image converted from tensor data\n   */\n  toDataURL(options?: TensorToDataUrlOptions): string;\n\n  /**\n   * creates an ImageData instance from tensor\n   *\n   * @param options - An optional object representing options for creating an ImageData instance from the tensor.\n   *\n   * The following default settings will be applied:\n   * - `format`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * @returns an ImageData instance representing the image converted from tensor data\n   */\n  toImageData(options?: TensorToImageDataOptions): ImageData;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Tensor, TypedTensor} from './tensor.js';\n\nexport type ImageFormat = 'RGB'|'RGBA'|'BGR'|'RBG';\nexport type ImageTensorLayout = 'NHWC'|'NCHW';\n\n// the following region contains type definitions for constructing tensor from a specific location.\n\n// #region types for constructing a tensor from a specific location\n\n/**\n * represent common properties of the parameter for constructing a tensor from a specific location.\n */\ninterface CommonConstructorParameters<T> extends Pick<Tensor, 'dims'> {\n  /**\n   * Specify the data type of the tensor.\n   */\n  readonly type: T;\n}\n\n/**\n * represent the parameter for constructing a tensor from a GPU resource.\n */\ninterface GpuResourceConstructorParameters<T extends Tensor.Type> {\n  /**\n   * an optional callback function to download data from GPU to CPU.\n   *\n   * If not provided, the tensor treat the GPU data as external resource.\n   */\n  download?(): Promise<Tensor.DataTypeMap[T]>;\n\n  /**\n   * an optional callback function that will be called when the tensor is disposed.\n   *\n   * If not provided, the tensor treat the GPU data as external resource.\n   */\n  dispose?(): void;\n}\n\n/**\n * represent the parameter for constructing a tensor from a pinned CPU buffer\n */\nexport interface CpuPinnedConstructorParameters<T extends Tensor.CpuPinnedDataTypes = Tensor.CpuPinnedDataTypes> extends\n    CommonConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'cpu-pinned'.\n   */\n  readonly location: 'cpu-pinned';\n  /**\n   * Specify the CPU pinned buffer that holds the tensor data.\n   */\n  readonly data: Tensor.DataTypeMap[T];\n}\n\n/**\n * represent the parameter for constructing a tensor from a WebGL texture\n */\nexport interface TextureConstructorParameters<T extends Tensor.TextureDataTypes = Tensor.TextureDataTypes> extends\n    CommonConstructorParameters<T>, GpuResourceConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'texture'.\n   */\n  readonly location: 'texture';\n  /**\n   * Specify the WebGL texture that holds the tensor data.\n   */\n  readonly texture: Tensor.TextureType;\n}\n\n/**\n * represent the parameter for constructing a tensor from a WebGPU buffer\n */\nexport interface GpuBufferConstructorParameters<T extends Tensor.GpuBufferDataTypes = Tensor.GpuBufferDataTypes> extends\n    CommonConstructorParameters<T>, GpuResourceConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'gpu-buffer'.\n   */\n  readonly location: 'gpu-buffer';\n  /**\n   * Specify the WebGPU buffer that holds the tensor data.\n   */\n  readonly gpuBuffer: Tensor.GpuBufferType;\n}\n\n// #endregion\n\n// the following region contains type definitions of each individual options.\n// the tensor factory functions use a composition of those options as the parameter type.\n\n// #region Options fields\n\nexport interface OptionsFormat {\n  /**\n   * Describes the image format represented in RGBA color space.\n   */\n  format?: ImageFormat;\n}\n\nexport interface OptionsTensorFormat {\n  /**\n   * Describes the image format of the tensor.\n   *\n   * NOTE: this is different from option 'format'. While option 'format' represents the original image, 'tensorFormat'\n   * represents the target format of the tensor. A transpose will be performed if they are different.\n   */\n  tensorFormat?: ImageFormat;\n}\n\nexport interface OptionsTensorDataType {\n  /**\n   * Describes the data type of the tensor.\n   */\n  dataType?: 'float32'|'uint8';\n}\n\nexport interface OptionsTensorLayout {\n  /**\n   * Describes the tensor layout when representing data of one or more image(s).\n   */\n  tensorLayout?: ImageTensorLayout;\n}\n\nexport interface OptionsDimensions {\n  /**\n   * Describes the image height in pixel\n   */\n  height?: number;\n  /**\n   * Describes the image width in pixel\n   */\n  width?: number;\n}\n\nexport interface OptionResizedDimensions {\n  /**\n   * Describes the resized height. If omitted, original height will be used.\n   */\n  resizedHeight?: number;\n  /**\n   * Describes resized width - can be accessed via tensor dimensions as well\n   */\n  resizedWidth?: number;\n}\n\nexport interface OptionsNormalizationParameters {\n  /**\n   * Describes normalization parameters when preprocessing the image as model input.\n   *\n   * Data element are ranged from 0 to 255.\n   */\n  norm?: {\n    /**\n     * The 'bias' value for image normalization.\n     * - If omitted, use default value 0.\n     * - If it's a single number, apply to each channel\n     * - If it's an array of 3 or 4 numbers, apply element-wise. Number of elements need to match the number of channels\n     * for the corresponding image format\n     */\n    bias?: number|[number, number, number]|[number, number, number, number];\n    /**\n     * The 'mean' value for image normalization.\n     * - If omitted, use default value 255.\n     * - If it's a single number, apply to each channel\n     * - If it's an array of 3 or 4 numbers, apply element-wise. Number of elements need to match the number of channels\n     * for the corresponding image format\n     */\n    mean?: number | [number, number, number] | [number, number, number, number];\n  };\n}\n\n// #endregion\n\n// #region Options composition\n\nexport interface TensorFromImageDataOptions extends OptionResizedDimensions, OptionsTensorFormat, OptionsTensorLayout,\n                                                    OptionsTensorDataType, OptionsNormalizationParameters {}\n\nexport interface TensorFromImageElementOptions extends OptionResizedDimensions, OptionsTensorFormat,\n                                                       OptionsTensorLayout, OptionsTensorDataType,\n                                                       OptionsNormalizationParameters {}\n\nexport interface TensorFromUrlOptions extends OptionsDimensions, OptionResizedDimensions, OptionsTensorFormat,\n                                              OptionsTensorLayout, OptionsTensorDataType,\n                                              OptionsNormalizationParameters {}\n\nexport interface TensorFromImageBitmapOptions extends OptionResizedDimensions, OptionsTensorFormat, OptionsTensorLayout,\n                                                      OptionsTensorDataType, OptionsNormalizationParameters {}\n\nexport interface TensorFromTextureOptions<T extends Tensor.TextureDataTypes> extends\n    Required<OptionsDimensions>, OptionsFormat, GpuResourceConstructorParameters<T>/* TODO: add more */ {}\n\nexport interface TensorFromGpuBufferOptions<T extends Tensor.GpuBufferDataTypes> extends\n    Pick<Tensor, 'dims'>, GpuResourceConstructorParameters<T> {\n  /**\n   * Describes the data type of the tensor.\n   */\n  dataType?: T;\n}\n\n// #endregion\n\n/**\n * type TensorFactory defines the factory functions of 'Tensor' to create tensor instances from existing data or\n * resources.\n */\nexport interface TensorFactory {\n  /**\n   * create a tensor from an ImageData object\n   *\n   * @param imageData - the ImageData object to create tensor from\n   * @param options - An optional object representing options for creating tensor from ImageData.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(imageData: ImageData, options?: TensorFromImageDataOptions):\n      Promise<TypedTensor<'float32'>|TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from a HTMLImageElement object\n   *\n   * @param imageElement - the HTMLImageElement object to create tensor from\n   * @param options - An optional object representing options for creating tensor from HTMLImageElement.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(imageElement: HTMLImageElement, options?: TensorFromImageElementOptions):\n      Promise<TypedTensor<'float32'>|TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from URL\n   *\n   * @param urlSource - a string as a URL to the image or a data URL containing the image data.\n   * @param options - An optional object representing options for creating tensor from URL.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(urlSource: string, options?: TensorFromUrlOptions): Promise<TypedTensor<'float32'>|TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from an ImageBitmap object\n   *\n   * @param bitmap - the ImageBitmap object to create tensor from\n   * @param options - An optional object representing options for creating tensor from URL.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(bitmap: ImageBitmap, options: TensorFromImageBitmapOptions):\n      Promise<TypedTensor<'float32'>|TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from a WebGL texture\n   *\n   * @param texture - the WebGLTexture object to create tensor from\n   * @param options - An optional object representing options for creating tensor from WebGL texture.\n   *\n   * The options include following properties:\n   * - `width`: the width of the texture. Required.\n   * - `height`: the height of the texture. Required.\n   * - `format`: the format of the texture. If omitted, assume 'RGBA'.\n   * - `download`: an optional function to download the tensor data from GPU to CPU. If omitted, the GPU data\n   * will not be able to download. Usually, this is provided by a GPU backend for the inference outputs. Users don't\n   * need to provide this function.\n   * - `dispose`: an optional function to dispose the tensor data on GPU. If omitted, the GPU data will not be disposed.\n   * Usually, this is provided by a GPU backend for the inference outputs. Users don't need to provide this function.\n   *\n   * @returns a tensor object\n   */\n  fromTexture<T extends Tensor.TextureDataTypes = 'float32'>(\n      texture: Tensor.TextureType, options: TensorFromTextureOptions<T>): TypedTensor<'float32'>;\n\n  /**\n   * create a tensor from a WebGPU buffer\n   *\n   * @param buffer - the GPUBuffer object to create tensor from\n   * @param options - An optional object representing options for creating tensor from WebGPU buffer.\n   *\n   * The options include following properties:\n   * - `dataType`: the data type of the tensor. If omitted, assume 'float32'.\n   * - `dims`: the dimension of the tensor. Required.\n   * - `download`: an optional function to download the tensor data from GPU to CPU. If omitted, the GPU data\n   * will not be able to download. Usually, this is provided by a GPU backend for the inference outputs. Users don't\n   * need to provide this function.\n   * - `dispose`: an optional function to dispose the tensor data on GPU. If omitted, the GPU data will not be disposed.\n   * Usually, this is provided by a GPU backend for the inference outputs. Users don't need to provide this function.\n   *\n   * @returns a tensor object\n   */\n  fromGpuBuffer<T extends Tensor.GpuBufferDataTypes>(\n      buffer: Tensor.GpuBufferType, options: TensorFromGpuBufferOptions<T>): TypedTensor<T>;\n\n  /**\n   * create a tensor from a pre-allocated buffer. The buffer will be used as a pinned buffer.\n   *\n   * @param type - the tensor element type.\n   * @param buffer - a TypedArray corresponding to the type.\n   * @param dims - specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   *\n   * @returns a tensor object\n   */\n  fromPinnedBuffer<T extends Exclude<Tensor.Type, 'string'>>(\n      type: T, buffer: Tensor.DataTypeMap[T], dims?: readonly number[]): TypedTensor<T>;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/**\n * A string that represents a file's URL or path.\n *\n * Path is vailable only in onnxruntime-node or onnxruntime-web running in Node.js.\n */\nexport type FileUrlOrPath = string;\n\n/**\n * A Blob object that represents a file.\n */\nexport type FileBlob = Blob;\n\n/**\n * A Uint8Array, ArrayBuffer or SharedArrayBuffer object that represents a file content.\n *\n * When it is an ArrayBuffer or SharedArrayBuffer, the whole buffer is assumed to be the file content.\n */\nexport type FileData = Uint8Array|ArrayBufferLike;\n\n/**\n * Represents a file that can be loaded by the ONNX Runtime JavaScript API.\n */\nexport type FileType = FileUrlOrPath|FileBlob|FileData;\n\n/**\n * Represents an external data file.\n */\nexport interface ExternalDataFileDescription {\n  /**\n   * Specify the external data file.\n   */\n  data: FileType;\n  /**\n   * Specify the file path.\n   */\n  path: string;\n}\n\n/**\n * Represents an external data file.\n *\n * When using a string, it should be a file URL or path that in the same directory as the model file.\n */\nexport type ExternalDataFileType = ExternalDataFileDescription|FileUrlOrPath;\n\n/**\n * Options for model loading.\n */\nexport interface OnnxModelOptions {\n  /**\n   * Specifying a list of files that represents the external data.\n   */\n  externalData?: readonly ExternalDataFileType[];\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Tensor} from './tensor.js';\n\nexport type NonTensorType = never;\n\n/**\n * Type OnnxValue Represents both tensors and non-tensors value for model's inputs/outputs.\n *\n * NOTE: currently not support non-tensor\n */\nexport type OnnxValue = Tensor|NonTensorType;\n\n/**\n * Type OnnxValueDataLocation represents the location of the data of an OnnxValue.\n */\nexport type OnnxValueDataLocation = Tensor.DataLocation;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {resolveBackendAndExecutionProviders} from './backend-impl.js';\nimport {SessionHandler, TrainingSessionHandler} from './backend.js';\nimport {InferenceSession as InferenceSession} from './inference-session.js';\nimport {OnnxValue} from './onnx-value.js';\nimport {Tensor} from './tensor.js';\nimport {TrainingSession as TrainingSessionInterface, TrainingSessionCreateOptions} from './training-session.js';\n\ntype SessionOptions = InferenceSession.SessionOptions;\ntype FeedsType = InferenceSession.FeedsType;\ntype FetchesType = InferenceSession.FetchesType;\ntype ReturnType = InferenceSession.ReturnType;\ntype RunOptions = InferenceSession.RunOptions;\n\nconst noBackendErrMsg: string = 'Training backend could not be resolved. ' +\n    'Make sure you\\'re using the correct configuration & WebAssembly files.';\n\nexport class TrainingSession implements TrainingSessionInterface {\n  private constructor(handler: TrainingSessionHandler, hasOptimizerModel: boolean, hasEvalModel: boolean) {\n    this.handler = handler;\n    this.hasOptimizerModel = hasOptimizerModel;\n    this.hasEvalModel = hasEvalModel;\n  }\n  private handler: TrainingSessionHandler;\n  private hasOptimizerModel: boolean;\n  private hasEvalModel: boolean;\n\n  get trainingInputNames(): readonly string[] {\n    return this.handler.inputNames;\n  }\n  get trainingOutputNames(): readonly string[] {\n    return this.handler.outputNames;\n  }\n\n  get evalInputNames(): readonly string[] {\n    if (this.hasEvalModel) {\n      return this.handler.evalInputNames;\n    } else {\n      throw new Error('This training session has no evalModel loaded.');\n    }\n  }\n  get evalOutputNames(): readonly string[] {\n    if (this.hasEvalModel) {\n      return this.handler.evalOutputNames;\n    } else {\n      throw new Error('This training session has no evalModel loaded.');\n    }\n  }\n\n  static async create(trainingOptions: TrainingSessionCreateOptions, sessionOptions?: SessionOptions):\n      Promise<TrainingSession> {\n    const evalModel: string|Uint8Array = trainingOptions.evalModel || '';\n    const optimizerModel: string|Uint8Array = trainingOptions.optimizerModel || '';\n    const options: SessionOptions = sessionOptions || {};\n\n    // resolve backend, update session options with validated EPs, and create session handler\n    const [backend, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);\n    if (backend.createTrainingSessionHandler) {\n      const handler = await backend.createTrainingSessionHandler(\n          trainingOptions.checkpointState, trainingOptions.trainModel, evalModel, optimizerModel,\n          optionsWithValidatedEPs);\n      return new TrainingSession(handler, !!trainingOptions.optimizerModel, !!trainingOptions.evalModel);\n    } else {\n      throw new Error(noBackendErrMsg);\n    }\n  }\n\n  /**\n   * Helper function for runTrainStep and future runStep methods that handles the type-narrowing conversion from\n   * the given parameters to SessionHandler.FetchesType and RunOptions.\n   *\n   * @param inputNames the feeds object is checked that they contain all input names in the provided list of input\n   * names.\n   * @param outputNames the fetches object is checked that their keys match up with valid names in the list of output\n   * names.\n   * @param feeds the required input\n   * @param arg1 narrowed & converted into the SessionHandler.FetchesType or RunOptions object\n   * @param arg2 optional RunOptions object.\n   * @returns\n   */\n  typeNarrowingForRunStep(\n      inputNames: readonly string[], outputNames: readonly string[], feeds: FeedsType, arg1?: FetchesType|RunOptions,\n      arg2?: RunOptions): [SessionHandler.FetchesType, RunOptions] {\n    const fetches: {[name: string]: OnnxValue|null} = {};\n    let options: RunOptions = {};\n    // check inputs\n    if (typeof feeds !== 'object' || feeds === null || feeds instanceof Tensor || Array.isArray(feeds)) {\n      throw new TypeError(\n          '\\'feeds\\' must be an object that use input names as keys and OnnxValue as corresponding values.');\n    }\n\n    let isFetchesEmpty = true;\n    // determine which override is being used\n    if (typeof arg1 === 'object') {\n      if (arg1 === null) {\n        throw new TypeError('Unexpected argument[1]: cannot be null.');\n      }\n      if (arg1 instanceof Tensor) {\n        throw new TypeError('\\'fetches\\' cannot be a Tensor');\n      }\n\n      if (Array.isArray(arg1)) {\n        if (arg1.length === 0) {\n          throw new TypeError('\\'fetches\\' cannot be an empty array.');\n        }\n        isFetchesEmpty = false;\n        // output names\n        for (const name of arg1) {\n          if (typeof name !== 'string') {\n            throw new TypeError('\\'fetches\\' must be a string array or an object.');\n          }\n          if (outputNames.indexOf(name) === -1) {\n            throw new RangeError(`'fetches' contains invalid output name: ${name}.`);\n          }\n          fetches[name] = null;\n        }\n\n        if (typeof arg2 === 'object' && arg2 !== null) {\n          options = arg2;\n        } else if (typeof arg2 !== 'undefined') {\n          throw new TypeError('\\'options\\' must be an object.');\n        }\n      } else {\n        // decide whether arg1 is fetches or options\n        // if any output name is present and its value is valid OnnxValue, we consider it fetches\n        let isFetches = false;\n        const arg1Keys = Object.getOwnPropertyNames(arg1);\n        for (const name of outputNames) {\n          if (arg1Keys.indexOf(name) !== -1) {\n            const v = (arg1 as InferenceSession.NullableOnnxValueMapType)[name];\n            if (v === null || v instanceof Tensor) {\n              isFetches = true;\n              isFetchesEmpty = false;\n              fetches[name] = v;\n            }\n          }\n        }\n\n        if (isFetches) {\n          if (typeof arg2 === 'object' && arg2 !== null) {\n            options = arg2;\n          } else if (typeof arg2 !== 'undefined') {\n            throw new TypeError('\\'options\\' must be an object.');\n          }\n        } else {\n          options = arg1 as RunOptions;\n        }\n      }\n    } else if (typeof arg1 !== 'undefined') {\n      throw new TypeError('Unexpected argument[1]: must be \\'fetches\\' or \\'options\\'.');\n    }\n\n    // check if all inputs are in feed\n    for (const name of inputNames) {\n      if (typeof feeds[name] === 'undefined') {\n        throw new Error(`input '${name}' is missing in 'feeds'.`);\n      }\n    }\n\n    // if no fetches is specified, we use the full output names list\n    if (isFetchesEmpty) {\n      for (const name of outputNames) {\n        fetches[name] = null;\n      }\n    }\n\n    return [fetches, options];\n  }\n\n  /**\n   * Helper method for runTrainStep and any other runStep methods. Takes the ReturnType result from the SessionHandler\n   * and changes it into a map of Tensors.\n   *\n   * @param results\n   * @returns\n   */\n  convertHandlerReturnTypeToMapOfTensors(results: SessionHandler.ReturnType): ReturnType {\n    const returnValue: {[name: string]: OnnxValue} = {};\n    for (const key in results) {\n      if (Object.hasOwnProperty.call(results, key)) {\n        const result = results[key];\n        if (result instanceof Tensor) {\n          returnValue[key] = result;\n        } else {\n          returnValue[key] = new Tensor(result.type, result.data, result.dims);\n        }\n      }\n    }\n    return returnValue;\n  }\n\n  async lazyResetGrad(): Promise<void> {\n    await this.handler.lazyResetGrad();\n  }\n\n  runTrainStep(feeds: FeedsType, options?: RunOptions): Promise<ReturnType>;\n  runTrainStep(feeds: FeedsType, fetches: FetchesType, options?: RunOptions): Promise<ReturnType>;\n  async runTrainStep(feeds: FeedsType, arg1?: FetchesType|RunOptions, arg2?: RunOptions): Promise<ReturnType> {\n    const [fetches, options] =\n        this.typeNarrowingForRunStep(this.trainingInputNames, this.trainingOutputNames, feeds, arg1, arg2);\n    const results = await this.handler.runTrainStep(feeds, fetches, options);\n    return this.convertHandlerReturnTypeToMapOfTensors(results);\n  }\n\n  async runOptimizerStep(options?: InferenceSession.RunOptions|undefined): Promise<void> {\n    if (this.hasOptimizerModel) {\n      await this.handler.runOptimizerStep(options || {});\n    } else {\n      throw new Error('This TrainingSession has no OptimizerModel loaded.');\n    }\n  }\n\n  runEvalStep(feeds: FeedsType, options?: RunOptions|undefined): Promise<ReturnType>;\n  runEvalStep(feeds: FeedsType, fetches: FetchesType, options?: RunOptions|undefined): Promise<ReturnType>;\n  async runEvalStep(feeds: FeedsType, arg1?: FetchesType|RunOptions, arg2?: RunOptions): Promise<ReturnType> {\n    if (this.hasEvalModel) {\n      const [fetches, options] =\n          this.typeNarrowingForRunStep(this.evalInputNames, this.evalOutputNames, feeds, arg1, arg2);\n      const results = await this.handler.runEvalStep(feeds, fetches, options);\n      return this.convertHandlerReturnTypeToMapOfTensors(results);\n    } else {\n      throw new Error('This TrainingSession has no EvalModel loaded.');\n    }\n  }\n\n  async getParametersSize(trainableOnly = true): Promise<number> {\n    return this.handler.getParametersSize(trainableOnly);\n  }\n\n  async loadParametersBuffer(array: Uint8Array, trainableOnly = true): Promise<void> {\n    const paramsSize = await this.getParametersSize(trainableOnly);\n    // checking that the size of the Uint8Array is equivalent to the byte length of a Float32Array of the number\n    // of parameters\n    if (array.length !== 4 * paramsSize) {\n      throw new Error(\n          'Size of the buffer passed into loadParametersBuffer must match the number of parameters in ' +\n          'the model. Please use getParametersSize method to check.');\n    }\n    return this.handler.loadParametersBuffer(array, trainableOnly);\n  }\n\n  async getContiguousParameters(trainableOnly = true): Promise<OnnxValue> {\n    return this.handler.getContiguousParameters(trainableOnly);\n  }\n\n  async release(): Promise<void> {\n    return this.handler.dispose();\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {InferenceSession} from './inference-session.js';\nimport {OnnxValue} from './onnx-value.js';\nimport {TrainingSession as TrainingSessionImpl} from './training-session-impl.js';\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\nexport declare namespace TrainingSession {\n  /**\n   * Either URI file path (string) or Uint8Array containing model or checkpoint information.\n   */\n  type UriOrBuffer = string|Uint8Array;\n}\n\n/**\n * Represent a runtime instance of an ONNX training session,\n * which contains a model that can be trained, and, optionally,\n * an eval and optimizer model.\n */\nexport interface TrainingSession {\n  // #region run()\n\n  /**\n   * Lazily resets the gradients of all trainable parameters to zero. Should happen after the invocation of\n   * runOptimizerStep.\n   */\n  lazyResetGrad(): Promise<void>;\n\n  /**\n   * Run TrainStep asynchronously with the given feeds and options.\n   *\n   * @param feeds - Representation of the model input. See type description of `InferenceSession.InputType` for\n   detail.\n   * @param options - Optional. A set of options that controls the behavior of model training.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding values.\n   */\n  runTrainStep(feeds: InferenceSession.FeedsType, options?: InferenceSession.RunOptions):\n      Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Run a single train step with the given inputs and options.\n   *\n   * @param feeds - Representation of the model input.\n   * @param fetches - Representation of the model output.\n   * detail.\n   * @param options - Optional. A set of options that controls the behavior of model training.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding\n   values.\n   */\n  runTrainStep(\n      feeds: InferenceSession.FeedsType, fetches: InferenceSession.FetchesType,\n      options?: InferenceSession.RunOptions): Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Runs a single optimizer step, which performs weight updates for the trainable parameters using the optimizer model.\n   *\n   * @param options - Optional. A set of options that controls the behavior of model optimizing.\n   */\n  runOptimizerStep(options?: InferenceSession.RunOptions): Promise<void>;\n\n  /**\n   * Run a single eval step with the given inputs and options using the eval model.\n   *\n   * @param feeds - Representation of the model input.\n   * @param options - Optional. A set of options that controls the behavior of model eval step.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding\n   values.\n   */\n  runEvalStep(feeds: InferenceSession.FeedsType, options?: InferenceSession.RunOptions):\n      Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Run a single eval step with the given inputs and options using the eval model.\n   *\n   * @param feeds - Representation of the model input.\n   * @param fetches - Representation of the model output.\n   * detail.\n   * @param options - Optional. A set of options that controls the behavior of model eval step.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding\n   values.\n   */\n  runEvalStep(\n      feeds: InferenceSession.FeedsType, fetches: InferenceSession.FetchesType,\n      options?: InferenceSession.RunOptions): Promise<InferenceSession.ReturnType>;\n\n  // #endregion\n\n  // #region copy parameters\n\n  /**\n   * Retrieves the size of all parameters for the training state. Calculates the total number of primitive (datatype of\n   * the parameters) elements of all the parameters in the training state.\n   *\n   * @param trainableOnly - When set to true, the size is calculated for trainable params only. Default value is true.\n   */\n  getParametersSize(trainableOnly: boolean): Promise<number>;\n\n  /**\n   * Copies parameter values from the given buffer to the training state. Currently, only supporting models with\n   * parameters of type Float32.\n   *\n   * @param buffer - A Uint8Array representation of Float32 parameters.\n   * @param trainableOnly - True if trainable parameters only to be modified, false otherwise. Default value is true.\n   */\n  loadParametersBuffer(buffer: Uint8Array, trainableOnly: boolean): Promise<void>;\n\n  /**\n   * Copies the model parameters to a contiguous buffer. Usually used in the context of Federated Learning.\n   * Currently, only supporting models with parameters of type Float32.\n   *\n   * @param trainableOnly - When set to true, only trainable parameters are copied. Trainable parameters are parameters\n   * for which requires_grad is set to true. Default value is true.\n   * @returns A promise that resolves to a Float32 OnnxValue of the requested parameters.\n   */\n  getContiguousParameters(trainableOnly: boolean): Promise<OnnxValue>;\n  // #endregion\n\n  // #region release()\n\n  /**\n   * Release the inference session and the underlying resources.\n   */\n  release(): Promise<void>;\n  // #endregion\n\n  // #region metadata\n\n  /**\n   * Get input names of the loaded training model.\n   */\n  readonly trainingInputNames: readonly string[];\n\n  /**\n   * Get output names of the loaded training model.\n   */\n  readonly trainingOutputNames: readonly string[];\n\n  /**\n   * Get input names of the loaded eval model. Is an empty array if no eval model is loaded.\n   */\n  readonly evalInputNames: readonly string[];\n\n  /**\n   * Get output names of the loaded eval model. Is an empty array if no eval model is loaded.\n   */\n  readonly evalOutputNames: readonly string[];\n\n  // #endregion\n}\n\n/**\n * Represents the optional parameters that can be passed into the TrainingSessionFactory.\n */\nexport interface TrainingSessionCreateOptions {\n  /**\n   * URI or buffer for a .ckpt file that contains the checkpoint for the training model.\n   */\n  checkpointState: TrainingSession.UriOrBuffer;\n  /**\n   * URI or buffer for the .onnx training file.\n   */\n  trainModel: TrainingSession.UriOrBuffer;\n  /**\n   * Optional. URI or buffer for the .onnx optimizer model file.\n   */\n  optimizerModel?: TrainingSession.UriOrBuffer;\n  /**\n   * Optional. URI or buffer for the .onnx eval model file.\n   */\n  evalModel?: TrainingSession.UriOrBuffer;\n}\n\n/**\n * Defines method overload possibilities for creating a TrainingSession.\n */\nexport interface TrainingSessionFactory {\n  // #region create()\n\n  /**\n   * Creates a new TrainingSession and asynchronously loads any models passed in through trainingOptions\n   *\n   * @param trainingOptions specify models and checkpoints to load into the Training Session\n   * @param sessionOptions specify configuration for training session behavior\n   *\n   * @returns Promise that resolves to a TrainingSession object\n   */\n  create(trainingOptions: TrainingSessionCreateOptions, sessionOptions?: InferenceSession.SessionOptions):\n      Promise<TrainingSession>;\n\n  // #endregion\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const TrainingSession: TrainingSessionFactory = TrainingSessionImpl;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/**\n * # ONNX Runtime JavaScript API\n *\n * ONNX Runtime JavaScript API is a unified API for all JavaScript usages, including the following NPM packages:\n *\n * - [onnxruntime-node](https://www.npmjs.com/package/onnxruntime-node)\n * - [onnxruntime-web](https://www.npmjs.com/package/onnxruntime-web)\n * - [onnxruntime-react-native](https://www.npmjs.com/package/onnxruntime-react-native)\n *\n * See also:\n * - [Get Started](https://onnxruntime.ai/docs/get-started/with-javascript/)\n * - [Inference examples](https://github.com/microsoft/onnxruntime-inference-examples/tree/main/js)\n *\n * @packageDocumentation\n */\n\nexport * from './backend.js';\nexport * from './env.js';\nexport * from './inference-session.js';\nexport * from './tensor.js';\nexport * from './tensor-conversion.js';\nexport * from './tensor-factory.js';\nexport * from './trace.js';\nexport * from './onnx-model.js';\nexport * from './onnx-value.js';\nexport * from './training-session.js';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Env} from 'onnxruntime-common';\n\nimport {logLevelStringToEnum} from '../wasm-common';\n\ntype LogLevel = NonNullable<Env['logLevel']>;\ntype MessageString = string;\ntype MessageFunction = () => string;\ntype Message = MessageString|MessageFunction;\n\nconst logLevelPrefix = ['V', 'I', 'W', 'E', 'F'];\n\nconst doLog = (level: number, message: string): void => {\n  // eslint-disable-next-line no-console\n  console.log(`[${logLevelPrefix[level]},${new Date().toISOString()}]${message}`);\n};\n\nlet configLogLevel: LogLevel|undefined;\nlet debug: boolean|undefined;\n\nexport const configureLogger = ($configLogLevel: LogLevel, $debug: boolean): void => {\n  configLogLevel = $configLogLevel;\n  debug = $debug;\n};\n\n/**\n * A simple logging utility to log messages to the console.\n */\nexport const LOG = (logLevel: LogLevel, msg: Message): void => {\n  const messageLevel = logLevelStringToEnum(logLevel);\n  const configLevel = logLevelStringToEnum(configLogLevel);\n  if (messageLevel >= configLevel) {\n    doLog(messageLevel, typeof msg === 'function' ? msg() : msg);\n  }\n};\n\n/**\n * A simple logging utility to log messages to the console. Only logs when debug is enabled.\n */\nexport const LOG_DEBUG: typeof LOG = (...args: Parameters<typeof LOG>) => {\n  if (debug) {\n    LOG(...args);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Tensor} from 'onnxruntime-common';\n\nimport {tensorTypeToTypedArrayConstructor} from '../wasm-common';\n\nexport const createView = (dataBuffer: ArrayBuffer, type: Tensor.Type): Int32Array|Uint32Array|BigInt64Array|\n    BigUint64Array|Uint8Array|Float32Array|Float64Array|Int8Array|Int16Array|Uint16Array =>\n        new (tensorTypeToTypedArrayConstructor(type))(dataBuffer);\n\n/**\n * a TensorView does not own the data.\n */\nexport interface TensorView {\n  readonly data: number;\n  readonly dataType: number;\n  readonly dims: readonly number[];\n\n  /**\n   * get a Float32Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getFloat32Array(): Float32Array;\n\n  /**\n   * get a BigInt64Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getBigInt64Array(): BigInt64Array;\n\n  /**\n   * get a Int32Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getInt32Array(): Int32Array;\n\n  /**\n   * create a new tensor view with the same data but different dimensions.\n   */\n  reshape(newDims: readonly number[]): TensorView;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../wasm-common';\nimport {TensorView} from '../tensor-view';\n\nimport {ShaderHelper} from './ops/common';\n\nexport type SessionState = 'default'|'capturing'|'replaying';\n\nexport enum GpuDataType {\n  default = 0,\n  upload = 1,\n  profile = 2\n}\nexport type GpuDataId = number;\n\nexport type GpuArchitecture = 'ampere';\nexport type GpuVendor = 'amd'|'intel'|'nvidia';\nexport interface AdapterInfo {\n  isArchitecture: (architecture: GpuArchitecture) => boolean;\n  isVendor: (vendor: GpuVendor) => boolean;\n}\n\nexport interface GpuData {\n  type: GpuDataType;\n  id: GpuDataId;\n  buffer: GPUBuffer;\n}\n\nexport interface TensorInfo {\n  dims: readonly number[];\n  dataType: number;\n}\n\nexport interface ProgramUniform {\n  type: DataType;\n  data: number|readonly number[];\n}\n\nexport type ProgramUniformVariableInfo = [type: DataType, length: number];\n\n/**\n * Represent the dependency of a program on a specific input tensor.\n *\n * - 'none': the shader/uniform does not depend on this input's info\n * - 'type': the shader/uniform depends on data type of this input\n * - 'rank': the shader/uniform depends on data type and the rank of this input\n * - 'dims': the shader/uniform depends on data type and the dims of this input\n * - 'data': the shader/uniform depends on data type, the dims and the data of this input\n */\nexport type ProgramInputTensorInfoDependency = 'none'|'type'|'rank'|'dims'|'data';\n\n/**\n * Represent information about a program's cache for shader.\n */\nexport interface ProgramShaderCacheInfo {\n  /**\n   * an optional string as a cache hint in the artifact cache. If this is not specified, the cache hint will be empty.\n   *\n   * This hint string should only contains initializing-time information, such as the attributes or any information of\n   * initializers. It should NOT contain any runtime information, such as the shape of inputs.\n   */\n  hint?: string;\n\n  /**\n   * an optional list of dependencies of the program on the input tensors. If this is not specified, the program depends\n   * on 'dims' of all inputs.\n   */\n  inputDependencies?: ProgramInputTensorInfoDependency[];\n}\n\n/**\n * Represent information about a program's cache for uniform.\n */\nexport interface ProgramUniformCacheInfo {\n  /**\n   * an optional string as a cache hint in the uniform cache. If this is not specified, the cache hint will be empty.\n   *\n   * This hint string should only contains runtime information, such as the shape of inputs.\n   */\n  hint?: string;\n\n  /**\n   * an optional list of dependencies of the program on the input tensors. If this is not specified, the program depends\n   * on 'none' of all inputs.\n   */\n  inputDependencies?: ProgramInputTensorInfoDependency[];\n}\n\n\n/**\n * A set of data that represent a shader program\n */\nexport interface ProgramInfo {\n  /**\n   * the name of the program. used for debugging and profiling\n   */\n  name: string;\n\n  /**\n   * an optional object describing the cache information of the program shader.\n   *\n   * If this is not specified, assume hint is empty and inputDependencies are ['dims'] for all inputs.\n   */\n  shaderCache?: ProgramShaderCacheInfo;\n\n  /**\n   * the shader's processing source code.\n   *\n   * This function will be called when shader cache missed.\n   */\n  getShaderSource: (shaderHelper: ShaderHelper) => string;\n\n  /**\n   * A function to get run data required to run the program.\n   *\n   * This function will be called every time the program is executed. Should keep this function as simple as possible.\n   */\n  getRunData: (inputs: readonly TensorView[]) => {\n    outputs: readonly TensorInfo[];\n    dispatchGroup: {x: number; y?: number; z?: number};\n    programUniforms?: readonly ProgramUniform[];\n  };\n}\n\nexport interface Artifact {\n  programInfo: ProgramInfo;\n  computePipeline: GPUComputePipeline;\n  uniformVariablesInfo: readonly ProgramUniformVariableInfo[]|undefined;\n}\n\nexport interface ComputeContextInputsOutputsMapping {\n  /**\n   * specify the mapping to the program's inputs. the value can be a number or a tensor view.\n   * - if it's a number, it's the index of the kernel's input\n   * - if it's a tensor view, it's an existing tensor view that will be used as the input\n   *\n   * if inputs is not specified, the mapping will be the kernel's inputs in order.\n   */\n  readonly inputs?: ReadonlyArray<TensorView|number>;\n  /**\n   * specify the mapping to the program's outputs. the value must be a number.\n   * - if it's a non-negative number, it's the index of the kernel's output\n   * - if it's -1, it's an output that will be created as a temporary value. this value will be released after\n   * the kernel is executed.\n   * - if it's -2, it's an output that will be created as a persistent value. this value will be released when the\n   * kernel is released.\n   *\n   * if outputs is not specified, the mapping will be the kernel's outputs in order.\n   */\n  readonly outputs?: readonly number[];\n}\n\n/**\n * A ComputeContext instance carries the states that representing the current running of a kernel.\n */\nexport interface ComputeContext {\n  /**\n   * gpu adapter info\n   */\n  readonly adapterInfo: AdapterInfo;\n\n  /**\n   * stores the pointer to OpKernelContext\n   */\n  readonly opKernelContext: number;\n\n  /**\n   * a list of inputs, each input is an instance of TensorView\n   */\n  readonly inputs: readonly TensorView[];\n\n  /**\n   * a custom data object that can be used to store any data that is needed by the kernel\n   */\n  readonly kernelCustomData: {[key: string]: unknown};\n\n  /**\n   * a buffer that can be used to access custom data created each time the kernel is executed\n   */\n  readonly customDataBuffer: Uint8Array;\n\n  /**\n   * a number of outputs for the node\n   */\n  readonly outputCount: number;\n\n  compute(program: ProgramInfo, inputsOutputsMapping?: ComputeContextInputsOutputsMapping): TensorView[];\n  output(index: number, dims: readonly number[]): number;\n  getMaxComputeWorkgroupSizes(): [number, number, number];\n  getMaxComputeWorkgroupStoragesize(): number;\n}\n\nexport type TimestampQuery = 'none'|'inside-passes'|'at-passes';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {WebGpuBackend} from '../backend-webgpu';\nimport {LOG_DEBUG} from '../log';\n\nimport {GpuData, GpuDataId, GpuDataType} from './types';\n\n/**\n * manages GpuDataId -> GpuBuffer\n */\nexport interface GpuDataManager {\n  /**\n   * copy data from CPU to GPU.\n   */\n  upload(id: GpuDataId, data: Uint8Array): void;\n  /**\n   * copy data from GPU to GPU.\n   */\n  memcpy(sourceId: GpuDataId, destinationId: GpuDataId): void;\n  /**\n   * create new data on GPU.\n   */\n  create(size: number, usage?: number): GpuData;\n  /**\n   * get GPU data by ID.\n   */\n  get(id: GpuDataId): GpuData|undefined;\n  /**\n   * release the data on GPU by ID.\n   *\n   * @return size of the data released\n   */\n  release(id: GpuDataId): number;\n  /**\n   * copy data from GPU to CPU.\n   */\n  download(id: GpuDataId, getTargetBuffer: () => Uint8Array): Promise<void>;\n\n  /**\n   * refresh the buffers that marked for release.\n   *\n   * when release() is called, the buffer is not released immediately. this is because we need to wait for the commands\n   * to be submitted to the GPU. this function is called after the commands are submitted so that the buffers can be\n   * actually released.\n   */\n  refreshPendingBuffers(): void;\n\n  /**\n   * register an external buffer for IO Binding. If the buffer is already registered, return the existing GPU data ID.\n   *\n   * GPU data manager only manages a mapping between the buffer and the GPU data ID. It will not manage the lifecycle of\n   * the external buffer.\n   */\n  registerExternalBuffer(buffer: GPUBuffer, originalSize: number, previousBuffer?: GPUBuffer): number;\n\n  /**\n   * unregister an external buffer for IO Binding.\n   */\n  unregisterExternalBuffer(buffer: GPUBuffer): void;\n\n  /**\n   * destroy all gpu buffers.\n   */\n  dispose(): void;\n\n  /**\n   * release session related data.\n   * @param sessionId - specify the session ID.\n   */\n  onReleaseSession(sessionId: number): void;\n}\n\ninterface StorageCacheValue {\n  gpuData: GpuData;\n  originalSize: number;\n}\n\nconst bucketFreelist: Map<number, number> = new Map([\n  [64, 250],\n  [128, 200],\n  [256, 200],\n  [512, 200],\n  [2048, 230],\n  [4096, 200],\n  [8192, 50],\n  [16384, 50],\n  [32768, 50],\n  [65536, 50],\n  [131072, 50],\n  [262144, 50],\n  [524288, 50],\n  [1048576, 50],\n  [2097152, 30],\n  [4194304, 20],\n  [8388608, 10],\n  [12582912, 10],\n  [16777216, 10],\n  [26214400, 15],\n  [33554432, 22],\n  [44236800, 2],\n  [58982400, 6],\n  // we don't want to cache the bucket sizes below but not caching them\n  // results in some major performance hits for models like sd-turbo.\n  [67108864, 6],\n  [134217728, 6],\n  [167772160, 6],\n]);\n\nconst bucketArr: number[] = [];\n\n/**\n * normalize the buffer size so that it fits the 128-bits (16 bytes) alignment.\n */\nconst calcNormalizedBufferSize = (size: number) => Math.ceil(size / 16) * 16;\n\n/**\n * calculate the buffer size so that it fits into buckets.\n */\nconst calcBucketBufferSize = (size: number) => {\n  for (let idx = 0; idx < bucketArr.length; idx++) {\n    const sizeForBucket = bucketArr[idx];\n    if (size <= sizeForBucket) {\n      return sizeForBucket;\n    }\n  }\n  // not in bucket list -> caller will not cache, round up to 16.\n  return Math.ceil(size / 16) * 16;\n};\n\nlet guid = 1;\nconst createNewGpuDataId = () => guid++;\n\n/**\n * exported standard download function. This function is used by the session to download the data from GPU, and also by\n * factory to create GPU tensors with the capacity of downloading data from GPU.\n *\n * @param backend - the WebGPU backend\n * @param gpuBuffer - the GPU buffer to download\n * @param originalSize - the original size of the data\n * @param getTargetBuffer - optional. If provided, the data will be copied to the target buffer. Otherwise, a new buffer\n * will be created and returned.\n */\nexport const downloadGpuData =\n    async(backend: WebGpuBackend, gpuBuffer: GPUBuffer, originalSize: number, getTargetBuffer?: () => Uint8Array):\n        Promise<Uint8Array> => {\n          const bufferSize = calcNormalizedBufferSize(originalSize);\n          const gpuReadBuffer = backend.device.createBuffer(\n              // eslint-disable-next-line no-bitwise\n              {size: bufferSize, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});\n          try {\n            const commandEncoder = backend.getCommandEncoder();\n            backend.endComputePass();\n            commandEncoder.copyBufferToBuffer(\n                gpuBuffer /* source buffer */, 0 /* source offset */, gpuReadBuffer /* destination buffer */,\n                0 /* destination offset */, bufferSize /* size */\n            );\n            backend.flush();\n\n            await gpuReadBuffer.mapAsync(GPUMapMode.READ);\n\n            const arrayBuffer = gpuReadBuffer.getMappedRange();\n            if (getTargetBuffer) {\n              // if we already have a CPU buffer to accept the data, no need to clone the ArrayBuffer.\n              const targetBuffer = getTargetBuffer();\n              targetBuffer.set(new Uint8Array(arrayBuffer, 0, originalSize));\n              return targetBuffer;\n            } else {\n              // the mapped ArrayBuffer will be released when the GPU buffer is destroyed. Need to clone the\n              // ArrayBuffer.\n              return new Uint8Array(arrayBuffer.slice(0, originalSize));\n            }\n          } finally {\n            gpuReadBuffer.destroy();\n          }\n        };\n\nclass GpuDataManagerImpl implements GpuDataManager {\n  // GPU Data ID => GPU Data ( storage buffer )\n  private storageCache: Map<GpuDataId, StorageCacheValue>;\n\n  // pending buffers for uploading ( data is unmapped )\n  private buffersForUploadingPending: GPUBuffer[];\n  // pending buffers for computing\n  private buffersPending: GPUBuffer[];\n\n  // The reusable storage buffers for computing.\n  private freeBuffers: Map<number, GPUBuffer[]>;\n  // The reusable uniform buffers\n  private freeUniformBuffers: Map<number, GPUBuffer[]>;\n\n  // The external buffers registered users for IO Binding.\n  private externalBuffers: Map<GPUBuffer, GpuDataId>;\n\n  // The pendingBuffers for capture graph.\n  // a SessionID -> GPUBuffer[] mapping.\n  private capturedPendingBuffers: Map<number, GPUBuffer[]>;\n\n  constructor(private backend: WebGpuBackend) {\n    this.storageCache = new Map();\n    this.freeBuffers = new Map();\n    this.freeUniformBuffers = new Map();\n    this.buffersForUploadingPending = [];\n    this.buffersPending = [];\n    this.externalBuffers = new Map();\n    this.capturedPendingBuffers = new Map();\n\n    for (const [key, ] of bucketFreelist) {\n      bucketArr.push(key);\n      this.freeBuffers.set(key, []);\n      this.freeUniformBuffers.set(key, []);\n    }\n  }\n\n  upload(id: GpuDataId, data: Uint8Array): void {\n    const srcArrayBuffer = data.buffer;\n    const srcOffset = data.byteOffset;\n    const srcLength = data.byteLength;\n    const size = calcNormalizedBufferSize(srcLength);\n\n    // get destination gpu buffer\n    const gpuDataCache = this.storageCache.get(id);\n    if (!gpuDataCache) {\n      throw new Error('gpu data for uploading does not exist');\n    }\n    if (gpuDataCache.originalSize !== srcLength) {\n      throw new Error(`inconsistent data size. gpu data size=${gpuDataCache.originalSize}, data size=${srcLength}`);\n    }\n\n    // create gpu buffer\n    const gpuBufferForUploading = this.backend.device.createBuffer(\n        // eslint-disable-next-line no-bitwise\n        {mappedAtCreation: true, size, usage: GPUBufferUsage.MAP_WRITE | GPUBufferUsage.COPY_SRC});\n\n    // copy (upload) data\n    const arrayBuffer = gpuBufferForUploading.getMappedRange();\n    new Uint8Array(arrayBuffer).set(new Uint8Array(srcArrayBuffer, srcOffset, srcLength));\n    gpuBufferForUploading.unmap();\n\n\n    // GPU copy\n    const commandEncoder = this.backend.getCommandEncoder();\n    this.backend.endComputePass();\n    commandEncoder.copyBufferToBuffer(gpuBufferForUploading, 0, gpuDataCache.gpuData.buffer, 0, size);\n\n    LOG_DEBUG('verbose', () => `[WebGPU] GpuDataManager.upload(id=${id})`);\n\n    this.buffersForUploadingPending.push(gpuBufferForUploading);\n  }\n\n  memcpy(sourceId: GpuDataId, destinationId: GpuDataId): void {\n    // get source gpu buffer\n    const sourceGpuDataCache = this.storageCache.get(sourceId);\n    if (!sourceGpuDataCache) {\n      throw new Error('source gpu data for memcpy does not exist');\n    }\n    // get destination gpu buffer\n    const destinationGpuDataCache = this.storageCache.get(destinationId);\n    if (!destinationGpuDataCache) {\n      throw new Error('destination gpu data for memcpy does not exist');\n    }\n    if (sourceGpuDataCache.originalSize !== destinationGpuDataCache.originalSize) {\n      throw new Error('inconsistent source and destination gpu data size');\n    }\n\n    const size = calcNormalizedBufferSize(sourceGpuDataCache.originalSize);\n\n    // GPU copy\n    const commandEncoder = this.backend.getCommandEncoder();\n    this.backend.endComputePass();\n    commandEncoder.copyBufferToBuffer(\n        sourceGpuDataCache.gpuData.buffer, 0, destinationGpuDataCache.gpuData.buffer, 0, size);\n  }\n\n  registerExternalBuffer(buffer: GPUBuffer, originalSize: number, previousBuffer?: GPUBuffer): number {\n    let id: number|undefined;\n    if (previousBuffer) {\n      id = this.externalBuffers.get(previousBuffer);\n      if (id === undefined) {\n        throw new Error('previous buffer is not registered');\n      }\n      if (buffer === previousBuffer) {\n        LOG_DEBUG(\n            'verbose',\n            () => `[WebGPU] GpuDataManager.registerExternalBuffer(size=${originalSize}) => id=${\n                id}, buffer is the same, skip.`);\n        return id;\n      } else if (this.backend.capturedCommandList.has(this.backend.currentSessionId!)) {\n        throw new Error(`Registering a different external buffer under graph capture mode is not supported yet.\n             Please use the previous external buffer!`);\n      }\n      this.externalBuffers.delete(previousBuffer);\n    } else {\n      id = createNewGpuDataId();\n    }\n\n    this.storageCache.set(id, {gpuData: {id, type: GpuDataType.default, buffer}, originalSize});\n    this.externalBuffers.set(buffer, id);\n    LOG_DEBUG(\n        'verbose',\n        () => `[WebGPU] GpuDataManager.registerExternalBuffer(size=${originalSize}) => id=${id}, registered.`);\n    return id;\n  }\n\n  unregisterExternalBuffer(buffer: GPUBuffer): void {\n    const id = this.externalBuffers.get(buffer);\n    if (id !== undefined) {\n      this.storageCache.delete(id);\n      this.externalBuffers.delete(buffer);\n      LOG_DEBUG('verbose', () => `[WebGPU] GpuDataManager.unregisterExternalBuffer() => id=${id}`);\n    }\n  }\n\n  // eslint-disable-next-line no-bitwise\n  create(size: number, usage = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST): GpuData {\n    const bufferSize = calcBucketBufferSize(size);\n\n    let gpuBuffer;\n    // Currently, only storage buffers are reused.\n    // eslint-disable-next-line no-bitwise\n    const isStorage = (usage & GPUBufferUsage.STORAGE) === GPUBufferUsage.STORAGE;\n    // eslint-disable-next-line no-bitwise\n    const isUniform = (usage & GPUBufferUsage.UNIFORM) === GPUBufferUsage.UNIFORM;\n    if (isStorage || isUniform) {\n      const freeBuffers = isStorage ? this.freeBuffers : this.freeUniformBuffers;\n      const buffers = freeBuffers.get(bufferSize);\n      if (!buffers) {\n        // no such bucket/freelist - create gpu buffer\n        gpuBuffer = this.backend.device.createBuffer({size: bufferSize, usage});\n      } else {\n        if (buffers.length > 0) {\n          // in freelist, use it\n          gpuBuffer = buffers.pop() as GPUBuffer;\n        } else {\n          // bucket empty, create gpu buffer\n          gpuBuffer = this.backend.device.createBuffer({size: bufferSize, usage});\n        }\n      }\n    } else {\n      // create gpu buffer\n      gpuBuffer = this.backend.device.createBuffer({size: bufferSize, usage});\n    }\n\n    const gpuData = {id: createNewGpuDataId(), type: GpuDataType.default, buffer: gpuBuffer};\n    this.storageCache.set(gpuData.id, {gpuData, originalSize: size});\n\n    LOG_DEBUG('verbose', () => `[WebGPU] GpuDataManager.create(size=${size}) => id=${gpuData.id}`);\n    return gpuData;\n  }\n\n  get(id: GpuDataId): GpuData|undefined {\n    return this.storageCache.get(id)?.gpuData;\n  }\n\n  release(id: GpuDataId): number {\n    const cachedData = this.storageCache.get(id);\n    if (!cachedData) {\n      throw new Error('releasing data does not exist');\n    }\n\n    LOG_DEBUG('verbose', () => `[WebGPU] GpuDataManager.release(id=${id}), gpuDataId=${cachedData.gpuData.id}`);\n\n    this.storageCache.delete(id);\n    this.buffersPending.push(cachedData.gpuData.buffer);\n    // cachedData.gpuData.buffer.destroy();\n\n    return cachedData.originalSize;\n  }\n\n  async download(id: GpuDataId, getTargetBuffer: () => Uint8Array): Promise<void> {\n    const cachedData = this.storageCache.get(id);\n    if (!cachedData) {\n      throw new Error('data does not exist');\n    }\n    await downloadGpuData(this.backend, cachedData.gpuData.buffer, cachedData.originalSize, getTargetBuffer);\n  }\n\n  refreshPendingBuffers(): void {\n    for (const buffer of this.buffersForUploadingPending) {\n      // upload buffer is only useful in the session creation time. So we don't need to reuse them in session running.\n      buffer.destroy();\n    }\n    this.buffersForUploadingPending = [];\n\n    if (this.buffersPending.length === 0) {\n      return;\n    }\n\n    if (this.backend.sessionStatus === 'default') {\n      for (const buffer of this.buffersPending) {\n        const maxInFreeList = bucketFreelist.get(buffer.size);\n\n        // eslint-disable-next-line no-bitwise\n        if ((buffer.usage & GPUBufferUsage.STORAGE) === GPUBufferUsage.STORAGE) {\n          // Put the pending buffer to freeBuffers list instead of really destroying it for buffer reusing.\n          const freelist = this.freeBuffers.get(buffer.size) || [];\n          if (maxInFreeList === undefined || freelist.length >= maxInFreeList) {\n            buffer.destroy();\n          } else {\n            freelist.push(buffer);\n          }\n          // eslint-disable-next-line no-bitwise\n        } else if ((buffer.usage & GPUBufferUsage.UNIFORM) === GPUBufferUsage.UNIFORM) {\n          // Put the pending buffer to freeUniformBuffers list instead of really destroying it for buffer reusing.\n          const freelist = this.freeUniformBuffers.get(buffer.size) || [];\n          if (maxInFreeList === undefined || freelist.length >= maxInFreeList) {\n            buffer.destroy();\n          } else {\n            freelist.push(buffer);\n          }\n        } else {\n          buffer.destroy();\n        }\n      }\n      this.buffersPending = [];\n    } else {\n      // Don't release intermediate tensors in non-default mode.\n      // TODO: reuse the storage buffers in non-default mode.\n      let capturedBuffers = this.capturedPendingBuffers.get(this.backend.currentSessionId!);\n      if (!capturedBuffers) {\n        capturedBuffers = [];\n        this.capturedPendingBuffers.set(this.backend.currentSessionId!, capturedBuffers);\n      }\n      for (const buffer of this.buffersPending) {\n        capturedBuffers.push(buffer);\n      }\n      this.buffersPending = [];\n    }\n  }\n\n  dispose() {\n    this.freeBuffers.forEach((buffers) => {\n      buffers.forEach(buffer => {\n        buffer.destroy();\n      });\n    });\n    this.freeUniformBuffers.forEach((buffers) => {\n      buffers.forEach(buffer => {\n        buffer.destroy();\n      });\n    });\n\n    this.storageCache.forEach((storage) => {\n      storage.gpuData.buffer.destroy();\n    });\n\n    this.capturedPendingBuffers.forEach((buffers) => {\n      buffers.forEach(buffer => {\n        buffer.destroy();\n      });\n    });\n    this.storageCache = new Map();\n    this.freeBuffers = new Map();\n    this.freeUniformBuffers = new Map();\n    this.capturedPendingBuffers = new Map();\n  }\n\n  onReleaseSession(sessionId: number) {\n    // release the captured pending buffers.\n    const pendingBuffers = this.capturedPendingBuffers.get(sessionId);\n    if (pendingBuffers) {\n      pendingBuffers.forEach(buffer => {\n        buffer.destroy();\n      });\n      this.capturedPendingBuffers.delete(sessionId);\n    }\n  }\n}\n\nexport const createGpuDataManager = (...args: ConstructorParameters<typeof GpuDataManagerImpl>): GpuDataManager =>\n    new GpuDataManagerImpl(...args);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nclass AttributeWithCacheKeyImpl {\n  constructor(attribute: Record<string, unknown>) {\n    Object.assign(this, attribute);\n  }\n\n  private key: string;\n  public get cacheKey(): string {\n    if (!this.key) {\n      this.key =\n          Object.getOwnPropertyNames(this).sort().map(name => `${(this as Record<string, unknown>)[name]}`).join(';');\n    }\n    return this.key;\n  }\n}\n\nexport interface AttributeWithCacheKey {\n  readonly cacheKey: string;\n}\n\n/**\n * create a new object from the given attribute, and add a cacheKey property to it\n */\nexport const createAttributeWithCacheKey = <T extends Record<string, unknown>>(attribute: T): T&AttributeWithCacheKey =>\n    new AttributeWithCacheKeyImpl(attribute) as unknown as T & AttributeWithCacheKey;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/* eslint-disable no-param-reassign */\n\nexport class MatMulUtil {\n  /**\n   * Calculate the expected shape when matrix multiplication\n   * @param a The shape of tensor A. Should be a tuple of 2 positive integers\n   * @param b The shape of tensor B. Should be a tuple of 2 positive integers\n   * @returns The expected shape of the result, or undefined if N/A\n   */\n  static calcMatMulShape(a: [number, number], b: [number, number]): [number, number]|undefined {\n    return (a[1] !== b[0]) ? undefined : [a[0], b[1]];\n  }\n}\n\n\nexport class BroadcastUtil {\n  /**\n   * Calculate the expected shape when broadcasting 2 tensors\n   * @param a The shape of tensor A. Should be an array of positive integers\n   * @param b The shape of tensor B. Should be an array of positive integers\n   * @param isMatMul Whether the operation is MatMul\n   * @returns The expected shape of the result, or undefined if N/A\n   */\n  static calcShape(adims: readonly number[], bdims: readonly number[], isMatMul = false): readonly number[]|undefined {\n    const arank = adims.length;\n    const brank = bdims.length;\n    if (arank === 0) {\n      return bdims;\n    }\n    if (brank === 0) {\n      return adims;\n    }\n    const crank = Math.max(adims.length, bdims.length);\n    const cdims = new Array<number>(crank);\n\n    // calculate the last 2 dimension if it is MatMul\n    if (isMatMul) {\n      if (arank < 2 || brank < 2) {\n        return undefined;\n      }\n      const cShapeMatMul =\n          MatMulUtil.calcMatMulShape([adims[arank - 2], adims[arank - 1]], [bdims[brank - 2], bdims[brank - 1]]);\n      if (cShapeMatMul === undefined) {\n        return undefined;\n      }\n      [cdims[crank - 2], cdims[crank - 1]] = cShapeMatMul;\n    }\n\n    for (let i = isMatMul ? 3 : 1; i <= crank; i++) {\n      const aLen = arank - i < 0 ? 1 : adims[arank - i];\n      const bLen = brank - i < 0 ? 1 : bdims[brank - i];\n\n      if (aLen !== bLen && aLen > 1 && bLen > 1) {\n        return undefined;\n      }\n      const max = Math.max(aLen, bLen);\n      if (aLen && bLen) {\n        cdims[crank - i] = Math.max(aLen, bLen);\n      } else {\n        // when either aLen or bLen is 0, the other should be either 0 or 1, otherwise it is not broadcastable.\n        if (max > 1) {\n          return undefined;\n        }\n        cdims[crank - i] = 0;\n      }\n    }\n\n    return cdims;\n  }\n\n  /**\n   * Determine if a shape is unidirectional broadcastable to another shape\n   * @param shape The input shape\n   * @param finalShape The desired shape after broadcasting\n   */\n  static isValidBroadcast(shape: readonly number[], finalShape: readonly number[]): boolean {\n    // align shape to the right\n    const inputRank = shape.length;\n    const finalRank = finalShape.length;\n    if (inputRank > finalRank) {\n      return false;\n    }\n    for (let i = 1; i <= inputRank; i++) {\n      if (shape[inputRank - i] !== 1 && shape[inputRank - i] !== finalShape[finalRank - i]) {\n        return false;\n      }\n    }\n    return true;\n  }\n}\n\n\nexport class ShapeUtil {\n  /**\n   * calculate the size (number of elements)\n   */\n  static size(dims: readonly number[]): number {\n    return ShapeUtil.getSizeFromDimensionRange(dims, 0, dims.length);\n  }\n\n  /**\n   * convert dims corresponding to type change to pack. ex. uint8 data to uint32\n   */\n  static convertShape(dims: readonly number[], size = 4): readonly number[] {\n    const rank = dims.length;\n    if (rank === 0) {\n      return [];\n    }\n    const newDims = new Array(rank);\n    let i = rank - 1;\n    while (i >= 0) {\n      if (dims[i] % size === 0) {\n        newDims[i] = dims[i] / size;\n        break;\n      }\n      if (size % dims[i] !== 0) {\n        throw new Error('cannot convert shape');\n      }\n      newDims[i] = 1;\n      size /= dims[i];\n      i--;\n    }\n    for (i--; i >= 0; i--) {\n      newDims[i] = dims[i];\n    }\n    return newDims;\n  }\n\n  /**\n   * calculate the size (number of elements) from the given axis (inclusive)\n   */\n  static sizeFromDimension(dims: readonly number[], axis: number): number {\n    if (axis < 0 || axis > dims.length) {\n      throw new Error(`invalid dimension of ${axis} for sizeFromDimension as Tensor has ${dims.length} dimensions.`);\n    }\n    return ShapeUtil.getSizeFromDimensionRange(dims, axis, dims.length);\n  }\n\n  /**\n   * calculate the size (number of elements) to the given axis (exclusive)\n   */\n  static sizeToDimension(dims: readonly number[], axis: number): number {\n    if (axis < 0 || axis > dims.length) {\n      throw new Error(`invalid dimension of ${axis} for sizeToDimension as Tensor has ${dims.length} dimensions.`);\n    }\n    return ShapeUtil.getSizeFromDimensionRange(dims, 0, axis);\n  }\n\n  /**\n   * calculate the size (number of elements) from and to the given axis [start, end)\n   */\n  static getSizeFromDimensionRange(dims: readonly number[], start: number, end: number): number {\n    let size = 1;\n    for (let i = start; i < end; i++) {\n      // safety check as this method is called by multiple other methods requiring size.\n      // size cannot be negative.\n      if (dims[i] < 0) {\n        throw new Error(\n            // eslint-disable-next-line max-len\n            'cannot get valid size from specified dimension range. Most likely the range contains negative values in them.');\n      }\n      size *= dims[i];\n    }\n    return size;\n  }\n\n  static computeStrides(dims: readonly number[]): readonly number[] {\n    const rank = dims.length;\n    if (rank === 0) {\n      return [];\n    } else if (rank === 1) {\n      return [1];\n    }\n    const strides = new Array(rank);\n    strides[rank - 1] = 1;\n    strides[rank - 2] = dims[rank - 1];\n    for (let i = rank - 3; i >= 0; --i) {\n      strides[i] = strides[i + 1] * dims[i + 1];\n    }\n    return strides;\n  }\n\n  /**\n   * normailze axis of range [-r, r) into [0, r).\n   */\n  static normalizeAxis(axis: number, tensorRank: number): number {\n    if (axis < -tensorRank && axis >= tensorRank) {\n      throw new Error('unsupported axis for this operation.');\n    }\n    return axis < 0 ? axis + tensorRank : axis;\n  }\n\n  static normalizeAxes(axes: readonly number[], tensorRank?: number): number[] {\n    return axes.map(x => this.normalizeAxis(x, tensorRank ?? axes.length));\n  }\n\n  /**\n   * Sorts a given array based on the indices in the Perm array\n   * Used in Transpose\n   * @param a Array to be sorted such as dims or strides\n   * @param perm Perm given; if null a will be reversed\n   */\n  static sortBasedOnPerm(a: readonly number[], perm?: readonly number[]): readonly number[] {\n    if (perm) {\n      return perm.map((v) => a[v]);\n    } else {\n      return a.slice().reverse();\n    }\n  }\n\n  /**\n   * Pads a given shape according to the padding values\n   * @param dims shape of the Tensor to be padded\n   * @param pad pad values\n   */\n  static padShape(dims: readonly number[], pad: readonly number[]): readonly number[] {\n    const rank = dims.length;\n    return dims.map((v, i) => v + pad[i] + pad[i + rank]);\n  }\n\n  /**\n   * Determines if the two shapes are identical\n   * @param shape1\n   * @param shape2\n   */\n  static areEqual(shape1: readonly number[], shape2: readonly number[]): boolean {\n    if (shape1.length !== shape2.length) {\n      return false;\n    }\n    return shape1.every((v, i) => v === shape2[i]);\n  }\n}\n\nexport class PoolConvUtil {\n  /**\n   * Adjust the kernel, strides, pads to correct rank. Set to default value if not present\n   * @param isGlobalOperator If true, perform global pooling.\n   * @param inputDims The input tensor dimension.\n   * @param kernelShape The size of the kernel along each axis.\n   * @param strides Stride along each axis.\n   * @param dilations Dilation along each axis.\n   * @param pads Padding for the beginning and ending along each axis.\n   */\n  static adjustPoolAttributes(\n      isGlobalOperator: boolean, inputDims: readonly number[], kernelShape: number[], strides: number[],\n      dilations: number[], pads: number[]): void {\n    if (!isGlobalOperator && kernelShape.length !== inputDims.length - 2) {\n      throw new Error('length of specified kernel shapes should be 2 less than length of input dimensions');\n    }\n\n    if (isGlobalOperator) {\n      // adjust kernel shape to cover the input dims\n      for (let dim = 0; dim < inputDims.length - 2; dim++) {\n        if (dim >= kernelShape.length) {\n          kernelShape.push(inputDims[dim + 2]);\n        } else {\n          kernelShape[dim] = inputDims[dim + 2];\n        }\n      }\n    }\n\n    // adjust strides length to match kernel shape length\n    for (let dim = 0; dim < kernelShape.length; dim++) {\n      if (dim < strides.length) {\n        if (strides[dim] < 0) {\n          throw new Error('strides should be greater than or equal to 1');\n        }\n      } else {\n        strides.push(1);\n      }\n    }\n\n    // adjust dilation value\n    for (let dim = 0; dim < kernelShape.length; dim++) {\n      if (dim < dilations.length) {\n        if (dilations[dim] < 0) {\n          throw new Error('dilations should be greater than or equal to 1');\n        }\n      } else {\n        dilations.push(1);\n      }\n    }\n\n    // adjust pads length to match 2 * kernel shape length\n    for (let dim = 0; dim < kernelShape.length * 2; dim++) {\n      if (dim < pads.length) {\n        if (pads[dim] < 0) {\n          throw new Error('pad should be greater than or equal to 1');\n        }\n      } else {\n        pads.push(0);\n      }\n    }\n\n    // sanity checks for values in kernel shapes and pads\n    for (let dim = 0; dim < kernelShape.length; dim++) {\n      if (kernelShape[dim] <= 0) {\n        throw new Error('kernel shapes need to be greater than 0');\n      }\n\n      if (pads[dim] >= kernelShape[dim] || pads[dim + kernelShape.length] >= kernelShape[dim]) {\n        throw new Error('pads should be smaller than kernel');\n      }\n    }\n  }\n\n  // adjust pad values based on 'autoPad' attribute\n  static adjustPadsBasedOnAutoPad(\n      inputDims: readonly number[], strides: readonly number[], dilations: readonly number[],\n      kernelShape: readonly number[], pads: number[], isChannelLast: boolean, autoPad?: string): void {\n    if (!autoPad) {\n      return;\n    }\n\n    if (pads.length !== 2 * (inputDims.length - 2)) {\n      throw new Error('length of pads should be twice the length of data dimensions');\n    }\n\n    if (strides.length !== (inputDims.length - 2)) {\n      throw new Error('length of strides should be the length of data dimensions');\n    }\n\n    if (kernelShape.length !== (inputDims.length - 2)) {\n      throw new Error('length of kernel shapes should be the length of data dimensions');\n    }\n\n    for (let dim = 0; dim < inputDims.length - 2; dim++) {\n      PoolConvUtil.adjustPadAndReturnShape(\n          inputDims[dim + (isChannelLast ? 1 : 2)], strides[dim], dilations[dim], kernelShape[dim], pads, dim,\n          dim + inputDims.length - 2, autoPad);\n    }\n  }\n\n  /**\n   * Calculate the output shape for Pool ops based on input attributes. (Should be used only for Pool ops)\n   * @param isGlobalOperator If true, perform global pooling.\n   * @param inputDims The input tensor dimension. (inputs[0].dims)\n   * @param strides Stride along each axis.\n   * @param dilations Dilation along each axis.\n   * @param kernelShape The size of the kernel along each axis.\n   * @param pads Padding for the beginning and ending along each axis.\n   * @param autoPad DEPRECATED attribute supported for legacy models. Specifies how to implicitly calculate pads in each\n   *     dimension. Can take values NOTSET, SAME_UPPER, SAME_LOWER, or VALID.\n   */\n  static computePoolOutputShape(\n      isGlobalOperator: boolean, inputDims: readonly number[], strides: number[], dilations: number[],\n      kernelShape: number[], pads: number[], autoPad?: string): number[] {\n    if (inputDims.length <= 0) {\n      throw new Error('input shape must be of size greater than 0');\n    }\n\n    // Add batch size and number of channels of output\n    const outputDims = [inputDims[0], inputDims[1]];\n\n    PoolConvUtil.computeShapeHelper(\n        isGlobalOperator, inputDims, outputDims, strides, dilations, kernelShape, pads, autoPad);\n    return outputDims;\n  }\n\n  /**\n   * Calculate the output shape for Conv op based on input attributes. (Should be used only for Conv op)\n   * @param inputDims The input tensor dimension. (inputs[0].dims)\n   * @param filterDims The filter tensor dimension. (inputs[1].dims)\n   * @param strides Stride along each axis.\n   * @param kernelShape The size of the kernel along each axis.\n   * @param pads Padding for the beginning and ending along each axis.\n   * @param autoPad DEPRECATED attribute supported for legacy models. Specifies how to implicitly calculate pads in each\n   *     dimension. Can take values NOTSET, SAME_UPPER, SAME_LOWER, or VALID.\n   */\n  static computeConvOutputShape(\n      inputDims: readonly number[], filterDims: readonly number[], strides: number[], dilations: number[],\n      kernelShape: number[], pads: number[], autoPad?: string): number[] {\n    if (inputDims.length <= 0 || filterDims.length <= 0) {\n      throw new Error('invalid input tensor dims or invalid filter tensor dims');\n    }\n\n    // Add batch size and number of channels of output\n    const outputDims = [inputDims[0], filterDims[0]];\n\n    PoolConvUtil.computeShapeHelper(false, inputDims, outputDims, strides, dilations, kernelShape, pads, autoPad);\n    return outputDims;\n  }\n\n  // will compute output shapes for data dimensions ONLY (i.e.) no batch size and channels\n  // called by computePoolOutputShape() and computeConvOutputShape()\n  // adjust pads based on 'autoPad' attribute prior to shape computation\n  private static computeShapeHelper(\n      isGlobalOperator: boolean, inputDims: readonly number[], outputDims: number[], strides: readonly number[],\n      dilations: readonly number[], kernelShape: readonly number[], pads: number[], autoPad?: string) {\n    if (isGlobalOperator) {\n      for (let dim = 0; dim < inputDims.length - 2; dim++) {\n        outputDims.push(1);\n      }\n    } else {\n      for (let dim = 0; dim < inputDims.length - 2; dim++) {\n        outputDims.push(PoolConvUtil.adjustPadAndReturnShape(\n            inputDims[dim + 2], strides[dim], dilations[dim], kernelShape[dim], pads, dim, dim + inputDims.length - 2,\n            autoPad));\n      }\n    }\n  }\n\n  // helper for computeShapeHelper() and adjustPadsBasedOnAutoPad()\n  // adjusts pad value for given 'autoPad' string and computes output shape along a particular dimension\n  private static adjustPadAndReturnShape(\n      inSize: number, stride: number, dilation: number, kernel: number, pads: number[], padHeadIndex: number,\n      padTailIndex: number, autoPad?: string): number {\n    const dkernel = dilation * (kernel - 1) + 1;\n    if (autoPad && autoPad !== 'NOTSET') {\n      switch (autoPad) {\n        case 'VALID':\n          pads[padHeadIndex] = 0;\n          pads[padTailIndex] = 0;\n          return Math.floor(((inSize - dkernel) / stride) + 1);\n        case 'SAME_LOWER':\n        case 'SAME_UPPER':\n          if (dilation !== 1) {\n            throw new Error('Dilation not supported for SAME_UPPER or SAME_LOWER');\n          } else {\n            const legacyTargetSize = (inSize + stride - 1) / stride;\n            const padNeeded = (legacyTargetSize - 1) * stride + kernel - inSize;\n            pads[padHeadIndex] =\n                (autoPad === 'SAME_LOWER') ? Math.floor((padNeeded + 1) / 2) : Math.floor(padNeeded / 2);\n            pads[padTailIndex] = padNeeded - pads[padHeadIndex];\n            return Math.floor(((inSize + padNeeded - kernel) / stride) + 1);\n          }\n        default:\n          throw new Error('Unsupported AutoPad type');\n      }\n    } else {\n      return Math.floor(((inSize + pads[padHeadIndex] + pads[padTailIndex] - dkernel) / stride) + 1);\n    }\n  }\n}\n\nexport class GemmUtil {\n  // will make sure input shapes are compatible for this op\n  // and return back the shape of the output in the form of a tuple\n  // will throw exception if the input shapes are not compatible\n  static getShapeOfGemmResult(\n      leftShape: readonly number[], transLeft: boolean, rightShape: readonly number[], transRight: boolean,\n      biasShape?: readonly number[]): readonly number[] {\n    if (leftShape.length !== 2 || rightShape.length !== 2) {\n      throw new Error('shape need to be of size 2');\n    }\n\n    let M: number;\n    let K: number;\n    let N: number;\n\n    if (transLeft) {\n      M = leftShape[1];\n      K = leftShape[0];\n    } else {\n      M = leftShape[0];\n      K = leftShape[1];\n    }\n\n    let kDim = -1;\n\n    if (transRight) {\n      N = rightShape[0];\n      kDim = 1;\n    } else {\n      N = rightShape[1];\n      kDim = 0;\n    }\n\n    if (rightShape[kDim] !== K) {\n      throw new Error('dimension mismatch');\n    }\n\n    if (M <= 0 || N <= 0 || K <= 0) {\n      throw new Error('invalid shape specified');\n    }\n\n    if (biasShape && !BroadcastUtil.isValidBroadcast(biasShape, [M, N])) {\n      throw new Error('gemm: invalid bias shape for broadcast');\n    }\n\n    return [M, N, K];\n  }\n}\n\n\nexport const MIN_CLIP = -3.4028234663852886e+38;\nexport const MAX_CLIP = 3.4028234663852886e+38;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {ShapeUtil} from '../../util';\nimport {ProgramUniform, ProgramUniformVariableInfo} from '../types';\n\n/**\n * constant value for a workgroup size.\n *\n * We definitely can do further optimization in future, but for now we use 64.\n *\n * rule of thumb: Use [a workgroup size of] 64 unless you know what GPU you are targeting or that your workload\n *                needs something different.\n *\n * from: https://surma.dev/things/webgpu/\n **/\nexport const WORKGROUP_SIZE = 64;\n\ninterface IndicesHelperTypes {\n  /**\n   * WGSL type of indices expression\n   */\n  readonly indices: string;\n\n  /**\n   * WGSL type of a value\n   */\n  readonly value: string;\n\n  /**\n   * WGSL type of storage type representing a value\n   *\n   * This is usually the same to `value`, but for some type (eg. bool), we need to use `u32` as storage type for\n   * value type `vec4<bool>`\n   */\n  readonly storage: string;\n\n  /**\n   * tensor type as represented in TensorView\n   */\n  readonly tensor: number;\n}\n\n/**\n * A helper class for generating WGSL code for manipulating indices and data for a shader's input or output.\n *\n * This class is designed to offer a unified way to generate WGSL code for manipulating indices and data for a shader's\n * input or output.\n *\n * The following is a list of terminologies used in this class:\n * - `offset`: a uint32 value representing the offset of an element in the data buffer.\n * - `indices`: an abstraction of a multi-dimensional array's indices representing the data's index on each dimension.\n * - `value`: a value of a data element.\n *\n * Users are expected to create an instance of this class for each shader's input or output, and use the instance to\n * generate WGSL code for manipulating indices and data. The following 2 exported functions are for users to call to\n * create an instance of an indices helper:\n * - `inputVariable()`: create an indices helper instance for an input.\n * - `outputVariable()`: create an indices helper instance for an output.\n * - `internalVariable()`: create an indices helper instance for an internal variable.\n *\n * An indices helper instance contains helper functions for the following operations:\n * - access readonly basic information, including: `name`(the name of the input or output), `usage`(whether it's an\n * input, an output or an internal variable) and `shape`(the passed in shape).\n * - `type`: access readonly type information, including: `indices`(the type of indices), `value`(the type of value at\n * runtime), `storage`(the type of value at storage) and `tensor`(the tensor type as represented in TensorView).\n * - generate WGSL code for getting indices from offset. Use `offsetToIndices()` for WGSL code snippet to calculate\n * indices from offset, and use `indicesToOffset()` for WGSL code snippet to calculate offset from indices.\n * - to manipulate an instance of indices, use `setIndices()` and `getIndices()` to set and get the indices on an\n * indices variable.\n * - to manipulate data, use `set()`/`get()` to access data at the given indices from parameter list, use\n * `setByIndices()`/`getByIndices()` to access data at the given indices from an indices variable, and use\n * `setByOffset()`/`getByOffset()` to access data at the given offset.\n * - `impl`: get WGSL code of function implementation for the util functions mentioned above.\n */\nexport interface IndicesHelper {\n  /**\n   * get WGSL code of function implementation for the util functions.\n   *\n   */\n  readonly impl: () => string;\n\n  /**\n   * get type info\n   */\n  readonly type: IndicesHelperTypes;\n\n  /**\n   * WGSL code of a expression for getting indices from offset.\n   *\n   * @param varOffset - a u32 expression representing the offset.\n   *\n   * @returns an `type.indices` expression\n   */\n  readonly offsetToIndices: (varOffset: string) => string;\n\n  /**\n   * WGSL code of an `u32` expression for getting offset from indices.\n   *\n   * @param varIndices - a `type.indices` expression representing the indices.\n   *\n   * @returns an `u32` expression\n   */\n  readonly indicesToOffset: (varIndices: string) => string;\n\n  /**\n   * WGSL code of an `u32` expression for getting original offset from broadcasted indices.\n   *\n   * @param varIndices - a `type.indices` expression representing the output indices.\n   * @param output - output IndicesHelper.\n   *\n   * @returns an `u32` expression\n   */\n  readonly broadcastedIndicesToOffset: (varIndices: string, output: IndicesHelper) => string;\n\n  /**\n   * WGSL code of generating an indices literal\n   *\n   * @param init - initial value.\n   */\n  readonly indices: (...init: ReadonlyArray<number|string>) => string;\n\n  /**\n   * WGSL code of a statement for setting indices.\n   *\n   * @param varIndices - a variable name for the indices.\n   * @param idx - the index of the indices to set. can be a number or a string (WGSL `u32` expression).\n   * @param value - the value to set. can be a number or a string (WGSL `u32` expression).\n   *\n   * @returns a WGSL statement\n   */\n  readonly indicesSet: (varIndices: string, idx: number|string, value: number|string) => void;\n\n  /**\n   * WGSL code of an `u32` expression for getting indices.\n   *\n   * @param varIndices - a variable name for the indices.\n   * @param idx - the index of the indices to get. can be a number or a string (WGSL `u32` expression).\n   *\n   * @returns an `u32` expression\n   */\n  readonly indicesGet: (varIndices: string, idx: number|string) => string;\n\n  /**\n   * WGSL code for a statement for setting data at the given indices.\n   *\n   * @param indicesAndValue - an array of numbers or strings (WGSL `u32` expression) representing the indices, followed\n   *     by the value to set. This array should have exactly `shape.length + 1` elements.\n   */\n  readonly set: (...indicesAndValue: ReadonlyArray<number|string>) => string;\n\n  /**\n   * WGSL code for a statement for setting data at the given indices variable.\n   *\n   * @param varIndices - a variable name for the indices.\n   * @param value - the value to set. should be a WGSL expression.\n   */\n  readonly setByIndices: (varIndices: string, value: string) => string;\n\n  /**\n   * WGSL code for a statement for setting data at the given offset.\n   *\n   * @param offset - a number or a string (WGSL `u32` expression) representing the offset.\n   * @param value - the value to set. should be a WGSL expression.\n   */\n  readonly setByOffset: (offset: number|string, value: string) => string;\n\n  /**\n   * WGSL code for an expression for getting data at the given indices.\n   *\n   * @param indices - an array of numbers or strings (WGSL `u32` expression) representing the indices.\n   */\n  readonly get: (...indices: ReadonlyArray<number|string>) => string;\n\n  /**\n   * WGSL code for an expression for getting data at the given indices variable.\n   *\n   * @param varIndices - a variable name for the indices.\n   */\n  readonly getByIndices: (varIndices: string) => string;\n\n  /**\n   * WGSL code for an expression for getting data at the given offset.\n   *\n   * @param offset - a number or a string (WGSL `u32` expression) representing the offset.\n   */\n  readonly getByOffset: (offset: number|string) => string;\n\n  /**\n   * name of the data variable\n   */\n  readonly name: string;\n\n  /**\n   * whether the helper is for an input, an output or an internal variable.\n   */\n  readonly usage: 'input'|'output'|'internal';\n\n  /**\n   * the rank of the input or output.\n   */\n  readonly rank: number;\n\n  /**\n   * a string representing the variable name for the shape of the input or output.\n   */\n  readonly shape: string;\n\n  /**\n   * a string representing the variable name for the strides of the input or output.\n   */\n  readonly strides: string;\n}\n\nconst getWgslMappedType = (type: number, components: 1|2|3|4): string|[string, string] => {\n  if (components === 3) {\n    throw new Error('vec3 has same alignment as vec4, use vec4 instead');\n  }\n\n  // return type is [ storage type, runtime type ] or a single string for both\n  switch (type) {\n    case DataType.float16:\n      return components > 1 ? `vec${components}<f16>` : 'f16';\n    case DataType.float:\n      return components > 1 ? `vec${components}<f32>` : 'f32';\n    case DataType.int32:\n      return components > 1 ? `vec${components}<i32>` : 'i32';\n    case DataType.uint32:\n      return components > 1 ? `vec${components}<u32>` : 'u32';\n    case DataType.int64:\n      if (components > 1) {\n        throw new Error('currently not supported vecX of uint64 yet');\n      }\n      return ['vec2<u32>', 'i32'];\n    case DataType.uint64:\n      if (components > 1) {\n        throw new Error('currently not supported vecX of uint64 yet');\n      }\n      return ['vec2<u32>', 'u32'];\n    case DataType.bool:\n      if (components !== 4) {\n        throw new Error('bool must be vec4');\n      }\n      return ['u32', 'vec4<bool>'];\n\n    default:\n      throw new Error(`Unknown data type: ${type}`);\n  }\n};\n\nexport const tensorTypeToWsglStorageType = (type: DataType, components: 1|2|3|4 = 1) => {\n  const mappedType = getWgslMappedType(type, components);\n  return typeof mappedType === 'string' ? mappedType : mappedType[0];\n};\n\nexport const tensorTypeToWsglValueType = (type: DataType, components: 1|2|3|4 = 1) => {\n  const mappedType = getWgslMappedType(type, components);\n  return typeof mappedType === 'string' ? mappedType : mappedType[1];\n};\n\nexport const createTensorShapeVariables = (...dims: ReadonlyArray<readonly number[]>): ProgramUniform[] => {\n  const programUniforms: ProgramUniform[] = [];\n  dims.forEach(dim => {\n    if (dim.length !== 0) {\n      programUniforms.push(\n          {type: DataType.uint32, data: dim}, {type: DataType.uint32, data: ShapeUtil.computeStrides(dim)});\n    }\n  });\n  return programUniforms;\n};\n\n/**\n * A helper function to get maximum vector size for specified data length\n * @param size\n */\nexport const getMaxComponents = (size: number) => {\n  // we cannot use vec3 type since it has alignment of 16 bytes\n  if (size % 4 === 0) {\n    return 4;\n  } else if (size % 2 === 0) {\n    return 2;\n  }\n\n  return 1;\n};\n\n/**\n * A helper function that initializes variable as a scalar or vector. e.g. f32(0) or vec4f(0,0,0,0)\n * @param dataType\n * @param components\n * @param value\n */\nexport const fillVector = (dataType = 'f32', components?: number, value = '0') => {\n  if (!components || components === 1) {\n    return `${dataType}(${value})`;\n  }\n\n  return `vec${components}<${dataType}>(${value})`;\n};\n\n/**\n * A helper function that casts value or vector to f32\n * @param dataType\n * @param components\n * @param value\n */\nexport const castToF32 = (dataType: string, components: number, value: string) => {\n  if (dataType === 'f32') {\n    return value;\n  }\n  if (components === 1) {\n    return `f32(${value})`;\n  }\n\n  return `vec${components}<f32>(${value})`;\n};\n\n/**\n * A helper function that returns scalar or sums all components of a vector\n * @param name\n * @param components\n */\nexport const sumVector = (name: string, components: number) => {\n  if (components === 4) {\n    return `(${name}.x + ${name}.y + ${name}.z + ${name}.w)`;\n  } else if (components === 2) {\n    return `(${name}.x + ${name}.y)`;\n  } else if (components === 3) {\n    return `(${name}.x + ${name}.y + ${name}.z)`;\n  }\n\n  return name;\n};\n\n/**\n * A helper function that returns variable element at index.\n * @param name - the name of variable.\n * @param index - the index of variable element.\n * @param length - the length of variable.\n * @param type - the type of variable, optional.\n */\nexport const getElementAt =\n    (name: string, index: number|string, length: number, type?: UniformDataElementType): string => {\n      if (name.startsWith('uniforms.') && length > 4) {\n        if (typeof (index) === 'string') {\n          if (type === 'f16') {\n            return `${name}[(${index}) / 8][(${index}) % 8 / 4][(${index}) % 8 % 4]`;\n          } else {\n            return `${name}[(${index}) / 4][(${index}) % 4]`;\n          }\n        } else {\n          if (type === 'f16') {\n            return `${name}[${Math.floor(index / 8)}][${Math.floor(index % 8 / 4)}][${index % 8 % 4}]`;\n          } else {\n            return `${name}[${Math.floor(index / 4)}][${index % 4}]`;\n          }\n        }\n      } else {\n        return length > 1 ? `${name}[${index}]` : name;\n      }\n    };\n\n/**\n * A helper function to get a IndicesHelper for a given input or output.\n *\n * @param name - the name of the input or output.\n * @param tensorType - the tensor type of the input or output.\n * @param shapeOrRank - the tensor shape or the rank of the input or output.\n * @param usage - the usage of the indices helper.\n * @param components - indicates the number of components of each element. 1 for scalar, 2 for vec2, 3 for vec3, 4 for\n *    vec4.\n */\nconst createIndicesHelper =\n    (name: string, tensorType: number, shapeOrRank: number|readonly number[], usage: IndicesHelper['usage'],\n     components: 1|2|3|4): IndicesHelper => {\n      const useUniform = typeof shapeOrRank === 'number';\n      const rank = useUniform ? shapeOrRank : shapeOrRank.length;\n      const rankIdentity = [...new Array(rank).keys()];\n      const indicesType = rank < 2 ? 'u32' : rank <= 4 ? `vec${rank}<u32>` : `array<u32, ${rank}>`;\n      const mappedType = getWgslMappedType(tensorType, components);\n      const valueType = typeof mappedType === 'string' ? mappedType : mappedType[1];\n      const storageType = typeof mappedType === 'string' ? mappedType : mappedType[0];\n      const type = {indices: indicesType, value: valueType, storage: storageType, tensor: tensorType};\n\n      const normalizeDim = (dim: number|string): string => typeof dim === 'string' ? dim : `${dim}u`;\n\n      const implementationUsed = {\n        offsetToIndices: false,\n        indicesToOffset: false,\n        broadcastedIndicesToOffset: false,\n        set: false,\n        setByIndices: false,\n        get: false,\n        getByIndices: false,\n      };\n\n      const uniformPrefix = useUniform ? 'uniforms.' : '';\n      const shape = `${uniformPrefix}${name}_shape`;\n      const strides = `${uniformPrefix}${name}_strides`;\n\n      let o2iSnippet = '';\n      for (let i = 0; i < rank - 1; i++) {\n        o2iSnippet += `\n    let dim${i} = current / ${getElementAt(strides, i, rank)};\n    let rest${i} = current % ${getElementAt(strides, i, rank)};\n    indices[${i}] = dim${i};\n    current = rest${i};\n    `;\n      }\n      o2iSnippet += `indices[${rank - 1}] = current;`;\n\n      const offsetToIndicesImplementation = rank < 2 ? '' : `\n  fn o2i_${name}(offset: u32) -> ${type.indices} {\n    var indices: ${type.indices};\n    var current = offset;\n    ${o2iSnippet}\n    return indices;\n  }`;\n\n      const offsetToIndices = (varOffset: string) => {\n        implementationUsed.offsetToIndices = true;\n        return rank < 2 ? varOffset : `o2i_${name}(${varOffset})`;\n      };\n\n      const offsets: string[] = [];\n      if (rank >= 2) {\n        for (let i = rank - 1; i >= 0; i--) {\n          offsets.push(`${getElementAt(strides, i, rank)} * (indices[${i}])`);\n        }\n      }\n\n      const indicesToOffsetImplementation = rank < 2 ? '' : `\n  fn i2o_${name}(indices: ${type.indices}) -> u32 {\n    return ${offsets.join('+')};\n  }`;\n\n      const indicesToOffset = (varIndices: string) => {\n        implementationUsed.indicesToOffset = true;\n        return rank < 2 ? varIndices : `i2o_${name}(${varIndices})`;\n      };\n\n      const indices = (...init: ReadonlyArray<number|string>) =>\n          rank === 0 ? '0u' : `${type.indices}(${init.map(normalizeDim).join(',')})`;\n\n      const indicesGet = (varIndices: string, idx: number|string) => {\n        if (rank < 2) {\n          return `${varIndices}`;\n        } else {\n          return `${getElementAt(varIndices, idx, rank)}`;\n        }\n      };\n\n      const indicesSet = (varIndices: string, idx: number|string, value: string) => {\n        if (rank < 2) {\n          return `${varIndices}=${value};`;\n        } else {\n          return `${getElementAt(varIndices, idx, rank)}=${value};`;\n        }\n      };\n\n      const broadcastedIndicesToOffsetImplementation: {[key: string]: string} = {};\n      const broadcastedIndicesToOffset = (varIndices: string, output: IndicesHelper) => {\n        implementationUsed.broadcastedIndicesToOffset = true;\n        const implKey = `${output.name}broadcastedIndicesTo${name}Offset`;\n        if (implKey in broadcastedIndicesToOffsetImplementation) {\n          return `${implKey}(${varIndices})`;\n        }\n        const offsets = [];\n        for (let i = rank - 1; i >= 0; i--) {\n          const idx = output.indicesGet('outputIndices', i + output.rank - rank);\n          offsets.push(`${indicesGet(strides, i)} * (${idx} % ${indicesGet(shape, i)})`);\n        }\n        broadcastedIndicesToOffsetImplementation[implKey] =\n            `fn ${implKey}(outputIndices: ${output.type.indices}) -> u32 {\n             return ${offsets.length > 0 ? offsets.join('+') : '0u'};\n           }`;\n\n        return `${implKey}(${varIndices})`;\n      };\n\n      const setByOffset = (offset: number|string, value: string) => (() => {\n        if (type.storage === type.value) {\n          return `${name}[${offset}]=${value};`;\n        } else if (type.storage === 'vec2<u32>' && type.value === 'i32') {\n          // int64, components === 1\n          return `${name}[${offset}]=vec2<u32>(u32(${value}), select(0u, 0xFFFFFFFFu, ${value} < 0));`;\n        } else if (type.storage === 'vec2<u32>' && type.value === 'u32') {\n          // uint64, components === 1\n          return `${name}[${offset}]=vec2<u32>(u32(${value}), 0u);`;\n        } else if (type.storage === 'u32' && type.value === 'vec4<bool>') {\n          // bool, components === 4\n          return `${name}[${offset}]=dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(${value}));`;\n        } else {\n          throw new Error(`not supported combination of storage type ${type.storage} and value type ${type.value} yet`);\n        }\n      })();\n\n      const getByOffset = (offset: number|string) => (() => {\n        if (type.storage === type.value) {\n          return `${name}[${offset}]`;\n        } else if (type.storage === 'vec2<u32>' && type.value === 'i32') {\n          // int64, components === 1\n          return `i32(${name}[${offset}].x)`;\n        } else if (type.storage === 'vec2<u32>' && type.value === 'u32') {\n          // uint64, components === 1\n          return `u32(${name}[${offset}].x)`;\n        } else if (type.storage === 'u32' && type.value === 'vec4<bool>') {\n          // bool, components === 4\n          return `vec4<bool>(bool(${name}[${offset}] & 0xFFu), bool(${name}[${offset}] & 0xFF00u), bool(${name}[${\n              offset}] & 0xFF0000u), bool(${name}[${offset}] & 0xFF000000u))`;\n        } else {\n          throw new Error(`not supported combination of storage type ${type.storage} and value type ${type.value} yet`);\n        }\n      })();\n\n      const getByIndicesImplementation = rank < 2 ? '' : `\n  fn get_${name}ByIndices(indices: ${type.indices}) -> ${valueType} {\n    return ${getByOffset(`i2o_${name}(indices)`)};\n  }`;\n\n      const getImplementation = rank < 2 ? '' : (() => {\n        const functionParams = rankIdentity.map(i => `d${i}: u32`).join(', ');\n        const dimsParams = rankIdentity.map(i => `d${i}`).join(', ');\n        return `\n  fn get_${name}(${functionParams}) -> ${valueType} {\n    return get_${name}ByIndices(${indices(dimsParams)});\n  }`;\n      })();\n\n      const get = (...indices: ReadonlyArray<number|string>) => {\n        if (indices.length !== rank) {\n          throw new Error(`indices length must be ${rank}`);\n        }\n\n        const normalizedIndices = indices.map(normalizeDim).join(',');\n\n        if (rank === 0) {\n          return getByOffset('0u');\n        } else if (rank === 1) {\n          return getByOffset(normalizedIndices[0]);\n        } else {\n          implementationUsed.get = true;\n          implementationUsed.getByIndices = true;\n          implementationUsed.indicesToOffset = true;\n          return `get_${name}(${normalizedIndices})`;\n        }\n      };\n\n      const getByIndices = (varIndices: string) => {\n        if (rank < 2) {\n          return getByOffset(varIndices);\n        } else {\n          implementationUsed.getByIndices = true;\n          implementationUsed.indicesToOffset = true;\n          return `get_${name}ByIndices(${varIndices})`;\n        }\n      };\n\n      const setByIndicesImplementation = rank < 2 ? '' : `\n  fn set_${name}ByIndices(indices: ${type.indices}, value: ${valueType}) {\n    ${setByOffset(`i2o_${name}(indices)`, 'value')}\n  }`;\n\n      const setImplementation = rank < 2 ? '' : (() => {\n        const functionParams = rankIdentity.map(i => `d${i}: u32`).join(', ');\n        const dimsParams = rankIdentity.map(i => `d${i}`).join(', ');\n        return `\n  fn set_${name}(${functionParams}, value: ${valueType}) {\n    set_${name}ByIndices(${indices(dimsParams)}, value);\n  }`;\n      })();\n\n      const set = (...indicesAndValue: ReadonlyArray<number|string>) => {\n        if (indicesAndValue.length !== rank + 1) {\n          throw new Error(`indices length must be ${rank}`);\n        }\n        const value = indicesAndValue[rank];\n        if (typeof value !== 'string') {\n          throw new Error('value must be string');\n        }\n\n        const normalizedIndices = indicesAndValue.slice(0, rank).map(normalizeDim).join(',');\n\n        if (rank === 0) {\n          return setByOffset('0u', value);\n        } else if (rank === 1) {\n          return setByOffset(normalizedIndices[0], value);\n        } else {\n          implementationUsed.set = true;\n          implementationUsed.setByIndices = true;\n          implementationUsed.indicesToOffset = true;\n          return `set_${name}(${normalizedIndices}, ${value})`;\n        }\n      };\n\n      const setByIndices = (varIndices: string, value: string) => {\n        if (rank < 2) {\n          return setByOffset(varIndices, value);\n        } else {\n          implementationUsed.setByIndices = true;\n          implementationUsed.indicesToOffset = true;\n          return `set_${name}ByIndices(${varIndices}, ${value});`;\n        }\n      };\n\n      const impl = () => {\n        const impls = [];\n        let needShapeStrides = false;\n        if (implementationUsed.offsetToIndices) {\n          impls.push(offsetToIndicesImplementation);\n          needShapeStrides = true;\n        }\n        if (implementationUsed.indicesToOffset) {\n          impls.push(indicesToOffsetImplementation);\n          needShapeStrides = true;\n        }\n        if (implementationUsed.broadcastedIndicesToOffset) {\n          Object.values(broadcastedIndicesToOffsetImplementation).forEach(impl => impls.push(impl));\n          needShapeStrides = true;\n        }\n        if (implementationUsed.set) {\n          impls.push(setImplementation);\n          needShapeStrides = true;\n        }\n        if (implementationUsed.setByIndices) {\n          impls.push(setByIndicesImplementation);\n          needShapeStrides = true;\n        }\n        if (implementationUsed.get) {\n          impls.push(getImplementation);\n          needShapeStrides = true;\n        }\n        if (implementationUsed.getByIndices) {\n          impls.push(getByIndicesImplementation);\n          needShapeStrides = true;\n        }\n        if (!useUniform && needShapeStrides) {\n          impls.unshift(\n              `const ${shape} = ${type.indices}(${shapeOrRank.join(',')});`,\n              `const ${strides} = ${type.indices}(${ShapeUtil.computeStrides(shapeOrRank).join(',')});`);\n        }\n        return impls.join('\\n');\n      };\n\n      return {\n        impl,\n        type,\n        offsetToIndices,\n        indicesToOffset,\n        broadcastedIndicesToOffset,\n        indices,\n        indicesGet,\n        indicesSet,\n        set,\n        setByOffset,\n        setByIndices,\n        get,\n        getByOffset,\n        getByIndices,\n        // isVec4,\n        usage,\n        name,\n        strides,\n        shape,\n        rank\n      };\n    };\n\n/**\n * Create a IndicesHelper for an input.\n *\n * @param name - the name of the input.\n * @param type - the tensor type of the input.\n * @param shapeOrRank - the tensor shape or the rank of the input.\n * @param components - the number of components of the input. available values are 1, 2, 3, 4. default is 1.\n * @returns an IndicesHelper for the input.\n */\nexport const inputVariable =\n    (name: string, type: number, shapeOrRank: number|readonly number[], components: 1|2|3|4 = 1): IndicesHelper =>\n        createIndicesHelper(name, type, shapeOrRank, 'input', components);\n\n/**\n * Create a IndicesHelper for an output.\n *\n * @param name - the name of the output.\n * @param type - the tensor type of the output.\n * @param shapeOrRank - the tensor shape or the rank of the output.\n * @param components - the number of components of the output. available values are 1, 2, 3, 4. default is 1.\n * @returns an IndicesHelper for the output.\n */\nexport const outputVariable =\n    (name: string, type: number, shapeOrRank: number|readonly number[], components: 1|2|3|4 = 1): IndicesHelper =>\n        createIndicesHelper(name, type, shapeOrRank, 'output', components);\n\n/**\n * Create a IndicesHelper for an internal variable.\n *\n * @param name - the name of the variable.\n * @param type - the tensor type of the variable.\n * @param shapeOrRank - the tensor shape or the rank of the variable.\n * @param components - the number of components of the variable. available values are 1, 2, 3, 4. default is 1.\n * @returns an IndicesHelper for the variable.\n */\nexport const internalVariable =\n    (name: string, type: number, shapeOrRank: number|readonly number[], components: 1|2|3|4 = 1): IndicesHelper =>\n        createIndicesHelper(name, type, shapeOrRank, 'internal', components);\n\nexport type UniformDataElementType = 'u32'|'f16'|'f32'|'i32';\nexport type UniformsArrayType = Array<{name: string; type: UniformDataElementType; length?: number}>;\n\n/**\n * A ShaderHelper is a helper class for generating WGSL code.\n */\nexport interface ShaderHelper {\n  /**\n   * A helper function to generate the start of main function in WGSL source code.\n   *\n   * @example\n   * const getShaderSource = (shaderHelper: ShaderHelper) => `\n   *  ...\n   *\n   *  ${shaderHelper.mainStart()}\n   *    // your code here inside main() function\n   *    ...\n   *  }\n   * `;\n   *\n   * @param workgroupSize - an optional workgroup size. default is WORKGROUP_SIZE.\n   */\n  mainStart(workgroupSize?: number|[number, number, number]): string;\n\n  /**\n   * A helper function to generate the code snippet for guarding against out-of-bounds size.\n   *\n   * @example\n   * const getShaderSource = (shaderHelper: ShaderHelper) => `\n   *  ...\n   *\n   *  ${shaderHelper.mainStart()}\n   *    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}\n   *\n   *    // your code here inside main() function\n   *    ...\n   *  }\n   * `;\n   *\n   * @param size - the size of the data to guard against. can be a number or a string (WGSL `u32` expression).\n   */\n  guardAgainstOutOfBoundsWorkgroupSizes(size: unknown): string;\n\n  /**\n   * A helper function to generate the code snippet for declaring multiple inputs or outputs.\n   *\n   * @param variables - an array of IndicesHelper for the variables.\n   */\n  declareVariables(...variables: IndicesHelper[]): string;\n\n  /**\n   * A helper function to register one uniform. Can be called multiple times to register multiple uniforms.\n   *\n   * @param name - the name of the uniform.\n   * @param type - the type of the uniform.\n   * @param length - the length of the uniform, default to 1 when it is not provided.\n   */\n  registerUniform(name: string, type: string, length?: number): ShaderHelper;\n\n  /**\n   * A helper function to register multiple uniforms. Can be called multiple times to register multiple uniforms.\n   *\n   * @param uniforms - an array of uniforms. Each element of the array is an object with 2 properties: `name` and\n   *     `type`.\n   */\n  registerUniforms(uniforms: UniformsArrayType): ShaderHelper;\n\n  /**\n   * A helper function to register multiple internal variables. Can be called multiple times to register multiple\n   * internal variables.\n   *\n   * @param variables - an array of IndicesHelper for the variables.\n   */\n  registerInternalVariables(...variables: IndicesHelper[]): ShaderHelper;\n}\n\nclass ShaderHelperImpl implements ShaderHelper {\n  constructor(private normalizedDispatchGroup: [number, number, number], private limits: GPUSupportedLimits) {}\n\n  guardAgainstOutOfBoundsWorkgroupSizes(size: number|string): string {\n    // Guard against out-of-bounds work group sizes\n    const sizeInCode = typeof size === 'number' ? `${size}u` : size;\n    return `if (global_idx >= ${sizeInCode}) { return; }`;\n  }\n\n  mainStart(workgroupSize: number|[number, number, number] = WORKGROUP_SIZE) {\n    const workgroupSizeX = typeof workgroupSize === 'number' ? workgroupSize : workgroupSize[0];\n    const workgroupSizeY = typeof workgroupSize === 'number' ? 1 : workgroupSize[1];\n    const workgroupSizeZ = typeof workgroupSize === 'number' ? 1 : workgroupSize[2];\n\n    if (workgroupSizeX > this.limits.maxComputeWorkgroupSizeX ||\n        workgroupSizeY > this.limits.maxComputeWorkgroupSizeY ||\n        workgroupSizeZ > this.limits.maxComputeWorkgroupSizeZ) {\n      throw new Error(`workgroup size [${workgroupSizeX}, ${workgroupSizeY}, ${\n          workgroupSizeZ}] exceeds the maximum workgroup size [${this.limits.maxComputeWorkgroupSizeX}, ${\n          this.limits.maxComputeWorkgroupSizeY}, ${this.limits.maxComputeWorkgroupSizeZ}].`);\n    }\n\n    if (workgroupSizeX * workgroupSizeY * workgroupSizeZ > this.limits.maxComputeInvocationsPerWorkgroup) {\n      throw new Error(`workgroup size [${workgroupSizeX}, ${workgroupSizeY}, ${\n          workgroupSizeZ}] exceeds the maximum workgroup invocations ${\n          this.limits.maxComputeInvocationsPerWorkgroup}.`);\n    }\n\n    const is1DimensionDispatch = this.normalizedDispatchGroup[1] === 1 && this.normalizedDispatchGroup[2] === 1;\n    const paramList = is1DimensionDispatch ? `@builtin(global_invocation_id) global_id : vec3<u32>,\n    @builtin(workgroup_id) workgroup_id : vec3<u32>,\n    @builtin(local_invocation_id) local_id : vec3<u32>` :\n                                             `@builtin(global_invocation_id) global_id : vec3<u32>,\n                                             @builtin(local_invocation_id) local_id : vec3<u32>,\n    @builtin(local_invocation_index) local_idx : u32,\n    @builtin(workgroup_id) workgroup_id : vec3<u32>,\n    @builtin(num_workgroups) num_workgroups : vec3<u32>`;\n    const globalIdxDefinition = is1DimensionDispatch ?\n        'let global_idx = global_id.x; let local_idx = local_id.x;' :\n        `let global_idx = (workgroup_id.z * num_workgroups[0] * num_workgroups[1] +\n          workgroup_id.y * num_workgroups[0] + workgroup_id.x) * ${\n            workgroupSizeX * workgroupSizeY * workgroupSizeZ}u + local_idx;`;\n\n    return `@compute @workgroup_size(${workgroupSizeX}, ${workgroupSizeY}, ${workgroupSizeZ})\n  fn main(${paramList}) {\n    ${globalIdxDefinition}\n  `;\n  }\n\n  private appendVariableUniforms(variable: IndicesHelper): void {\n    if (variable.rank !== 0) {\n      if (variable.shape.startsWith('uniforms.')) {\n        this.uniforms.push({name: variable.shape.replace('uniforms.', ''), type: 'u32', length: variable.rank});\n      }\n      if (variable.strides.startsWith('uniforms.')) {\n        this.uniforms.push({name: variable.strides.replace('uniforms.', ''), type: 'u32', length: variable.rank});\n      }\n    }\n  }\n\n  private declareVariable(variable: IndicesHelper, bindingIndex: number): string {\n    if (variable.usage === 'internal') {\n      throw new Error('cannot use internal variable with declareVariable(). use registerInternalVariables() instead.');\n    }\n    this.variables.push(variable);\n    this.appendVariableUniforms(variable);\n\n    const access = variable.usage === 'input' ? 'read' : 'read_write';\n    const storageType = variable.type.storage;\n    return `@group(0) @binding(${bindingIndex}) var<storage, ${access}> ${variable.name}: array<${storageType}>;`;\n  }\n\n  declareVariables(...variables: IndicesHelper[]): string {\n    return variables.map(v => this.declareVariable(v, this.variableIndex++)).join('\\n');\n  }\n\n  private registerInternalVariable(variable: IndicesHelper): void {\n    if (variable.usage !== 'internal') {\n      throw new Error(\n          'cannot use input or output variable with registerInternalVariable(). use declareVariables() instead.');\n    }\n\n    this.internalVariables.push(variable);\n    this.appendVariableUniforms(variable);\n  }\n\n  registerInternalVariables(...variables: IndicesHelper[]): ShaderHelper {\n    variables.forEach(v => this.registerInternalVariable(v));\n    return this;\n  }\n\n  registerUniform(name: string, type: UniformDataElementType, length = 1): ShaderHelper {\n    this.uniforms.push({name, type, length});\n    return this;\n  }\n\n  registerUniforms(additionalUniforms: UniformsArrayType): ShaderHelper {\n    this.uniforms = this.uniforms.concat(additionalUniforms);\n    return this;\n  }\n\n  private internalVariables: IndicesHelper[] = [];\n  private variables: IndicesHelper[] = [];\n  private uniforms: UniformsArrayType = [];\n  private uniformDeclaration(): string {\n    if (this.uniforms.length === 0) {\n      return '';\n    }\n\n    const uniformSnippets: string[] = [];\n    for (const {name, type, length} of this.uniforms) {\n      if (length && length > 4) {\n        if (type === 'f16') {\n          uniformSnippets.push(`@align(16) ${name}:array<mat2x4<${type}>, ${Math.ceil(length / 8)}>`);\n        } else {\n          uniformSnippets.push(`${name}:array<vec4<${type}>, ${Math.ceil(length / 4)}>`);\n        }\n      } else {\n        const typeTemp = length == null || length === 1 ? type : `vec${length}<${type}>`;\n        uniformSnippets.push(`${name}:${typeTemp}`);\n      }\n    }\n\n    return `\n      struct Uniforms { ${uniformSnippets.join(', ')} };\n      @group(0) @binding(${this.variableIndex}) var<uniform> uniforms: Uniforms;`;\n  }\n  private variableIndex = 0;\n\n  /**\n   * Get additional implementation that needs to be added to the shader source.\n   */\n  get additionalImplementations(): string {\n    return this.uniformDeclaration() + this.variables.map(i => i.impl()).join('\\n') +\n        this.internalVariables.map(i => i.impl()).join('\\n');\n  }\n\n  /**\n   * Get the variable info of the shader program.\n   */\n  get variablesInfo(): ProgramUniformVariableInfo[]|undefined {\n    if (this.uniforms.length === 0) {\n      return undefined;\n    }\n\n    const uniformWgslTypeToDataType = (type: UniformDataElementType) =>\n        ([DataType.uint32, DataType.float16, DataType.float,\n          DataType.int32][['u32', 'f16', 'f32', 'i32'].indexOf(type)]);\n    return this.uniforms.map(u => ([uniformWgslTypeToDataType(u.type), u.length ?? 1]));\n  }\n}\n\nexport const createShaderHelper = (dispatchGroup: [number, number, number], limits: GPUSupportedLimits) =>\n    new ShaderHelperImpl(dispatchGroup, limits);\n\n/**\n * This function comes from https://github.com/tensorflow/tfjs/blob/master/tfjs-core/src/ops/broadcast_util.ts#L18-L40\n * Returns the dimensions in the input shape that are broadcasted to\n * produce the provided output shape.\n *\n * The returned dimensions are 0-indexed and sorted. An example:\n * inShape = [4, 1, 3]\n * outShape = [5, 4, 3, 3]\n * result = [1]. Dimension 1 (2nd dimension of input) gets broadcasted 1 => 3.\n */\nexport const getBroadcastDims = (inShape: readonly number[], outShape: readonly number[]): number[] => {\n  const inRank = inShape.length;\n  const dims: number[] = [];\n  for (let i = 0; i < inRank; i++) {\n    const dim = inRank - 1 - i;\n    const a = inShape[dim] || 1;\n    const b = outShape[outShape.length - 1 - i] || 1;\n    if (b > 1 && a === 1) {\n      dims.unshift(dim);\n    }\n  }\n  return dims;\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface TransposeAttributes extends AttributeWithCacheKey {\n  readonly perm: number[];\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Transpose requires 1 input.');\n  }\n};\n\nconst getAdjustedPerm = (inputRank: number, perm: number[]): number[] =>\n    (perm && perm.length !== inputRank) ? [...(new Array(inputRank).keys())].reverse() : perm;\n\nconst getOutputShape = (inputShape: readonly number[], perm: number[]): readonly number[] =>\n    ShapeUtil.sortBasedOnPerm(inputShape, getAdjustedPerm(inputShape.length, perm));\n\nconst permFunctionBody = (perm: number[], rank: number, input: IndicesHelper, output: IndicesHelper): string => {\n  const reverseFunc = [];\n  reverseFunc.push(`fn perm(i: ${output.type.indices}) -> ${input.type.indices} {\n    var a: ${input.type.indices};`);\n  for (let i = 0; i < rank; ++i) {\n    reverseFunc.push(input.indicesSet('a', perm[i], `i[${i}]`));\n  }\n  reverseFunc.push('return a;}');\n  return reverseFunc.join('\\n');\n};\n\nexport const createTransposeProgramInfo = (inputTensor: TensorView, permAttr: number[]): ProgramInfo => {\n  const inputDataType = inputTensor.dataType;\n  const inputRank = inputTensor.dims.length;\n  const perm = getAdjustedPerm(inputRank, permAttr);\n  const outputShape = getOutputShape(inputTensor.dims, perm);\n  const output = outputVariable('output', inputDataType, outputShape.length);\n  const input = inputVariable('a', inputDataType, inputRank);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(input, output)}\n\n  ${permFunctionBody(perm, inputRank, input, output)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n    let indices = ${output.offsetToIndices('global_idx')};\n    let aIndices = perm(indices);\n\n    ${output.setByOffset('global_idx', input.getByIndices('aIndices'))}\n  }`;\n  return {\n    name: 'Transpose',\n    shaderCache: {hint: `${permAttr}`, inputDependencies: ['rank']},\n    getRunData: (inputs) => {\n      const outputSize = ShapeUtil.size(outputShape);\n      return {\n        outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n        dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n        programUniforms:\n            [{type: DataType.uint32, data: outputSize}, ...createTensorShapeVariables(inputs[0].dims, outputShape)],\n      };\n    },\n    getShaderSource,\n  };\n};\n\nexport const transpose = (context: ComputeContext, attributes: TransposeAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createTransposeProgramInfo(context.inputs[0], attributes.perm));\n};\n\nexport const parseTransposeAttributes = (attributes: Record<string, unknown>): TransposeAttributes =>\n    createAttributeWithCacheKey({perm: attributes.perm as number[]});\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramShaderCacheInfo} from '../types';\n\nimport {inputVariable, outputVariable, ShaderHelper} from './common';\nimport {createReduceAttributesFromInputs, ReduceAttributes} from './reduce';\nimport {createTransposeProgramInfo} from './transpose';\n\nconst reduceOps: {[key: string]: string} = {\n  max: 'select(bestValue, candidate, candidate > bestValue)',\n  min: 'select(bestValue, candidate, candidate < bestValue)',\n  mean: 'bestValue + candidate',\n  sum: 'bestValue + candidate',\n  prod: 'bestValue * candidate',\n  sumSquare: 'bestValue + candidate * candidate',\n  logSumExp: 'bestValue + exp(candidate)',\n  l1: 'bestValue + abs(candidate)',\n  l2: 'bestValue + candidate * candidate',\n  logSum: 'bestValue + candidate'\n};\n\nconst reduceSharedOps: {[key: string]: string} = {\n  max: 'select(bestValue, candidate, candidate > bestValue)',\n  min: 'select(bestValue, candidate, candidate < bestValue)',\n  mean: 'bestValue + candidate',\n  sum: 'bestValue + candidate',\n  prod: 'bestValue * candidate',\n  sumSquare: 'bestValue + candidate',\n  logSumExp: 'bestValue + candidate',\n  l1: 'bestValue + candidate',\n  l2: 'bestValue + candidate',\n  logSum: 'bestValue + candidate'\n};\n\nconst reduceInitValues: {[key: string]: string} = {\n  max: '_A[offset]',\n  min: '_A[offset]',\n  mean: '0',\n  sum: '0',\n  prod: '1',\n  sumSquare: '0',\n  logSumExp: '0',\n  l1: '0',\n  l2: '0',\n  logSum: '0'\n};\n\nconst reduceOutputValues: {[key: string]: string} = {\n  max: 'bestValue',\n  min: 'bestValue',\n  sum: 'bestValue',\n  prod: 'bestValue',\n  sumSquare: 'bestValue',\n  logSumExp: 'log(bestValue)',\n  l1: 'bestValue',\n  l2: 'sqrt(bestValue)',\n  logSum: 'log(bestValue)'\n};\n\nconst getInnerMostAxes = (numInnerAxes: number, rank: number): number[] => {\n  const res = [];\n  for (let i = rank - numInnerAxes; i < rank; ++i) {\n    res.push(i);\n  }\n  return res;\n};\n\nconst computeOutAndReduceShapes = (shape: readonly number[], axes: readonly number[]): [number[], number[]] => {\n  const outputShape = [];\n  const rank = shape.length;\n  for (let dim = 0; dim < rank; dim++) {\n    if (axes.indexOf(dim) === -1) {\n      outputShape.push(shape[dim]);\n    }\n  }\n  const reduceShape = axes.map(dim => shape[dim]);\n  return [outputShape, reduceShape];\n};\n\nconst expandShapeToKeepDim = (shape: number[], axes: number[]): number[] => {\n  const rank = shape.length + axes.length;\n  const expandShape = [];\n  let shapeIdx = 0;\n  for (let dim = 0; dim < rank; dim++) {\n    if (axes.indexOf(dim) === -1) {\n      expandShape.push(shape[shapeIdx++]);\n    } else {\n      expandShape.push(1);\n    }\n  }\n  return expandShape;\n};\n\nconst areAxesInnerMostDims = (axes: number[], rank: number): boolean => {\n  for (let i = 0; i < axes.length; ++i) {\n    if (axes[axes.length - i - 1] !== rank - 1 - i) {\n      return false;\n    }\n  }\n  return true;\n};\n\nconst getAxesPermutation = (axes: number[], rank: number): number[] => {\n  const res = [];\n  if (!areAxesInnerMostDims(axes, rank)) {\n    for (let i = 0; i < rank; ++i) {\n      if (axes.indexOf(i) === -1) {\n        res.push(i);\n      }\n    }\n    axes.forEach(axis => res.push(axis));\n  }\n  return res;\n};\n\nexport const createReduceSharedProgramInfo =\n    (name: string, shaderCache: ProgramShaderCacheInfo, inputs: readonly TensorView[], reduceType: string,\n     outputDataType: DataType, outputShape: number[], reduceShape: number[]): ProgramInfo => {\n      const inputShape = inputs[0].dims;\n\n      const outputSize = ShapeUtil.size(outputShape);\n      const reduceSize = ShapeUtil.size(reduceShape);\n\n      const input = inputVariable('_A', inputs[0].dataType, inputShape);\n      const output = outputVariable('output', outputDataType, outputShape);\n\n      const workgroupSize = 32;\n\n      const sharedMemorySnippet = `\n          var<workgroup> aBestValues : array<f32, ${workgroupSize}>;\n       `;\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => `\n        ${shaderHelper.registerUniform('reduceSize', 'u32').declareVariables(input, output)}\n        ${sharedMemorySnippet}\n        fn DIV_CEIL(a : u32, b : u32) -> u32 {\n          return ((a - 1u) / b + 1u);\n         }\n         ${shaderHelper.mainStart(workgroupSize)}\n\n          let outputIndex = global_idx / ${workgroupSize};\n          let offset = outputIndex * uniforms.reduceSize;\n\n          var bestValue = f32(${reduceInitValues[reduceType]});\n          let Length = uniforms.reduceSize;\n          for (var k = local_idx; k < Length; k = k + ${workgroupSize}) {\n           let candidate = f32(${input.getByOffset('offset + k')});\n           bestValue = ${reduceOps[reduceType]};\n          }\n          aBestValues[local_idx] = bestValue;\n          workgroupBarrier();\n\n         var reduceSize = min(Length, ${workgroupSize}u);\n         for (var currentSize = reduceSize / 2u; reduceSize > 1u;\n             currentSize = reduceSize / 2u) {\n           let interval = DIV_CEIL(reduceSize, 2u);\n           if (local_idx < currentSize) {\n            let candidate = aBestValues[local_idx + interval];\n            bestValue = ${reduceSharedOps[reduceType]};\n            aBestValues[local_idx] = bestValue;\n           }\n           reduceSize = interval;\n           workgroupBarrier();\n         }\n\n         if (local_idx == 0u) {\n          ${\n          output.setByOffset(\n              'outputIndex',\n              `${\n                  reduceType === 'mean' ? `${output.type.storage}(bestValue / f32(uniforms.reduceSize))` :\n                                          `${output.type.storage}(${reduceOutputValues[reduceType]})`}`)};\n         }\n        }`;\n\n      // One work group is responsible for only one element of output.\n      return {\n        name,\n        shaderCache,\n        getShaderSource,\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: outputDataType}],\n          dispatchGroup: {x: outputSize},\n          programUniforms: [{type: DataType.uint32, data: reduceSize}]\n        }),\n      };\n    };\n\nconst reduceCommon =\n    (context: ComputeContext, name: string, attributes: ReduceAttributes,\n     reduceType: 'sum'|'sumSquare'|'prod'|'min'|'max'|'mean'|'logSumExp'|'l1'|'l2'|'logSum'): void => {\n      const updatedAttributes: ReduceAttributes =\n          context.inputs.length === 1 ? attributes : createReduceAttributesFromInputs(context.inputs, attributes);\n\n      let updatedAxes = updatedAttributes.axes;\n      if (updatedAxes.length === 0 && !updatedAttributes.noopWithEmptyAxes) {\n        updatedAxes = context.inputs[0].dims.map((_dim, i) => i);\n      }\n      const normalizeAxes = ShapeUtil.normalizeAxes(updatedAxes, context.inputs[0].dims.length);\n\n      let axes = normalizeAxes;\n      let input = context.inputs[0];\n      const permutedAxes = getAxesPermutation(axes, context.inputs[0].dims.length);\n      if (permutedAxes.length > 0) {\n        input = context.compute(\n            createTransposeProgramInfo(context.inputs[0], permutedAxes), {inputs: [0], outputs: [-1]})[0];\n        axes = getInnerMostAxes(axes.length, input.dims.length);\n      }\n\n      const [outputShape, reduceShape] = computeOutAndReduceShapes(input.dims, axes);\n      let finalOutputShape = outputShape;\n      if (updatedAttributes.keepDims) {\n        finalOutputShape = expandShapeToKeepDim(outputShape, normalizeAxes);\n      }\n\n      context.compute(\n          createReduceSharedProgramInfo(\n              name, {hint: updatedAttributes.cacheKey, inputDependencies: ['type']}, [input], reduceType,\n              context.inputs[0].dataType, finalOutputShape, reduceShape),\n          {inputs: [input]});\n    };\n\nexport const reduceMeanShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceMeanShared', attributes, 'mean');\n};\n\nexport const reduceL1Shared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceL1Shared', attributes, 'l1');\n};\n\nexport const reduceL2Shared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceL2Shared', attributes, 'l2');\n};\n\nexport const reduceLogSumExpShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceLogSumExpShared', attributes, 'logSumExp');\n};\n\nexport const reduceMaxShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceMaxShared', attributes, 'max');\n};\n\nexport const reduceMinShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceMinShared', attributes, 'min');\n};\n\nexport const reduceProdShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceProdShared', attributes, 'prod');\n};\n\nexport const reduceSumShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceSumShared', attributes, 'sum');\n};\n\nexport const reduceSumSquareShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceSumSquareShared', attributes, 'sumSquare');\n};\n\nexport const reduceLogSumShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceLogSumShared', attributes, 'logSum');\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramShaderCacheInfo} from '../types';\n\nimport {createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\nimport {reduceL1Shared, reduceL2Shared, reduceLogSumExpShared, reduceLogSumShared, reduceMaxShared, reduceMeanShared, reduceMinShared, reduceProdShared, reduceSumShared, reduceSumSquareShared} from './reduce-shared';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length === 0 || inputs.length > 2) {\n    throw new Error('Reduce op requires 1 or 2 inputs.');\n  }\n\n  if (inputs.length === 2 && inputs[1].dims.length !== 1) {\n    throw new Error('Invalid axes input dims.');\n  }\n};\n\nexport interface ReduceAttributes extends AttributeWithCacheKey {\n  keepDims: boolean;\n  noopWithEmptyAxes: boolean;\n  axes: number[];\n}\n\nexport type ReduceOp =\n    (input: IndicesHelper, output: IndicesHelper,\n     axes: readonly number[]) => [string, string, string, string, ...string[]];\n\nconst noOp: ReduceOp = (input) => ['', '', `var value = ${input.getByIndices('input_indices')};`, ''];\nexport const createReduceProgramInfo =\n    (name: string, shaderCache: ProgramShaderCacheInfo, inputs: readonly TensorView[], reduceOp: ReduceOp,\n     axesInput: number[], outputDataType: DataType, keepDims = false, noopWithEmptyAxes = false): ProgramInfo => {\n      const outputShape: number[] = [];\n      const inputShape = inputs[0].dims;\n      const inputRank = inputShape.length;\n      const axes = ShapeUtil.normalizeAxes(axesInput, inputRank);\n      const reduceOnAllAxes = !noopWithEmptyAxes && axes.length === 0;\n      inputShape.forEach((d, i) => {\n        if (reduceOnAllAxes || axes.indexOf(i) >= 0) {\n          if (keepDims) {\n            outputShape.push(1);\n          }  // else { // skip this axis}\n        } else {\n          outputShape.push(d);\n        }\n      });\n      const outputRank = outputShape.length;\n      const outputSize = ShapeUtil.size(outputShape);\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const idxCopy: string[] = [];  // copy output indexes to input indexes\n\n        const input = inputVariable('_A', inputs[0].dataType, inputRank);\n        const output = outputVariable('output', outputDataType, outputRank);\n        const ops = reduceOp(input, output, axes);\n        let reduceOps = ops[2];\n\n        for (let k = 0, l = 0; k < inputRank; k++) {\n          // if this axis is reduced\n          if (reduceOnAllAxes || axes.indexOf(k) >= 0) {\n            if (keepDims) {\n              l++;\n            }\n            // loop over the d-th axis\n            reduceOps = `for(var j${k}: u32 = 0; j${k} < ${inputShape[k]}; j${k}++) {\n                  ${ops[2].includes('last_index') ? `let last_index = j${k};` : ''}\n                  ${input.indicesSet('input_indices', k, `j${k}`)}\n                  ${reduceOps}\n                }`;\n          } else {\n            idxCopy.push(`${input.indicesSet('input_indices', k, output.indicesGet('output_indices', l))};`);\n            l++;\n          }\n        }\n        return `\n\n        ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(input, output)}\n\n        ${shaderHelper.mainStart()}\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n          var input_indices: ${input.type.indices};\n          let output_indices = ${output.offsetToIndices('global_idx')};\n\n          ${idxCopy.join('\\n')}\n          ${ops[0]}       // init ops for reduce max/min\n          ${ops[1]}\n          ${reduceOps}\n          ${ops[3]}\n          ${ops.length === 4 ? output.setByOffset('global_idx', 'value') : ops.slice(4).join('\\n')}\n        }`;\n      };\n\n      return {\n        name,\n        shaderCache,\n        getShaderSource,\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: outputDataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms:\n              [{type: DataType.uint32, data: outputSize}, ...createTensorShapeVariables(inputShape, outputShape)]\n        }),\n      };\n    };\n\nexport const createReduceAttributesFromInputs =\n    (inputs: readonly TensorView[], attributes: ReduceAttributes): ReduceAttributes => {\n      const axes: number[] = [];\n      if (inputs[1].dims[0] > 0) {\n        inputs[1].getBigInt64Array().forEach(v => axes.push(Number(v)));\n      }\n      return createAttributeWithCacheKey(\n          {axes, keepDims: attributes.keepDims, noopWithEmptyAxes: attributes.noopWithEmptyAxes});\n    };\n\nconst runReduceProgram =\n    (context: ComputeContext, name: string, attributes: ReduceAttributes, reduceOp: ReduceOp): void => {\n      const inputs = context.inputs;\n      const updatedAttributes: ReduceAttributes =\n          inputs.length === 1 ? attributes : createReduceAttributesFromInputs(inputs, attributes);\n\n      context.compute(\n          createReduceProgramInfo(\n              name, {hint: updatedAttributes.cacheKey, inputDependencies: ['rank']}, [inputs[0]],\n              updatedAttributes.noopWithEmptyAxes && updatedAttributes.axes.length === 0 ? noOp : reduceOp,\n              updatedAttributes.axes, inputs[0].dataType, updatedAttributes.keepDims,\n              updatedAttributes.noopWithEmptyAxes),\n          {inputs: [0]});\n    };\n\nconst reduceLogSumNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var value = ${output.type.storage}(0);`,\n       '',\n       `value += ${input.getByIndices('input_indices')};`,\n       'value = log(value);',\n  ];\n  runReduceProgram(context, 'ReduceLogSum', attributes, reduceOp);\n};\n\nconst reduceL1Naive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var value = ${output.type.storage}(0);`,\n       '',\n       `value += abs(${input.getByIndices('input_indices')});`,\n       '',\n  ];\n  runReduceProgram(context, 'ReduceL1', attributes, reduceOp);\n};\n\nconst reduceL2Naive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var t = ${output.type.value}(0); var value = ${output.type.value}(0);`,\n       '',\n       `t = ${input.getByIndices('input_indices')}; value += (t * t);`,\n       'value = sqrt(value);',\n  ];\n  runReduceProgram(context, 'ReduceL2', attributes, reduceOp);\n};\n\nconst reduceLogSumExpNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var value = ${output.type.storage}(0);`,\n       '',\n       `value += exp(${input.getByIndices('input_indices')});`,\n       'value = log(value);',\n  ];\n  runReduceProgram(context, 'ReduceLogSumExp', attributes, reduceOp);\n};\n\nconst reduceMaxNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, _output, axes) => {\n    const idxZero = [];\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(input.indicesSet('input_indices', k, 0));\n      }\n    }\n\n    return [\n      `${idxZero.join('\\n')}`,\n      `var value = ${input.getByIndices('input_indices')};`,\n      `value = max(value, ${input.getByIndices('input_indices')});`,\n      '',\n    ];\n  };\n  runReduceProgram(context, 'ReduceMax', attributes, reduceOp);\n};\n\nconst reduceMeanNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output, axes) => {\n    let size = 1.0;\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        // TODO: this depends on the input dims. If we want to use uniform, this need to be updated.\n        size *= context.inputs[0].dims[k];\n      }\n    }\n\n    return [\n      'var sum = f32(0);',\n      '',\n      `sum += f32(${input.getByIndices('input_indices')});`,\n      `let value = ${output.type.value}(sum / ${size});`,\n    ];\n  };\n  runReduceProgram(context, 'ReduceMean', attributes, reduceOp);\n};\n\nconst reduceMinNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, _output, axes) => {\n    const idxZero = [];\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(`input_indices[${k}] = 0;`);  // first element\n      }\n    }\n\n    return [\n      `${idxZero.join('\\n')}`,\n      `var value = ${input.getByIndices('input_indices')};`,\n      `value = min(value, ${input.getByIndices('input_indices')});`,\n      '',\n    ];\n  };\n  runReduceProgram(context, 'ReduceMin', attributes, reduceOp);\n};\n\nconst reduceProdNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var value = ${output.type.storage}(1);`,\n       '',\n       `value *= ${input.getByIndices('input_indices')};`,\n       '',\n  ];\n  runReduceProgram(context, 'ReduceProd', attributes, reduceOp);\n};\n\nconst reduceSumNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var value = ${output.type.storage}(0);`,\n       '',\n       `value += ${input.getByIndices('input_indices')};`,\n       '',\n  ];\n  runReduceProgram(context, 'ReduceSum', attributes, reduceOp);\n};\n\nconst reduceSumSquareNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var t = ${output.type.value}(0); var value = ${output.type.value}(0);`,\n       '',\n       `t = ${input.getByIndices('input_indices')}; value += t * t;`,\n       '',\n  ];\n  runReduceProgram(context, 'ReduceSumSquare', attributes, reduceOp);\n};\n\nconst useNaiveReduceMethod =\n    (shape: readonly number[], axes: readonly number[], noopWithEmptyAxes: boolean): boolean => {\n      if (axes.length === 0) {\n        return noopWithEmptyAxes;\n      }\n\n      let outputSize = 1;\n      let reduceSize = 1;\n      for (let dim = 0; dim < axes.length; dim++) {\n        if (axes.indexOf(dim) === -1) {\n          outputSize *= shape[dim];\n        } else {\n          reduceSize *= shape[dim];\n        }\n      }\n\n      // The condition data is very rough, although considering the count of Execution Unit (EU), the potential\n      // work groups in a EU and the counts of loops in the naive and shared methods, also doing experiments\n      // on some machines.\n      return reduceSize < 32 && outputSize > 1024;\n    };\n\nexport const reduceMean = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceMeanNaive(context, attributes);\n  } else {\n    reduceMeanShared(context, attributes);\n  }\n};\n\nexport const reduceL1 = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceL1Naive(context, attributes);\n  } else {\n    reduceL1Shared(context, attributes);\n  }\n};\n\nexport const reduceL2 = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceL2Naive(context, attributes);\n  } else {\n    reduceL2Shared(context, attributes);\n  }\n};\n\nexport const reduceLogSumExp = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceLogSumExpNaive(context, attributes);\n  } else {\n    reduceLogSumExpShared(context, attributes);\n  }\n};\n\nexport const reduceMax = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceMaxNaive(context, attributes);\n  } else {\n    reduceMaxShared(context, attributes);\n  }\n};\n\nexport const reduceMin = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceMinNaive(context, attributes);\n  } else {\n    reduceMinShared(context, attributes);\n  }\n};\n\nexport const reduceProd = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceProdNaive(context, attributes);\n  } else {\n    reduceProdShared(context, attributes);\n  }\n};\n\nexport const reduceSum = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceSumNaive(context, attributes);\n  } else {\n    reduceSumShared(context, attributes);\n  }\n};\n\nexport const reduceSumSquare = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceSumSquareNaive(context, attributes);\n  } else {\n    reduceSumSquareShared(context, attributes);\n  }\n};\n\nexport const reduceLogSum = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceLogSumNaive(context, attributes);\n  } else {\n    reduceLogSumShared(context, attributes);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// TODO: this is the same naive implementation we use for reduce that has\n// performance limitations when the reduced axis is long. Need to add\n// a optimized codepath for this.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext} from '../types';\n\nimport {createReduceProgramInfo, ReduceOp} from './reduce';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length === 0 || inputs.length > 2) {\n    throw new Error('ArgMinMaxOp op requires 1 or 2 inputs.');\n  }\n  if (inputs[0].dataType !== DataType.float) {\n    throw new Error('Invalid input type.');\n  }\n};\n\nexport interface ArgMinMaxAttributes extends AttributeWithCacheKey {\n  keepDims: boolean;\n  axis: number;\n  selectLastIndex: number;\n}\n\nexport const argMin = (context: ComputeContext, attributes: ArgMinMaxAttributes): void => {\n  validateInputs(context.inputs);\n  const argMinMaxOp: ReduceOp = (input, output, axes) => {\n    const idxZero = [];\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(`input_indices[${k}] = 0;`);  // first element\n      }\n    }\n    return [\n      `${idxZero.join('\\n')}`, `var value = ${input.getByIndices('input_indices')};\\nvar best_index : i32 = 0;`,\n      `if (${input.getByIndices('input_indices')} ${attributes.selectLastIndex > 0 ? '<=' : '<'} value) {\n         value = ${input.getByIndices('input_indices')};\n         best_index = i32(last_index);\n       }`,\n      '', output.setByOffset('global_idx', 'best_index')\n    ];\n  };\n\n  context.compute(\n      createReduceProgramInfo(\n          'ArgMin', {hint: attributes.cacheKey, inputDependencies: ['rank']}, [context.inputs[0]], argMinMaxOp,\n          [attributes.axis], DataType.int64, attributes.keepDims),\n      {inputs: [0]});\n};\n\nexport const argMax = (context: ComputeContext, attributes: ArgMinMaxAttributes): void => {\n  validateInputs(context.inputs);\n  const argMinMaxOp: ReduceOp = (input, output, axes) => {\n    const idxZero = [];\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(`input_indices[${k}] = 0;`);  // first element\n      }\n    }\n    return [\n      `${idxZero.join('\\n')}`, `var value = ${input.getByIndices('input_indices')};\\nvar best_index : i32 = 0;`,\n      `if (${input.getByIndices('input_indices')} ${attributes.selectLastIndex > 0 ? '>=' : '>'} value) {\n         value = ${input.getByIndices('input_indices')};\n         best_index = i32(last_index);\n       }`,\n      '', output.setByOffset('global_idx', 'best_index')\n    ];\n  };\n\n  context.compute(\n      createReduceProgramInfo(\n          'argMax', {hint: attributes.cacheKey, inputDependencies: ['rank']}, [context.inputs[0]], argMinMaxOp,\n          [attributes.axis], DataType.int64, attributes.keepDims),\n      {inputs: [0]});\n};\n\nexport const parseArgMinMaxAttributes = (attributes: Record<string, unknown>): ArgMinMaxAttributes =>\n    createAttributeWithCacheKey(attributes as Omit<ArgMinMaxAttributes, keyof AttributeWithCacheKey>);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface ConcatAttributes extends AttributeWithCacheKey {\n  readonly axis: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[], axis: number): void => {\n  if (!inputs || inputs.length < 1) {\n    throw new Error('too few inputs');\n  }\n  const referenceIndex = 0;\n  const referenceInput = inputs[referenceIndex];\n  const inputType = referenceInput.dataType;\n  const inputRank = referenceInput.dims.length;\n  inputs.forEach((input, i) => {\n    if (i === referenceIndex) {\n      return;\n    }\n    // make sure types of all inputs match\n    if (input.dataType !== inputType) {\n      throw new Error('input tensors should be one type');\n    }\n    // make sure the dimensionality of all inputs are the same\n    if (input.dims.length !== inputRank) {\n      throw new Error('input tensors should have the same shape');\n    }\n    input.dims.forEach((dim, i) => {\n      if (i !== axis && dim !== referenceInput.dims[i]) {\n        throw new Error('non concat dimensions must match');\n      }\n    });\n  });\n};\n\nconst calculateInputIndexImpl = (numberOfTensors: number, sizeInConcatAxisStr: string): string => `\n  fn calculateInputIndex(index: u32) -> u32 {\n    let sizeInConcatAxis = array<u32, ${numberOfTensors}u>(${sizeInConcatAxisStr});\n    for (var i: u32 = 0u; i < ${numberOfTensors}; i += 1u ) {\n      if (index < sizeInConcatAxis[i]) {\n        return i;\n      }\n    }\n    return ${numberOfTensors}u;\n  }`;\n\nconst assignOutputData = (inputs: readonly IndicesHelper[], output: IndicesHelper) => {\n  const numberOfTensors = inputs.length;\n\n  const codeLines: string[] = [];\n  for (let i = 0; i < numberOfTensors; ++i) {\n    const returnSnippet = output.setByOffset('global_idx', inputs[i].getByIndices('indices'));\n    if (numberOfTensors === 1) {\n      codeLines.push(returnSnippet);\n    } else if (i === 0) {\n      codeLines.push(`if (inputIndex == ${i}u) { ${returnSnippet} }`);\n    } else if (i === numberOfTensors - 1) {\n      codeLines.push(`else { ${returnSnippet} }`);\n    } else {\n      codeLines.push(`else if (inputIndex == ${i}) { ${returnSnippet} }`);\n    }\n  }\n  return codeLines.join('\\n');\n};\n\nexport const createConcatProgramInfo =\n    (inputs: readonly TensorView[], adjustedAxis: number, outputShape: number[], dataType: DataType): ProgramInfo => {\n      const outputSize = ShapeUtil.size(outputShape);\n\n      const sizeInConcatAxis = new Array<number>(inputs.length);\n      const inputVars = new Array<IndicesHelper>(inputs.length);\n\n      let previousSum = 0;\n      const inputDependencies: ProgramInputTensorInfoDependency[] = [];\n      const inputRanks = [];\n      const programUniforms: ProgramUniform[] = [{type: DataType.uint32, data: outputSize}];\n      for (let i = 0; i < inputs.length; ++i) {\n        previousSum += inputs[i].dims[adjustedAxis];\n        sizeInConcatAxis[i] = previousSum;\n        inputRanks.push(inputs[i].dims.length);\n        inputVars[i] = inputVariable(`input${i}`, dataType, inputRanks[i]);\n        inputDependencies.push('rank');\n        programUniforms.push({type: DataType.uint32, data: sizeInConcatAxis[i]});\n      }\n      for (let i = 0; i < inputs.length; ++i) {\n        programUniforms.push(...createTensorShapeVariables(inputs[i].dims));\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShape));\n\n      const output = outputVariable('output', dataType, outputShape.length);\n      const indicesAxis = output.indicesGet('indices', adjustedAxis);\n      const sizeInConcatAxisStr =\n          Array.from(Array(sizeInConcatAxis.length).keys()).map(i => `uniforms.sizeInConcatAxis${i}`).join(',');\n      const getShaderSource = (shaderHelper: ShaderHelper) => `\n\n  ${(() => {\n        shaderHelper.registerUniform('outputSize', 'u32');\n        for (let i = 0; i < inputs.length; i++) {\n          shaderHelper.registerUniform(`sizeInConcatAxis${i}`, 'u32');\n        }\n        return shaderHelper.declareVariables(...inputVars, output);\n      })()}\n\n  ${calculateInputIndexImpl(sizeInConcatAxis.length, sizeInConcatAxisStr)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n\n    var indices = ${output.offsetToIndices('global_idx')};\n\n    let inputIndex = calculateInputIndex(${indicesAxis});\n    if (inputIndex != 0u) {\n      let sizeInConcatAxis = array<u32, ${sizeInConcatAxis.length}u>(${sizeInConcatAxisStr});\n      ${indicesAxis} -= sizeInConcatAxis[inputIndex - 1u];\n    }\n\n    ${assignOutputData(inputVars, output)}\n  }`;\n\n      return {\n        name: 'Concat',\n        shaderCache: {hint: `${adjustedAxis}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms,\n        }),\n        getShaderSource,\n      };\n    };\n\nexport const concat = (context: ComputeContext, attributes: ConcatAttributes): void => {\n  const inputs = context.inputs;\n  const inputShape = inputs[0].dims;\n  const adjustedAxis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);\n  validateInputs(inputs, adjustedAxis);\n  const outputShape = inputShape.slice();\n  outputShape[adjustedAxis] =\n      inputs.reduce((sum, input) => sum + (input.dims.length > adjustedAxis ? input.dims[adjustedAxis] : 0), 0);\n  // 0 length tensors are valid for concat, remove them\n  const nonEmptyInputs = inputs.filter(input => ShapeUtil.size(input.dims) > 0);\n  context.compute(\n      createConcatProgramInfo(nonEmptyInputs, adjustedAxis, outputShape, inputs[0].dataType), {inputs: nonEmptyInputs});\n};\n\nexport const parseConcatAttributes = (attributes: Record<string, unknown>): ConcatAttributes =>\n    createAttributeWithCacheKey({axis: attributes.axis as number});\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ComputeContext, GpuDataType, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, getMaxComponents, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, tensorTypeToWsglValueType, UniformDataElementType, UniformsArrayType} from './common';\nimport {createConcatProgramInfo} from './concat';\n\nexport const enum AttentionQkvFormat {\n  unknown,          // enum value not set, or depends on qkv projection implementation details\n  qkvBNSH,          // for non-packed qkv, permuted\n  qkvBSNH,          // for non-packed qkv, not permuted, used by memory efficient attention or MultiHeadAttention\n  qkvBSN3H,         // for TRT fused attention, qkv are packed\n  qkvBNSHqkvBS3NH,  // for TRT fused causal attention, data has two formats (qkv is 3BNSH, gemm_buffer is BS3NH)\n  qKvBSNHxBSN2H,    // for TRT fused cross attention, kv are packed\n  qkvTNH,           // for memory efficient attention, qkv are not packed, and paddings are removed.\n  qkvTN3H,          // for TRT fused attention, qkv are packed and paddings are removed\n}\n\nexport const enum AttentionMaskType {\n  none,                  // No mask\n  mask1dKeySeqLen,       // [batch_size], key sequence length\n  mask1dEndStart,        // [2 * batch_size] with end positions and start positions\n  mask1DKeySeqLenStart,  // [3 * batch_size + 2] with [key_len[0], ..., key_len[batch_size - 1], query_start[0],\n                         // ..., query_start[batch_size - 1], query_end[batch_size - 1], key_start[0], ...,\n                         // key_start[batch_size - 1], key_end[batch_size - 1]]\n  mask2dDummy,           // dummy mask with shape [1, 1] or [batch_size, 1]. It has same effect as no mask.\n  mask2dKeyPadding,      // [batch_size, total_sequence_length]\n  mask3dAttention,       // [batch_size, sequence_length, total_sequence_length]\n  mask4dMegatron,        // Megatron causal mask with shape [batch_size, 1, max_sequence_length, max_sequence_length]\n  maskUnknown\n}\n\nexport interface AttentionParameters {\n  batchSize: number;\n  sequenceLength: number;\n  pastSequenceLength: number;\n  kvSequenceLength: number;\n  totalSequenceLength: number;\n  maxSequenceLength: number;\n  inputHiddenSize: number;\n  hiddenSize: number;\n  vHiddenSize: number;\n  headSize: number;\n  vHeadSize: number;\n  numHeads: number;\n  isUnidirectional: boolean;\n  pastPresentShareBuffer: boolean;\n  maskFilterValue: number;\n  maskType: AttentionMaskType;\n  scale: number;\n  broadcastResPosBias: boolean;\n  passPastInKv: boolean;\n  qkvFormat: AttentionQkvFormat;\n}\n\nexport interface AttentionAttrs {\n  numHeads: number;\n  isUnidirectional: number;\n  maskFilterValue: number;\n  scale: number;\n  doRotary: number;\n  qkvHiddenSizes: number[];\n  pastPresentShareBuffer: boolean;\n}\n\nconst validateAttentionInputs = (inputs: readonly TensorView[], attributes: AttentionAttrs): AttentionParameters => {\n  // Abbreviation and Meanings:\n  //   B:    batch_size\n  //   S:    sequence_length (input sequence length of query)\n  //   P:    past_sequence_length (past sequence length of key or value)\n  //   L:    kv_sequence_length (input sequence length of key or value)\n  //   M:    max_sequence_length\n  //   T:    total_sequence_length = past_sequence_length + kv_sequence_length\n  //   N:    num_heads\n  //   H:    head size for Q and K, aka q_head_size or k_head_size or qk_head_size\n  //   H_v:  v_head_size\n  //   D_i:  input hidden size\n  //   D:    hidden size for Q and K (D = N * H), aka q_hidden_size or k_hidden_size or qk_hidden_size\n  //   D_v:  v_hidden_size = num_heads * v_head_size\n\n  // When past state is used, Q, K and V should have same hidden size (unless we split it into past_key and past_value).\n\n  // Input shapes:\n  //   input        (Q/K/V)    : (B, S, D_i)\n  //   weights      (Q/K/V)    : (D_i, D + D + D_v)\n  //   bias         (Q/K/V)    : (D + D + D_v)\n  //   mask_index              : see below\n  //   past         (K/V)      : (2, B, N, P, H) or NULL\n  //   relative_position_bias            : (B, N, S, T) or NULL\n\n  // For mask_index, the following shapes are supported:\n  //     NULL, (B, 1), (1, 1)\n  //     (B), (2 * B), (3 * B + 2)\n  //     (B, T)\n  //     (B, S, T)\n  //     (B, 1, M, M)\n  //\n  // When a model is pruned (like some attention heads are removed in Q/K/V), input_hidden_size could be larger\n  // than hidden dimension of Q, K and V.\n\n  const input = inputs[0];\n  const weights = inputs[1];\n  const bias = inputs[2];\n  const maskIndex = inputs[3];\n  const past = inputs[4];\n  const relativePositionBias = inputs[5];\n\n  if (past && relativePositionBias) {\n    throw new Error('Attention cannot have both past and relative_position_bias');\n  }\n\n  if (input.dims.length !== 3) {\n    throw new Error('Input \"input\" must have 3 dimensions');\n  }\n\n  const batchSize = input.dims[0];\n  const sequenceLength = input.dims[1];\n  const inputHiddenSize = input.dims[2];\n\n  if (bias.dims.length !== 1) {\n    throw new Error('Input \"bias\" is expected to have 1 dimensions');\n  }\n\n  if (weights.dims.length !== 2) {\n    throw new Error('Input \"weights\" is expected to have 2 dimensions');\n  }\n\n  if (weights.dims[0] !== inputHiddenSize) {\n    throw new Error('Input 1 dimension 0 should have same length as dimension 2 of input 0');\n  }\n\n  if (bias.dims[0] !== weights.dims[1]) {\n    throw new Error('Input \"bias\" dimension 0 should have same length as dimension 1 of input \"weights\"');\n  }\n\n  let qHiddenSize = bias.dims[0] / 3;\n  let kHiddenSize = qHiddenSize;\n  let vHiddenSize = kHiddenSize;\n  if (attributes.qkvHiddenSizes.length > 0) {\n    if (attributes.qkvHiddenSizes.length !== 3) {\n      throw new Error('qkv_hidden_sizes attribute should have 3 elements');\n    }\n    for (const sz of attributes.qkvHiddenSizes) {\n      if (sz % attributes.numHeads !== 0) {\n        throw new Error('qkv_hidden_sizes should be divisible by num_heads');\n      }\n    }\n\n    qHiddenSize = attributes.qkvHiddenSizes[0];\n    kHiddenSize = attributes.qkvHiddenSizes[1];\n    vHiddenSize = attributes.qkvHiddenSizes[2];\n  }\n\n  const kvSequenceLength = sequenceLength;\n\n  if (qHiddenSize !== kHiddenSize) {\n    throw new Error('qkv_hidden_sizes first element should be same as the second');\n  }\n\n  if (bias.dims[0] !== qHiddenSize + kHiddenSize + vHiddenSize) {\n    throw new Error('Input \"bias\" dimension 0 should have same length as sum of Q/K/V hidden sizes');\n  }\n\n  let pastSequenceLength = 0;\n  if (past) {\n    if (kHiddenSize !== vHiddenSize) {\n      throw new Error('Input \"past\" expect k_hidden_size == v_hidden_size');\n    }\n    if (past.dims.length !== 5) {\n      throw new Error('Input \"past\" must have 5 dimensions');\n    }\n    if (past.dims[0] !== 2) {\n      throw new Error('Input \"past\" first dimension must be 2');\n    }\n    if (past.dims[1] !== batchSize) {\n      throw new Error('Input \"past\" second dimension must be batch_size');\n    }\n    if (past.dims[2] !== attributes.numHeads) {\n      throw new Error('Input \"past\" third dimension must be num_heads');\n    }\n    if (past.dims[4] !== kHiddenSize / attributes.numHeads) {\n      throw new Error('Input \"past\" fifth dimension must be k_hidden_size / num_heads');\n    }\n\n    if (!attributes.pastPresentShareBuffer) {\n      pastSequenceLength = past.dims[3];\n    }\n    // TODO: handle past_seq_len\n  }\n\n  const totalSequenceLength = kvSequenceLength + pastSequenceLength;\n  const maxSequenceLength = -1;\n\n  const maskType = AttentionMaskType.none;\n  if (maskIndex) {\n    // maskType = AttentionMaskType.MASK_UNKNOWN;\n    // TODO: handle mask\n    throw new Error('Mask not supported');\n  }\n\n  if (past) {\n    throw new Error('past is not supported');\n  }\n\n  return {\n    batchSize,\n    sequenceLength,\n    pastSequenceLength,\n    kvSequenceLength,\n    totalSequenceLength,\n    maxSequenceLength,\n    inputHiddenSize,\n    hiddenSize: qHiddenSize,\n    vHiddenSize,\n    headSize: Math.floor(qHiddenSize / attributes.numHeads),\n    vHeadSize: Math.floor(vHiddenSize / attributes.numHeads),\n    numHeads: attributes.numHeads,\n    isUnidirectional: false,\n    pastPresentShareBuffer: false,\n    maskFilterValue: attributes.maskFilterValue,\n    maskType,\n    scale: attributes.scale,\n    broadcastResPosBias: false,\n    passPastInKv: false,\n    qkvFormat: AttentionQkvFormat.qkvBNSH,\n  };\n};\n\nconst createInPlaceSoftmaxProgramInfo = (_context: ComputeContext, input: TensorView, n: number, d: number) => {\n  const components = getMaxComponents(d);\n  let WG = 64;\n  const dComp = d / components;\n  if (dComp < WG) {\n    WG = 1;\n  } else if (dComp / 8 < 64) {\n    WG = Math.ceil(dComp / 8);\n  }\n  const elementsPerThread = Math.ceil(d / components / WG);\n  const programUniforms: ProgramUniform[] = [\n    {type: input.dataType, data: 1 / d}, {type: DataType.uint32, data: dComp},\n    {type: DataType.uint32, data: elementsPerThread}\n  ];\n  const dataType = tensorTypeToWsglStorageType(input.dataType, components);\n  const f32Type = tensorTypeToWsglValueType(DataType.float, components);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const inputHelper = outputVariable('x', input.dataType, input.dims, components);\n    const elemValueType = tensorTypeToWsglValueType(input.dataType);\n    const uniforms: UniformsArrayType = [\n      {name: 'd_inv', type: elemValueType as UniformDataElementType}, {name: 'd_comp', type: 'u32'},\n      {name: 'elements_per_thread', type: 'u32'}\n    ];\n\n    return `\n  var<workgroup> thread_max: array<f32, ${WG}>;\n  var<workgroup> thread_sum: array<f32, ${WG}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(inputHelper)}\n  ${shaderHelper.mainStart([\n      WG, 1, 1\n    ])}\n    let local_offset = local_idx * uniforms.elements_per_thread;\n    let offset = workgroup_id.x * uniforms.d_comp + local_offset;\n\n    var thread_max_vector = ${f32Type}(-3.402823e+38f);\n    for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n      thread_max_vector = max(${f32Type}(x[offset + i]), thread_max_vector);\n    }\n    thread_max[local_idx] = ${(() => {\n      switch (components) {\n        case 1:\n          return 'thread_max_vector';\n        case 2:\n          return 'max(thread_max_vector.x, thread_max_vector.y)';\n        case 4:\n          return 'max(max(thread_max_vector.x, thread_max_vector.y), max(thread_max_vector.z, thread_max_vector.w))';\n        default:\n          throw new Error(`Unsupported components: ${components}`);\n      }\n    })()};\n    workgroupBarrier();\n\n    var max_value =  f32(-3.402823e+38f);\n    for (var i = 0u; i < ${WG}; i++) {\n      max_value = max(thread_max[i], max_value);\n    }\n\n    var sum_vector = ${f32Type}(0);\n    for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n      sum_vector += exp(${f32Type}(x[offset + i]) - max_value);\n    }\n    thread_sum[local_idx] = ${(() => {\n      switch (components) {\n        case 1:\n          return 'sum_vector';\n        case 2:\n          return 'sum_vector.x + sum_vector.y';\n        case 4:\n          return 'sum_vector.x + sum_vector.y + sum_vector.z + sum_vector.w';\n        default:\n          throw new Error(`Unsupported components: ${components}`);\n      }\n    })()};\n    workgroupBarrier();\n\n    var sum: f32 = 0;\n    for (var i = 0u; i < ${WG}; i++) {\n      sum += thread_sum[i];\n    }\n\n    if (sum == 0) {\n      for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n        x[offset + i] = ${inputHelper.type.value}(uniforms.d_inv);\n      }\n    } else {\n      for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n        var f32input = ${f32Type}(x[offset + i]);\n        x[offset + i] = ${inputHelper.type.value}(exp(f32input - max_value) / sum);\n      }\n    }\n  }`;\n  };\n\n  return {\n    name: 'AttentionProbsSoftmax',\n    shaderCache: {hint: `${WG};${dataType};${components}`},\n    getShaderSource,\n    getRunData: () => ({outputs: [], dispatchGroup: {x: n}, programUniforms}),\n  };\n};\n\nconst createAttentionProbsProgramInfo =\n    (_context: ComputeContext, q: TensorView, key: TensorView, relativePositionBias: TensorView|undefined,\n     parameters: AttentionParameters, attributes: AttentionAttrs, pastSequenceLength: number) => {\n      const totalSequenceLength = pastSequenceLength + parameters.kvSequenceLength;\n      const probsShape = [parameters.batchSize, parameters.numHeads, parameters.sequenceLength, totalSequenceLength];\n\n      // TODO: handle mask\n\n      const alpha = attributes.scale === 0 ? 1.0 / Math.sqrt(parameters.headSize) : attributes.scale;\n      const components = getMaxComponents(parameters.headSize);\n      const vectorizedHeadSize = parameters.headSize / components;\n      const TILE_SIZE = 12;\n      const dispatch = {\n        x: Math.ceil(totalSequenceLength / TILE_SIZE),\n        y: Math.ceil(parameters.sequenceLength / TILE_SIZE),\n        z: parameters.batchSize * parameters.numHeads\n      };\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: parameters.sequenceLength}, {type: DataType.uint32, data: vectorizedHeadSize},\n        {type: DataType.uint32, data: totalSequenceLength}, {type: DataType.uint32, data: parameters.numHeads},\n        {type: DataType.float, data: alpha}\n      ];\n\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n      if (relativePositionBias) {\n        inputDependencies.push('rank');\n        programUniforms.push(...createTensorShapeVariables(relativePositionBias.dims));\n      }\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const qInput = inputVariable('q', q.dataType, q.dims, components);\n        const kInput = inputVariable('key', key.dataType, key.dims, components);\n        const inputVars = [qInput, kInput];\n        const relativePositionBiasInput = relativePositionBias ?\n            inputVariable('relative_position_bias', relativePositionBias.dataType, relativePositionBias.dims.length) :\n            undefined;\n        if (relativePositionBiasInput) {\n          inputVars.push(relativePositionBiasInput);\n        }\n        const output = outputVariable('output', q.dataType, probsShape);\n        // const dataType = tensorTypeToWsglStorageType(q.dataType);\n        const f32Type = tensorTypeToWsglValueType(DataType.float, components);\n\n        const uniforms: UniformsArrayType = [\n          {name: 'M', type: 'u32'}, {name: 'K', type: 'u32'}, {name: 'N', type: 'u32'},\n          {name: 'num_heads', type: 'u32'}, {name: 'alpha', type: 'f32' as UniformDataElementType}\n        ];\n        return `\n  const TILE_SIZE = ${TILE_SIZE}u;\n\n  var<workgroup> tileQ: array<${qInput.type.storage}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileK: array<${qInput.type.storage}, ${TILE_SIZE * TILE_SIZE}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}\n  ${shaderHelper.mainStart([\n          TILE_SIZE, TILE_SIZE, 1\n        ])}\n    // x holds the N and y holds the M\n    let headIdx = workgroup_id.z;\n    let m = workgroup_id.y * TILE_SIZE;\n    let n = workgroup_id.x * TILE_SIZE;\n    let qOffset = uniforms.M * uniforms.K * headIdx + m * uniforms.K;\n    let kOffset = uniforms.N * uniforms.K * headIdx + n * uniforms.K;\n\n    var value = ${f32Type}(0);\n    for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n      if (global_id.y < uniforms.M && w + local_id.x < uniforms.K) {\n        tileQ[TILE_SIZE * local_id.y + local_id.x] = q[qOffset + local_id.y * uniforms.K + w + local_id.x];\n      }\n      if (n + local_id.y < uniforms.N && w + local_id.x < uniforms.K) {\n        tileK[TILE_SIZE * local_id.y + local_id.x] = key[kOffset + local_id.y * uniforms.K + w + local_id.x];\n      }\n      workgroupBarrier();\n\n      for (var k: u32 = 0u; k < TILE_SIZE && w+k < uniforms.K; k++) {\n        value += ${f32Type}(tileQ[TILE_SIZE * local_id.y + k] * tileK[TILE_SIZE * local_id.x + k]);\n      }\n\n      workgroupBarrier();\n    }\n\n    let headOffset = headIdx * uniforms.M * uniforms.N;\n    if (global_id.y < uniforms.M && global_id.x < uniforms.N) {\n      let outputIdx = headOffset + global_id.y * uniforms.N + global_id.x;\n      var sum: f32 = ${(() => {\n          switch (components) {\n            case 1:\n              return 'value';\n            case 2:\n              return 'value.x + value.y';\n            case 4:\n              return 'value.x + value.y + value.z + value.w';\n            default:\n              throw new Error(`Unsupported components: ${components}`);\n          }\n        })()};\n\n  ${(() => {\n          if (relativePositionBiasInput) {\n            return `\n      let batch = workgroup_id.z / uniforms.num_heads;\n      let head = workgroup_id.z % uniforms.num_heads;\n      var indices = ${relativePositionBiasInput.type.indices}(batch, head, global_id.y, global_id.x);\n      output[outputIdx] = ${output.type.value}(sum * uniforms.alpha) + ${\n                relativePositionBiasInput.getByIndices('indices')};`;\n          }\n          return `output[outputIdx] = ${output.type.value} (sum * uniforms.alpha);`;\n        })()}\n    }\n  }`;\n      };\n      return {\n        name: 'AttentionProbs',\n        shaderCache: {hint: `${components}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: probsShape, dataType: q.dataType, gpuDataType: GpuDataType.default}],\n          dispatchGroup: dispatch,\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n\n\nconst createVxAttentionScoreProgramInfo =\n    (_context: ComputeContext, probs: TensorView, v: TensorView, params: AttentionParameters,\n     pastSequenceLength: number) => {\n      const totalSequenceLength = pastSequenceLength + params.kvSequenceLength;\n      const outputShape = [params.batchSize, params.sequenceLength, params.vHiddenSize];\n      const TILE_SIZE = 12;\n      const dispatch = {\n        x: Math.ceil(params.vHeadSize / TILE_SIZE),\n        y: Math.ceil(params.sequenceLength / TILE_SIZE),\n        z: params.batchSize * params.numHeads\n      };\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: params.sequenceLength}, {type: DataType.uint32, data: totalSequenceLength},\n        {type: DataType.uint32, data: params.vHeadSize}, {type: DataType.uint32, data: params.numHeads},\n        {type: DataType.uint32, data: params.vHiddenSize}\n      ];\n\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const probsHelper = inputVariable('probs', probs.dataType, probs.dims);\n        const vHelper = inputVariable('v', v.dataType, v.dims);\n        const output = outputVariable('output', probs.dataType, outputShape);\n        const uniforms: UniformsArrayType = [\n          {name: 'M', type: 'u32'}, {name: 'K', type: 'u32'}, {name: 'N', type: 'u32'},\n          {name: 'num_heads', type: 'u32'}, {name: 'v_hidden_size', type: 'u32'}\n        ];\n        return `\n  const TILE_SIZE = ${TILE_SIZE}u;\n  var<workgroup> tileQ: array<${probsHelper.type.value}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileK: array<${probsHelper.type.value}, ${TILE_SIZE * TILE_SIZE}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(probsHelper, vHelper, output)}\n  ${shaderHelper.mainStart([\n          TILE_SIZE, TILE_SIZE, 1\n        ])}\n   let headIdx = workgroup_id.z;\n   let m = global_id.y;\n   let n = global_id.x;\n\n   let offsetA = headIdx * (uniforms.M * uniforms.K) + m * uniforms.K;\n   let offsetB = headIdx * (uniforms.N * uniforms.K) + n;\n\n   var value = ${probsHelper.type.storage}(0);\n   for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n     if (m < uniforms.M && w + local_id.x < uniforms.K) {\n       tileQ[TILE_SIZE * local_id.y + local_id.x] = probs[offsetA + w + local_id.x];\n     }\n     if (n < uniforms.N && w + local_id.y < uniforms.K) {\n       tileK[TILE_SIZE * local_id.y + local_id.x] = v[offsetB + (w + local_id.y) * uniforms.N];\n     }\n     workgroupBarrier();\n     for (var k: u32 = 0u; k < TILE_SIZE && w+k < uniforms.K; k++) {\n       value += tileQ[TILE_SIZE * local_id.y + k] * tileK[TILE_SIZE * k + local_id.x];\n     }\n     workgroupBarrier();\n   }\n\n   // we need to transpose output from BNSH_v to BSND_v\n   let batchIdx = workgroup_id.z / uniforms.num_heads;\n   let currentBatchHeadNumber = workgroup_id.z % uniforms.num_heads;\n   if (m < uniforms.M && n < uniforms.N) {\n     let outputIdx = batchIdx * uniforms.M * uniforms.v_hidden_size + m * uniforms.v_hidden_size\n       + currentBatchHeadNumber * uniforms.N + n;\n     output[outputIdx] = value;\n   }\n  }`;\n      };\n\n      return {\n        name: 'AttentionScore',\n        shaderCache: {inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: probs.dataType, gpuDataType: GpuDataType.default}],\n          dispatchGroup: dispatch,\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n\nexport const applyAttention =\n    (context: ComputeContext, q: TensorView, k: TensorView, v: TensorView, _maskIndex: TensorView|undefined,\n     _past: TensorView|undefined, pastKey: TensorView|undefined, pastValue: TensorView|undefined,\n     relativePositionBias: TensorView|undefined, parameters: AttentionParameters, attributes: AttentionAttrs) => {\n      const outputPresentKey = context.outputCount > 1;\n      const outputPresentValue = context.outputCount > 2;\n      const pastSequenceLength = (outputPresentKey && outputPresentValue) ? parameters.pastSequenceLength : 0;\n      const totalSequenceLength = pastSequenceLength + parameters.kvSequenceLength;\n      // Concatinate pastKey and K to produce presentKey.\n      const presentKeyShape = [parameters.batchSize, parameters.numHeads, totalSequenceLength, parameters.headSize];\n      const concatKeyInputs = pastKey ? [pastKey, k] : [k];\n      const key = outputPresentKey ? context.compute(\n                                         createConcatProgramInfo(concatKeyInputs, 2, presentKeyShape, k.dataType),\n                                         {inputs: concatKeyInputs, outputs: [1]})[0] :\n                                     k;\n\n      // Concatinate pastValue and V to produce presentValue.\n      const presentValueShape = [parameters.batchSize, parameters.numHeads, totalSequenceLength, parameters.headSize];\n      const concatValueInputs = pastValue ? [pastValue, v] : [v];\n      const value = outputPresentValue ?\n          context.compute(\n              createConcatProgramInfo(concatValueInputs, 2, presentValueShape, v.dataType),\n              {inputs: concatValueInputs, outputs: [2]})[0] :\n          v;\n      const inputsK = [q, key];\n      if (relativePositionBias) {\n        inputsK.push(relativePositionBias);\n      }\n\n      // Run AttentionProbs\n      const probs = context.compute(\n          createAttentionProbsProgramInfo(\n              context, q, key, relativePositionBias, parameters, attributes, pastSequenceLength),\n          {inputs: inputsK, outputs: [-1]})[0];\n\n      // Run Softmax\n      context.compute(\n          createInPlaceSoftmaxProgramInfo(\n              context, probs, parameters.batchSize * parameters.numHeads * parameters.sequenceLength,\n              totalSequenceLength),\n          {inputs: [probs], outputs: []});\n\n      // Run AttrionScore\n      const inputsV = [probs, value];\n      context.compute(\n          createVxAttentionScoreProgramInfo(context, probs, value, parameters, pastSequenceLength),\n          {inputs: inputsV, outputs: [0]});\n    };\n\nconst prepare = (context: ComputeContext, parameters: AttentionParameters) => {\n  const outputShape = [\n    parameters.batchSize,\n    parameters.numHeads,\n    parameters.sequenceLength,\n    parameters.headSize,\n  ];\n  const M = parameters.sequenceLength;\n  const K = parameters.inputHiddenSize;\n  const N = parameters.headSize;\n  const TILE_SIZE = 12;\n  const dispatch = {\n    x: Math.ceil(parameters.headSize / TILE_SIZE),\n    y: Math.ceil(parameters.sequenceLength / TILE_SIZE),\n    z: parameters.batchSize * parameters.numHeads\n  };\n  const inputs = [context.inputs[0], context.inputs[1], context.inputs[2]];\n  const programUniforms: ProgramUniform[] = [\n    {type: DataType.uint32, data: M}, {type: DataType.uint32, data: K}, {type: DataType.uint32, data: N},\n    {type: DataType.uint32, data: parameters.numHeads}, {type: DataType.uint32, data: parameters.headSize},\n    {type: DataType.uint32, data: parameters.hiddenSize},\n    {type: DataType.uint32, data: parameters.hiddenSize + parameters.hiddenSize + parameters.vHiddenSize}\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const outputQ = outputVariable('output_q', inputs[0].dataType, outputShape);\n    const outputK = outputVariable('output_k', inputs[0].dataType, outputShape);\n    const outputV = outputVariable('output_v', inputs[0].dataType, outputShape);\n    const input = inputVariable('input', inputs[0].dataType, inputs[0].dims);\n    const weight = inputVariable('weight', inputs[1].dataType, inputs[1].dims);\n    const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims);\n    const dataType = input.type.storage;\n\n    const uniforms: UniformsArrayType = [\n      {name: 'M', type: 'u32'}, {name: 'K', type: 'u32'}, {name: 'N', type: 'u32'}, {name: 'num_heads', type: 'u32'},\n      {name: 'head_size', type: 'u32'}, {name: 'hidden_size', type: 'u32'}, {name: 'ldb', type: 'u32'}\n    ];\n    return `\n  const TILE_SIZE = ${TILE_SIZE}u;\n  var<workgroup> tileInput: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileWeightQ: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileWeightK: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileWeightV: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(input, weight, bias, outputQ, outputK, outputV)}\n  ${shaderHelper.mainStart([\n      TILE_SIZE, TILE_SIZE, 1\n    ])}\n    let batchIndex = workgroup_id.z / uniforms.num_heads;\n    let headNumber = workgroup_id.z % uniforms.num_heads;\n    let m = global_id.y;\n    let n = global_id.x;\n\n    let inputOffset = batchIndex * (uniforms.M * uniforms.K) + m * uniforms.K;\n    let biasOffsetQ = headNumber * uniforms.head_size;\n    let biasOffsetK = uniforms.hidden_size + biasOffsetQ;\n    let biasOffsetV = uniforms.hidden_size + biasOffsetK;\n\n    var valueQ = ${dataType}(0);\n    var valueK = ${dataType}(0);\n    var valueV = ${dataType}(0);\n    for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n      if (m < uniforms.M && w + local_id.x < uniforms.K) {\n        tileInput[TILE_SIZE * local_id.y + local_id.x] = input[inputOffset + w + local_id.x];\n      }\n      if (n < uniforms.N && w + local_id.y < uniforms.K) {\n        let offset = n + (w + local_id.y) * uniforms.ldb;\n        tileWeightQ[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetQ + offset];\n        tileWeightK[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetK + offset];\n        tileWeightV[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetV + offset];\n      }\n      workgroupBarrier();\n      for (var k: u32 = 0u; k<TILE_SIZE && w+k < uniforms.K; k++) {\n        let inputTileOffset = TILE_SIZE * local_id.y + k;\n        let weightTileOffset = TILE_SIZE * k + local_id.x;\n        valueQ += tileInput[inputTileOffset] * tileWeightQ[weightTileOffset];\n        valueK += tileInput[inputTileOffset] * tileWeightK[weightTileOffset];\n        valueV += tileInput[inputTileOffset] * tileWeightV[weightTileOffset];\n      }\n\n      workgroupBarrier();\n    }\n\n    let headOffset = (m * uniforms.N + n) % uniforms.head_size;\n    valueQ += bias[headOffset + biasOffsetQ];\n    valueK += bias[headOffset + biasOffsetK];\n    valueV += bias[headOffset + biasOffsetV];\n\n    let offset = workgroup_id.z * uniforms.M * uniforms.N;\n    if (m < uniforms.M && n < uniforms.N) {\n      let outputIdx = offset + m * uniforms.N + n;\n      output_q[outputIdx] = valueQ;\n      output_k[outputIdx] = valueK;\n      output_v[outputIdx] = valueV;\n    }\n  }`;\n  };\n\n  return context.compute(\n      {\n        name: 'AttentionPrepare',\n        shaderCache: {inputDependencies: ['type', 'type', 'type']},\n        getRunData: () => ({\n          outputs: [\n            {dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: GpuDataType.default},\n            {dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: GpuDataType.default},\n            {dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: GpuDataType.default},\n          ],\n          dispatchGroup: dispatch,\n          programUniforms\n        }),\n        getShaderSource,\n      },\n      {inputs, outputs: [-1, -1, -1]});\n};\n\nexport const attention = (context: ComputeContext, attributes: AttentionAttrs): void => {\n  const params = validateAttentionInputs(context.inputs, attributes);\n\n  const [q, k, v] = prepare(context, params);\n\n  return applyAttention(\n      context, q, k, v, context.inputs[4], undefined, undefined, undefined, context.inputs[5], params, attributes);\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {env} from 'onnxruntime-common';\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, getMaxComponents, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface BatchNormAttributes extends AttributeWithCacheKey {\n  readonly epsilon: number;\n  readonly momentum: number;\n  readonly spatial: boolean;\n  readonly trainingMode: boolean;\n  readonly format: 'NHWC'|'NCHW';\n  readonly outputCount: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: BatchNormAttributes): void => {\n  if (!inputs || inputs.length !== 5) {\n    throw new Error('BatchNormalization requires 5 inputs');\n  }\n\n  const checkShapeEqual = (actual: readonly number[], expected: readonly number[], message: string) => {\n    const r = expected.length;\n    if (r !== actual.length) {\n      throw new Error(`${message}: num dimensions != ${r}`);\n    }\n    expected.forEach((v, i) => {\n      if (v !== actual[i]) {\n        throw new Error(`${message}: dim[${i}] do not match`);\n      }\n    });\n  };\n\n  if (inputs[0].dims.length > 1) {\n    const shape = attributes.format === 'NHWC' ?\n        (attributes.spatial ? inputs[0].dims.slice(-1) :\n                              inputs[0].dims.slice(-1).concat(inputs[0].dims.slice(1, inputs[0].dims.length - 1))) :\n        inputs[0].dims.slice(1, attributes.spatial ? 2 : undefined);\n    checkShapeEqual(inputs[1].dims, shape, 'Invalid input scale');\n    checkShapeEqual(inputs[2].dims, shape, 'Invalid input B');\n    checkShapeEqual(inputs[3].dims, shape, 'Invalid input mean');\n    checkShapeEqual(inputs[4].dims, shape, 'Invalid input var');\n  } else {\n    checkShapeEqual(inputs[1].dims, [1], 'Invalid input scale');\n    checkShapeEqual(inputs[2].dims, [1], 'Invalid input B');\n    checkShapeEqual(inputs[3].dims, [1], 'Invalid input mean');\n    checkShapeEqual(inputs[4].dims, [1], 'Invalid input var');\n  }\n};\n\nconst createBatchNormInferenceProgramInfo =\n    (inputs: readonly TensorView[], attributes: BatchNormAttributes): ProgramInfo => {\n      const {epsilon, spatial, format} = attributes;\n      const yShape = inputs[0].dims;\n      const components = spatial ? getMaxComponents(yShape[yShape.length - 1]) : 1;\n      const cComponents = format === 'NHWC' && yShape.length > 1 ? components : 1;\n      const outputSize = ShapeUtil.size(yShape) / components;\n      // Only support uniforms for opset version >= 9 (spatial = true).\n      const useShapesUniforms = spatial;\n      const shapeOrRank = useShapesUniforms ? yShape.length : yShape;\n      const x = inputVariable('x', inputs[0].dataType, inputs[0].dims, components);\n      const scale = inputVariable('scale', inputs[1].dataType, inputs[1].dims, cComponents);\n      const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims, cComponents);\n      const inputMean = inputVariable('inputMean', inputs[3].dataType, inputs[3].dims, cComponents);\n      const inputVar = inputVariable('inputVar', inputs[4].dataType, inputs[4].dims, cComponents);\n      const y = outputVariable('y', inputs[0].dataType, shapeOrRank, components);\n      // TODO: support inputs with different data type. Current we need to make sure all inputs have the same data type.\n      // Otherwise, the shader compilation will fail.\n      const calcCOffset = (): string => {\n        let cOffset = '';\n        if (spatial) {\n          cOffset = `let cOffset = ${\n              yShape.length === 1   ? '0u' :\n                  format === 'NHWC' ? `outputIndices[${yShape.length - 1}] / ${components}` :\n                                      'outputIndices[1]'};`;\n        } else {\n          if (format === 'NCHW') {\n            cOffset = `\n            ${y.indicesSet('outputIndices', '0', '0')}\n            let cOffset = ${y.indicesToOffset('outputIndices')};`;\n          } else {\n            // update C channel.\n            cOffset = `var cIndices = ${scale.type.indices}(0);\n                       cIndices[0] = outputIndices[${yShape.length - 1}];`;\n            // update D1 x ... x Dn channels.\n            for (let i = 1; i < scale.rank; i++) {\n              cOffset += `cIndices[${i}] = outputIndices[${i}];`;\n            }\n            cOffset += `let cOffset = ${scale.indicesToOffset('cIndices')};`;\n          }\n        }\n        return cOffset;\n      };\n      const getInferenceModeShaderSource = (helper: ShaderHelper) => `\n  const epsilon = ${epsilon};\n  ${helper.registerUniform('outputSize', 'u32').declareVariables(x, scale, bias, inputMean, inputVar, y)}\n  ${helper.mainStart()}\n  ${helper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n    var outputIndices = ${y.offsetToIndices(`global_idx * ${components}`)};\n    ${calcCOffset()}\n    let scale = ${scale.getByOffset('cOffset')};\n    let bias = ${bias.getByOffset('cOffset')};\n    let inputMean = ${inputMean.getByOffset('cOffset')};\n    let inputVar = ${inputVar.getByOffset('cOffset')};\n    let x = ${x.getByOffset('global_idx')};\n    let value = (x - inputMean) * inverseSqrt(inputVar + epsilon) * scale + bias;\n    ${y.setByOffset('global_idx', 'value')}\n  }`;\n      return {\n        name: 'BatchNormalization',\n        shaderCache: {\n          hint: `${attributes.epsilon}_${attributes.format}_${spatial}_${components}`,\n          inputDependencies: useShapesUniforms ? ['rank', 'type', 'type', 'type', 'type'] : undefined,\n        },\n        getShaderSource: getInferenceModeShaderSource,\n        getRunData: () => ({\n          outputs: [{dims: inputs[0].dims, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms: useShapesUniforms ?\n              [\n                {type: DataType.uint32, data: outputSize},\n                ...createTensorShapeVariables(yShape),\n              ] :\n              [\n                {type: DataType.uint32, data: outputSize},\n              ],\n        }),\n      };\n    };\n\nexport const parseBatchNormAttributes = (attributes: Record<string, unknown>): BatchNormAttributes =>\n    createAttributeWithCacheKey(attributes as Omit<BatchNormAttributes, keyof AttributeWithCacheKey>);\n\nexport const batchNorm = (context: ComputeContext, attributes: Record<string, unknown>): void => {\n  const {inputs, outputCount} = context;\n  const updatedAttributes = parseBatchNormAttributes({...attributes, outputCount});\n  if (env.webgpu.validateInputContent) {\n    validateInputs(inputs, updatedAttributes);\n  }\n  if (attributes.trainingMode) {\n    throw new Error('BatchNormalization trainingMode is not supported yet.');\n  } else {\n    context.compute(createBatchNormInferenceProgramInfo(inputs, updatedAttributes));\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {inputVariable, outputVariable, ShaderHelper} from './common';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (inputs[0].dims.length !== 3) {\n    throw new Error('input should have 3 dimensions');\n  }\n\n  if (![320, 640, 1280].includes(inputs[0].dims[2])) {\n    throw new Error('number of channels should be 320, 640 or 1280');\n  }\n\n  if (inputs[1].dims.length !== 1) {\n    throw new Error('bias is expected to have 1 dimensions');\n  }\n\n  if (inputs[0].dims[2] !== inputs[1].dims[0]) {\n    throw new Error('last dimension of input and bias are not the same');\n  }\n};\n\nconst createBiasAddProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const outputShape = inputs[0].dims;\n\n  const channels = inputs[0].dims[2];\n  // since channel number can be only 320/640/1280, it's always divisable by 4\n  const outputSize = ShapeUtil.size(outputShape) / 4;\n\n  const dataType = inputs[0].dataType;\n  const input = inputVariable('input', dataType, outputShape, 4);\n  const bias = inputVariable('bias', dataType, [channels], 4);\n  const residual = inputVariable('residual', dataType, outputShape, 4);\n  const output = outputVariable('output', dataType, outputShape, 4);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  const channels = ${channels}u / 4;\n  ${shaderHelper.declareVariables(input, bias, residual, output)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}\n    let value = ${input.getByOffset('global_idx')}\n      + ${bias.getByOffset('global_idx % channels')} + ${residual.getByOffset('global_idx')};\n    ${output.setByOffset('global_idx', 'value')}\n  }`;\n\n  return {\n    name: 'BiasAdd',\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)}\n    }),\n    getShaderSource,\n  };\n};\n\nexport const biasAdd = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  context.compute(createBiasAddProgramInfo(context.inputs));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {MAX_CLIP, MIN_CLIP, ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglValueType} from './common';\n\ntype BuiltinFunctionName = string;\ntype ElementwiseCustomExpression = (expression: string) => string;\ntype ElementwiseFunctionCall = BuiltinFunctionName|ElementwiseCustomExpression;\n\nconst createElementwiseProgramShader =\n    (shaderHelper: ShaderHelper, datasize: number, inputDataType: number, outputDataType: number,\n     funcCall: ElementwiseFunctionCall, additionalImplementation?: string): string => {\n      const vecSize = Math.ceil(datasize / 4);\n\n      let expression = '';\n      if (typeof funcCall === 'string') {\n        expression = `${funcCall}(a)`;\n      } else {\n        expression = funcCall('a');\n      }\n\n      const input = inputVariable('inputData', inputDataType, [vecSize], 4);\n      const output = outputVariable('outputData', outputDataType, [vecSize], 4);\n\n      return `\n      ${shaderHelper.registerUniform('vec_size', 'u32').declareVariables(input, output)}\n\n  ${additionalImplementation ?? ''}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.vec_size')}\n\n    let a = ${input.getByOffset('global_idx')};\n    ${output.setByOffset('global_idx', expression)}\n  }`;\n    };\n\nconst createElementwiseProgramInfo =\n    (input: TensorView, name: string, funcCall: ElementwiseFunctionCall, additionalImplementation?: string,\n     cacheKey?: string, outputDataType: number = input.dataType): ProgramInfo => ({\n      name,\n      shaderCache: {hint: cacheKey, inputDependencies: ['type']},\n      getShaderSource: shaderHelper => createElementwiseProgramShader(\n          shaderHelper, ShapeUtil.size(input.dims), input.dataType, outputDataType, funcCall, additionalImplementation),\n      getRunData: (inputTensors) => ({\n        outputs: [{dims: input.dims, dataType: outputDataType}],\n        dispatchGroup:\n            {x: Math.ceil(ShapeUtil.size(inputTensors[0].dims) / 64 /* workgroup size */ / 4 /* vec size */)},\n        programUniforms: [\n          {type: DataType.uint32, data: Math.ceil(ShapeUtil.size(input.dims) / 4)},\n        ],\n      })\n    });\n\nexport const abs = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Abs', 'abs'));\n};\n\nexport const acos = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Acos', 'acos'));\n};\n\nexport const acosh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Acosh', 'acosh'));\n};\n\nexport const asin = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Asin', 'asin'));\n};\n\nexport const asinh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Asinh', 'asinh'));\n};\n\nexport const atan = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Atan', 'atan'));\n};\nexport const atanh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Atanh', 'atanh'));\n};\n\nexport interface CastAttributes extends AttributeWithCacheKey {\n  readonly to: number;\n  readonly saturate?: boolean;\n}\n\nexport const parseCastAttributes = (attributes: Record<string, unknown>): CastAttributes =>\n    createAttributeWithCacheKey(attributes as {to: number});\n\n\nexport const cast = (context: ComputeContext, attributes: CastAttributes): void => {\n  let func: ElementwiseFunctionCall;\n  switch (attributes.to) {\n    case DataType.float16:\n      func = 'vec4<f16>';\n      break;\n    case DataType.float:\n      func = 'vec4<f32>';\n      break;\n    case DataType.uint32:\n      func = 'vec4<u32>';\n      break;\n    case DataType.int32:\n      func = 'vec4<i32>';\n      break;\n    case DataType.bool:\n      func = 'vec4<bool>';\n      break;\n    default:\n      throw new RangeError(`not supported type (specified in attribute 'to' from 'Cast' operator): ${attributes.to}`);\n  }\n  context.compute(\n      createElementwiseProgramInfo(context.inputs[0], 'Cast', func, undefined, attributes.cacheKey, attributes.to));\n};\n\nexport interface ClipAttributes extends AttributeWithCacheKey {\n  readonly min: number;\n  readonly max: number;\n}\n\nconst generateClipAttributesFromInputs = (inputs: readonly TensorView[]): ClipAttributes => {\n  const min = (inputs.length >= 2 && inputs[1].data !== 0) ? inputs[1].getFloat32Array()[0] : MIN_CLIP;\n  const max = (inputs.length >= 3 && inputs[2].data !== 0) ? inputs[2].getFloat32Array()[0] : MAX_CLIP;\n  return createAttributeWithCacheKey({min, max});\n};\n\nexport const clip = (context: ComputeContext, clipAttributes: ClipAttributes): void => {\n  const attributes = context.inputs.length === 1 ? clipAttributes : generateClipAttributesFromInputs(context.inputs);\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(\n      createElementwiseProgramInfo(\n          context.inputs[0], 'Clip', a => `clamp(${a}, clip_min_, clip_max_)`, `\n    const clip_min_: vec4<${dataType}> = vec4(${dataType}(${attributes.min}));\n    const clip_max_: vec4<${dataType}> = vec4(${dataType}(${attributes.max}));\n`,\n          attributes.cacheKey),\n      {inputs: [0]});\n};\n\nexport const ceil = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Ceil', 'ceil'));\n};\n\nexport const cos = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Cos', 'cos'));\n};\n\nexport const cosh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Cosh', 'cosh'));\n};\n\nexport interface AlphaAttributes extends AttributeWithCacheKey {\n  readonly alpha: number;\n}\n\nexport const parseAlphaAttributes = (attributes: Record<string, unknown>): AlphaAttributes =>\n    createAttributeWithCacheKey(attributes as {alpha: number});\n\nexport const elu = (context: ComputeContext, attributes: AlphaAttributes): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'Elu', a => `elu_vf32(${a})`, `\n  const elu_alpha_ = ${dataType}(${attributes.alpha});\n\n  fn elu_f32(a: ${dataType}) -> ${dataType} {\n  return select((exp(a) - 1.0) * elu_alpha_, a, a >= 0.0);\n  }\n\n  fn elu_vf32(v: vec4<${dataType}>) -> vec4<${dataType}> {\n  return vec4(elu_f32(v.x), elu_f32(v.y), elu_f32(v.z), elu_f32(v.w));\n  }`,\n      attributes.cacheKey));\n};\n\nexport const erfImpl = (varType = 'f32') => `\nconst r0: ${varType} = 0.3275911;\nconst r1: ${varType} = 0.254829592;\nconst r2: ${varType} = -0.284496736;\nconst r3: ${varType} = 1.421413741;\nconst r4: ${varType} = -1.453152027;\nconst r5: ${varType} = 1.061405429;\n\nfn erf_vf32(v: vec4<${varType}>) -> vec4<${varType}> {\n  let absv = abs(v);\n  let x = 1.0 / (1.0 + r0 * absv);\n  return sign(v) * (1.0 - ((((r5 * x + r4) * x + r3) * x + r2) * x + r1) * x * exp(-absv * absv));\n}`;\n\nexport const erf = (context: ComputeContext): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Erf', a => `erf_vf32(${a})`, erfImpl(dataType)));\n};\n\nexport const exp = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Exp', 'exp'));\n};\n\nexport const floor = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Floor', 'floor'));\n};\n\nexport const gelu = (context: ComputeContext): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'Gelu', a => `0.5 * ${a} * (1.0 + erf_vf32(${a} * 0.7071067811865475))`, erfImpl(dataType)));\n};\n\nexport const leakyRelu = (context: ComputeContext, attributes: AlphaAttributes): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'LeakyRelu', a => `select(leaky_relu_alpha_ * ${a}, ${a}, ${a} >= vec4<${dataType}>(0.0))`,\n      `const leaky_relu_alpha_ = ${dataType}(${attributes.alpha});`, attributes.cacheKey));\n};\n\nexport const not = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Not', a => `!${a}`));\n};\n\nexport const neg = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Neg', a => `-${a}`));\n};\n\nexport const reciprocal = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Reciprocal', a => `1.0/${a}`));\n};\n\nexport const relu = (context: ComputeContext): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'Relu', a => `select(vec4<${dataType}>(0.0), ${a}, ${a} > vec4<${dataType}>(0.0))`));\n};\n\nexport const sigmoid = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Sigmoid', a => `(1.0 / (1.0 + exp(-${a})))`));\n};\n\nexport interface HardSigmoidAttributes extends AttributeWithCacheKey {\n  readonly alpha: number;\n  readonly beta: number;\n}\n\nexport const parseHardSigmoidAttributes = (attributes: Record<string, unknown>): HardSigmoidAttributes =>\n    createAttributeWithCacheKey(attributes as {\n      alpha: number;\n      beta: number;\n    });\n\nexport const hardSigmoid = (context: ComputeContext, attributes: HardSigmoidAttributes): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'HardSigmoid',\n      a => `max(vec4<${dataType}>(0.0), min(vec4<${dataType}>(1.0), ${attributes.alpha} * ${a} + vec4<${dataType}>(${\n          attributes.beta})))`,\n      undefined, attributes.cacheKey));\n};\n\nexport const sin = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Sin', 'sin'));\n};\n\nexport const sinh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Sinh', 'sinh'));\n};\n\nexport const sqrt = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Sqrt', 'sqrt'));\n};\n\nexport const tan = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Tan', 'tan'));\n};\n\nexport const tanhExpression = (a: string) => `sign(${a}) * (1 - exp(-2 * abs(${a}))) / (1 + exp(-2 * abs(${a})))`;\n\nexport const tanh = (context: ComputeContext): void => {\n  // TODO: revisit after https://github.com/gpuweb/gpuweb/issues/4458 is resolved\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Tanh', tanhExpression));\n};\n\nexport const fastGeluImpl = (varType = 'f32') => `\nconst fast_gelu_a: ${varType} = 0.5;\nconst fast_gelu_b: ${varType} = 0.7978845608028654;\nconst fast_gelu_c: ${varType} = 0.035677408136300125;\n\nfn tanh_v(v: vec4<${varType}>) -> vec4<${varType}> {\n  return ${tanhExpression('v')};\n}\n`;\n\nexport const fastGeluExpression = (x: string) =>\n    `(fast_gelu_a + fast_gelu_a * tanh_v(${x} * (fast_gelu_c * ${x} * ${x} + fast_gelu_b))) * ${x}`;\n\nexport const fastGelu = (context: ComputeContext): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'FastGelu', fastGeluExpression, fastGeluImpl(dataType), undefined,\n      context.inputs[0].dataType));\n};\n\nexport const thresholdedRelu = (context: ComputeContext, attributes: AlphaAttributes): number => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'ThresholdedRelu', a => `select(vec4<${dataType}>(0.0), ${a}, ${a} > thresholded_relu_alpha_)`,\n      `const thresholded_relu_alpha_ = vec4<${dataType}>(${attributes.alpha});`, attributes.cacheKey));\n  return 0;\n};\n\nexport const log = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Log', 'log'));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType} from './common';\nimport {erfImpl} from './unary-op';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (inputs[0].dims.length !== 3) {\n    throw new Error('input should have 3 dimensions');\n  }\n\n  if (![2560, 5120, 10240].includes(inputs[0].dims[2])) {\n    throw new Error('hidden state should be 2560, 5120 or 10240');\n  }\n\n  if (inputs[1].dims.length !== 1) {\n    throw new Error('bias is expected to have 1 dimensions');\n  }\n\n  if (inputs[0].dims[2] !== inputs[1].dims[0]) {\n    throw new Error('last dimension of input and bias are not the same');\n  }\n};\n\nconst createBiasSplitGeluProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const outputShape = inputs[0].dims.slice();\n  outputShape[2] = outputShape[2] / 2;\n\n  const input = inputVariable('input', inputs[0].dataType, inputs[0].dims, 4);\n  const bias = inputVariable('bias', inputs[0].dataType, [inputs[0].dims[2]], 4);\n  const output = outputVariable('output', inputs[0].dataType, outputShape, 4);\n\n  const outputSize = ShapeUtil.size(outputShape) / 4;\n  const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  const M_SQRT2 = sqrt(2.0);\n  const halfChannels = ${inputs[0].dims[2] / 4 / 2}u;\n\n  ${shaderHelper.declareVariables(input, bias, output)}\n\n  ${erfImpl(dataType)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}\n    let biasIdx = global_idx % halfChannels;\n    let batchIndex = global_idx / halfChannels;\n    let inputOffset = biasIdx + batchIndex * halfChannels * 2;\n    let valueLeft = input[inputOffset] + bias[biasIdx];\n    let valueRight = input[inputOffset + halfChannels] + bias[biasIdx + halfChannels];\n    let geluRight = valueRight * 0.5 * (erf_vf32(valueRight / M_SQRT2) + 1);\n\n    ${output.setByOffset('global_idx', 'valueLeft * geluRight')}\n  }`;\n\n  return {\n    name: 'BiasSplitGelu',\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)}\n    }),\n    getShaderSource,\n  };\n};\n\nexport const biasSplitGelu = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  context.compute(createBiasSplitGeluProgramInfo(context.inputs));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {BroadcastUtil, ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\ntype BuiltinFunctionName = string;\ntype BinaryCustomExpression = (expressionA: string, expressionB: string) => string;\ntype BinaryFunctionCall = BuiltinFunctionName|BinaryCustomExpression|{\n  scalar: BinaryCustomExpression;\n  vector: BinaryCustomExpression;\n};\n\nconst createBinaryOpProgramShader =\n    (shaderHelper: ShaderHelper, dimsA: readonly number[], dimsB: readonly number[], dimsOutput: readonly number[],\n     vectorize: boolean, doBroadcast: boolean, sharedDimensionDivisibleBy4: boolean, funcCall: BinaryFunctionCall,\n     typeA: number, typeB: number, typeOutput: number, additionalImplementation?: string) => {\n      let expressionScalar: BinaryCustomExpression;\n      let expressionVector: BinaryCustomExpression;\n      if (typeof funcCall === 'string') {\n        expressionScalar = expressionVector = (a, b) => `${funcCall}((${a}),(${b}))`;\n      } else if (typeof funcCall === 'function') {\n        expressionScalar = expressionVector = funcCall;\n      } else {\n        expressionScalar = funcCall.scalar;\n        expressionVector = funcCall.vector;\n      }\n\n      const output = outputVariable('outputData', typeOutput, dimsOutput.length, 4);\n      const a = inputVariable('aData', typeA, dimsA.length, 4);\n      const b = inputVariable('bData', typeB, dimsB.length, 4);\n\n      let assignment: string;\n      if (vectorize) {\n        if (doBroadcast) {\n          const isAOneElement = ShapeUtil.size(dimsA) === 1;\n          const isBOneElement = ShapeUtil.size(dimsB) === 1;\n          const aLastDimDivisibleBy4 = dimsA.length > 0 && dimsA[dimsA.length - 1] % 4 === 0;\n          const bLastDimDivisibleBy4 = dimsB.length > 0 && dimsB[dimsB.length - 1] % 4 === 0;\n          if (isAOneElement || isBOneElement) {\n            assignment = output.setByOffset(\n                'global_idx',\n                expressionVector(\n                    isAOneElement ? `${a.type.value}(${a.getByOffset('0')}.x)` : a.getByOffset('global_idx'),\n                    isBOneElement ? `${b.type.value}(${b.getByOffset('0')}.x)` : b.getByOffset('global_idx')));\n          } else {\n            assignment = `\n            let outputIndices = ${output.offsetToIndices('global_idx * 4u')};\n            let offsetA = ${a.broadcastedIndicesToOffset('outputIndices', output)};\n            let offsetB = ${b.broadcastedIndicesToOffset('outputIndices', output)};\n            ${\n                output.setByOffset(\n                    'global_idx',\n                    expressionVector(\n                        sharedDimensionDivisibleBy4 || aLastDimDivisibleBy4 ?\n                            a.getByOffset('offsetA / 4u') :\n                            `${a.type.value}(${a.getByOffset('offsetA / 4u')}[offsetA % 4u])`,\n                        sharedDimensionDivisibleBy4 || bLastDimDivisibleBy4 ?\n                            b.getByOffset('offsetB / 4u') :\n                            `${b.type.value}(${b.getByOffset('offsetB / 4u')}[offsetB % 4u])`))}\n          `;\n          }\n        } else {\n          assignment = output.setByOffset(\n              'global_idx', expressionVector(a.getByOffset('global_idx'), b.getByOffset('global_idx')));\n        }\n      } else {\n        if (!doBroadcast) {\n          throw new Error('no necessary to use scalar implementation for element-wise binary op implementation.');\n        }\n\n        const singleAssignment = (resStr: string, x: number, typeCast = '') => {\n          const expressionA = `aData[indexA${x}][componentA${x}]`;\n          const expressionB = `bData[indexB${x}][componentB${x}]`;\n          return `\n            let outputIndices${x} = ${output.offsetToIndices(`global_idx * 4u + ${x}u`)};\n            let offsetA${x} = ${a.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n            let offsetB${x} = ${b.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n            let indexA${x} = offsetA${x} / 4u;\n            let indexB${x} = offsetB${x} / 4u;\n            let componentA${x} = offsetA${x} % 4u;\n            let componentB${x} = offsetB${x} % 4u;\n            ${resStr}[${x}] = ${typeCast}(${expressionScalar(expressionA, expressionB)});\n          `;\n        };\n        if (typeOutput === DataType.bool) {\n          assignment = `\n            var data = vec4<u32>(0);\n            ${singleAssignment('data', 0, 'u32')}\n            ${singleAssignment('data', 1, 'u32')}\n            ${singleAssignment('data', 2, 'u32')}\n            ${singleAssignment('data', 3, 'u32')}\n            outputData[global_idx] = dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(data));`;\n        } else {\n          assignment = `\n            ${singleAssignment('outputData[global_idx]', 0)}\n            ${singleAssignment('outputData[global_idx]', 1)}\n            ${singleAssignment('outputData[global_idx]', 2)}\n            ${singleAssignment('outputData[global_idx]', 3)}\n          `;\n        }\n      }\n\n      return `\n        ${shaderHelper.registerUniform('vec_size', 'u32').declareVariables(a, b, output)}\n\n        ${additionalImplementation ?? ''}\n\n        ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.vec_size')}\n        ${assignment}\n      }`;\n    };\n\nconst createBinaryOpProgramInfo =\n    (name: string, cacheKey: string, a: TensorView, b: TensorView, funcCall: BinaryFunctionCall,\n     additionalImplementation?: string, outputDataType: number = a.dataType): ProgramInfo => {\n      const isBroadcast = !ShapeUtil.areEqual(a.dims, b.dims);\n      let outputShape = a.dims;\n      let outputSize = ShapeUtil.size(a.dims);\n\n      let vectorize = false;\n      let sharedDimensionDivisibleBy4 = false;\n\n      // TODO: deal with zero-sized tensors (eg. dims=[1,0])\n      const cacheKeyAux = [isBroadcast];\n      if (isBroadcast) {\n        const calculatedShape = BroadcastUtil.calcShape(a.dims, b.dims, false);\n        if (!calculatedShape) {\n          throw new Error('Can\\'t perform binary op on the given tensors');\n        }\n        outputShape = calculatedShape;\n        outputSize = ShapeUtil.size(outputShape);\n        const isAOneElement = ShapeUtil.size(a.dims) === 1;\n        const isBOneElement = ShapeUtil.size(b.dims) === 1;\n        const aLastDimDivisibleBy4 = a.dims.length > 0 && a.dims[a.dims.length - 1] % 4 === 0;\n        const bLastDimDivisibleBy4 = b.dims.length > 0 && b.dims[b.dims.length - 1] % 4 === 0;\n        cacheKeyAux.push(isAOneElement);\n        cacheKeyAux.push(isBOneElement);\n        cacheKeyAux.push(aLastDimDivisibleBy4);\n        cacheKeyAux.push(bLastDimDivisibleBy4);\n        // check whether vectorize can be enabled\n        let sharedDimension = 1;\n        for (let i = 1; i < outputShape.length; i++) {\n          const dimA = a.dims[a.dims.length - i] ?? 1;\n          const dimB = b.dims[b.dims.length - i] ?? 1;\n          if (dimA === dimB) {\n            sharedDimension *= dimA;\n          } else {\n            break;\n          }\n        }\n        if (sharedDimension % 4 === 0) {\n          sharedDimensionDivisibleBy4 = true;\n          vectorize = true;\n        } else if (isAOneElement || isBOneElement || aLastDimDivisibleBy4 || bLastDimDivisibleBy4) {\n          vectorize = true;\n        }\n      } else {\n        // element-wise\n        vectorize = true;\n      }\n      cacheKeyAux.push(vectorize);\n\n      return {\n        name,\n        shaderCache: {\n          hint: cacheKey + cacheKeyAux.map((x) => x.toString()).join('_'),\n          inputDependencies: ['rank', 'rank'],\n        },\n        getShaderSource: (shaderHelper) => createBinaryOpProgramShader(\n            shaderHelper, a.dims, b.dims, outputShape, vectorize, isBroadcast, sharedDimensionDivisibleBy4, funcCall,\n            a.dataType, b.dataType, outputDataType, additionalImplementation),\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: outputDataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */ / 4 /* component size */)},\n          programUniforms: [\n            {type: DataType.uint32, data: Math.ceil(ShapeUtil.size(outputShape) / 4)},\n            ...createTensorShapeVariables(a.dims, b.dims, outputShape)\n          ],\n        }),\n      };\n    };\n\nconst runBinaryOp =\n    (context: ComputeContext, name: string, funcCall: BinaryFunctionCall, additionalImplementation?: string,\n     cacheKey?: string, outputDataType?: number): void => {\n      context.compute(createBinaryOpProgramInfo(\n          name, cacheKey ?? '', context.inputs[0], context.inputs[1], funcCall, additionalImplementation,\n          outputDataType));\n    };\n\nexport const add = (context: ComputeContext): void => {\n  runBinaryOp(context, 'Add', (a, b) => `${a}+${b}`);\n};\n\nexport const div = (context: ComputeContext): void => {\n  runBinaryOp(context, 'Div', (a, b) => `${a}/${b}`);\n};\n\nexport const equal = (context: ComputeContext): void => {\n  runBinaryOp(\n      context, 'Equal', ({scalar: (a, b) => `u32(${a}==${b})`, vector: (a, b) => `vec4<u32>(${a}==${b})`}), undefined,\n      undefined, DataType.bool);\n};\n\nexport const mul = (context: ComputeContext): void => {\n  runBinaryOp(context, 'Mul', (a, b) => `${a}*${b}`);\n};\n\nexport const pow = (context: ComputeContext): void => {\n  const type = inputVariable('input', context.inputs[0].dataType, context.inputs[0].dims).type.value;\n  const roundStr = type === 'i32' ? 'round' : '';\n  runBinaryOp(\n      context, 'Pow', ({scalar: (a, b) => `pow_custom(${a},${b})`, vector: (a, b) => `pow_vector_custom(${a},${b})`}),\n      `\n    fn pow_custom(a : ${type}, b : ${type}) -> ${type} {\n      if (b == ${type}(0.0)) {\n        return ${type}(1.0);\n      } else if (a < ${type}(0.0) && f32(b) != floor(f32(b))) {\n        return ${type}(pow(f32(a), f32(b))); // NaN\n      }\n      return select(sign(a), ${type}(1.0), round(f32(abs(b) % ${type}(2.0))) != 1.0) * ${type}(${\n          roundStr}(pow(f32(abs(a)), f32(b))));\n    }\n    fn pow_vector_custom(a : vec4<${type}>, b : vec4<${type}>) -> vec4<${type}> {\n      // TODO: implement vectorized pow\n      return vec4<${type}>(pow_custom(a.x, b.x), pow_custom(a.y, b.y), pow_custom(a.z, b.z), pow_custom(a.w, b.w));\n    }\n      `);\n};\n\nexport const sub = (context: ComputeContext): void => {\n  runBinaryOp(context, 'Sub', (a, b) => `${a}-${b}`);\n};\n\nexport const greater = (context: ComputeContext): void => {\n  runBinaryOp(\n      context, 'Greater', ({scalar: (a, b) => `u32(${a}>${b})`, vector: (a, b) => `vec4<u32>(${a}>${b})`}), undefined,\n      undefined, DataType.bool);\n};\n\nexport const less = (context: ComputeContext): void => {\n  runBinaryOp(\n      context, 'Less', ({scalar: (a, b) => `u32(${a}<${b})`, vector: (a, b) => `vec4<u32>(${a}<${b})`}), undefined,\n      undefined, DataType.bool);\n};\n\nexport const greaterOrEqual = (context: ComputeContext): void => {\n  runBinaryOp(\n      context, 'GreaterOrEqual', ({scalar: (a, b) => `u32(${a}>=${b})`, vector: (a, b) => `vec4<u32>(${a}>=${b})`}),\n      undefined, undefined, DataType.bool);\n};\n\nexport const lessOrEqual = (context: ComputeContext): void => {\n  runBinaryOp(\n      context, 'LessOrEqual', ({scalar: (a, b) => `u32(${a}<=${b})`, vector: (a, b) => `vec4<u32>(${a}<=${b})`}),\n      undefined, undefined, DataType.bool);\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {MAX_CLIP, MIN_CLIP} from '../../util';\nimport {ProgramUniform} from '../types';\n\nimport {UniformsArrayType} from './common';\n\nexport interface InternalActivationAttributes {\n  readonly activation: string;\n  readonly clipMin?: number;\n  readonly clipMax?: number;\n  readonly alpha?: number;\n  readonly beta?: number;\n}\n\nexport const getActivationSnippet =\n    (attributes: InternalActivationAttributes, valueType: string, baseType = 'f32'): string => {\n      switch (attributes.activation) {\n        case 'Relu':\n          return `value = max(value, ${valueType}(0.0));`;\n        case 'Sigmoid':\n          return `value = (${valueType}(1.0) / (${valueType}(1.0) + exp(-value)));`;\n        case 'Clip':\n          return `value = clamp(value, ${valueType}(${baseType}(uniforms.clip_min)), ${valueType}(${\n              baseType}(uniforms.clip_max)));`;\n        case 'HardSigmoid':\n          return `value = max(${valueType}(0.0), min(${valueType}(1.0), ${baseType}(uniforms.alpha) * value + ${\n              baseType}(uniforms.beta)));`;\n        case 'LeakyRelu':\n          return `value = select(${baseType}(uniforms.alpha) * value, value, value >= ${valueType}(0.0));`;\n        case '':\n          return '';\n        // TODO: adding other activations that can be fused.\n        default:\n          throw new Error(`Unsupported activation ${attributes.activation}`);\n      }\n    };\n\nexport const appendActivationUniformsData =\n    (attributes: InternalActivationAttributes, programUniform: ProgramUniform[]) => {\n      if (attributes.activation === 'Clip') {\n        programUniform.push(\n            {type: DataType.float, data: attributes.clipMax!}, {type: DataType.float, data: attributes.clipMin!});\n      } else if (attributes.activation === 'HardSigmoid') {\n        programUniform.push(\n            {type: DataType.float, data: attributes.alpha!}, {type: DataType.float, data: attributes.beta!});\n      } else if (attributes.activation === 'LeakyRelu') {\n        programUniform.push({type: DataType.float, data: attributes.alpha!});\n      }\n    };\n\nexport const appendActivationUniforms = (attributes: InternalActivationAttributes, uniforms: UniformsArrayType) => {\n  if (attributes.activation === 'Clip') {\n    uniforms.push({name: 'clip_max', type: 'f32'}, {name: 'clip_min', type: 'f32'});\n  } else if (attributes.activation === 'HardSigmoid') {\n    uniforms.push({name: 'alpha', type: 'f32'}, {name: 'beta', type: 'f32'});\n  } else if (attributes.activation === 'LeakyRelu') {\n    uniforms.push({name: 'alpha', type: 'f32'});\n  }\n};\n\nexport const parseInternalActivationAttributes =\n    (attributes: Record<string, unknown>|undefined): InternalActivationAttributes => {\n      const activation = attributes?.activation as string || '';\n      if (activation === 'HardSigmoid') {\n        const [alpha, beta] = attributes?.activation_params as [number, number] || [0.2, 0.5];\n        return {activation, alpha, beta};\n      } else if (activation === 'Clip') {\n        const [clipMin, clipMax] = attributes?.activation_params as [number, number] || [MIN_CLIP, MAX_CLIP];\n        return {activation, clipMax, clipMin};\n      } else if (activation === 'LeakyRelu') {\n        const [alpha] = attributes?.activation_params as [number] || [0.01];\n        return {activation, alpha};\n      }\n      return {activation};\n    };\n", "/**\n * @license\n * Copyright 2021 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/activation_util.ts\n//\n// modified to fit the needs of the project\n\nexport const typeSnippet = (component: number, dataType: string) => {\n  switch (component) {\n    case 1:\n      return dataType;\n    case 2:\n      return `vec2<${dataType}>`;\n    case 3:\n      return `vec3<${dataType}>`;\n    case 4:\n      return `vec4<${dataType}>`;\n    default:\n      throw new Error(`${component}-component is not supported.`);\n  }\n};\n\nexport const biasSnippet = (hasBias: boolean): string => `\n      ${hasBias ? 'value = value + getBiasByOutputCoords(coords);' : ''}\n      `;\n", "/**\n * @license\n * Copyright 2020 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-core/src/ops/conv_util.ts\n//\n// modified to fit the needs of the project\n\nexport const utilFunctions = (strideStr: string) => (`\nfn getIndexFromCoords4D(coords : vec4<i32>, shape : vec4<i32>) -> i32 {\n  return dot(coords, vec4<i32>(\n      shape.y * shape.z * shape.w, shape.z * shape.w, shape.w, 1));\n}\nfn getOutputIndexFromCoords(coords : vec4<i32>) -> i32 {\n  return dot(coords, vec4<i32>(\n    i32(${strideStr}.x), i32(${strideStr}.y), i32(${strideStr}.z), 1));\n}\n`);\n", "/**\n * @license\n * Copyright 2019 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/matmul_packed_webgpu.ts\n//\n// modified to fit the needs of the project\n\nimport {DataType} from '../../../../wasm-common';\nimport {TensorView} from '../../../tensor-view';\nimport {ShapeUtil} from '../../../util';\nimport {ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../../types';\nimport {createTensorShapeVariables, getBroadcastDims, IndicesHelper, inputVariable, internalVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from '../common';\nimport {appendActivationUniforms, appendActivationUniformsData, getActivationSnippet, InternalActivationAttributes} from '../fuse-utils';\n\nimport {typeSnippet} from './activation_util';\n\nconst writeDataToSubAVec4Snippet = (transpose: boolean, batchDims?: IndicesHelper) => {\n  if (transpose) {\n    return `\n        mm_Asub[inputRow][inputCol] = mm_readA(batch,\n          kStart + inputRow,\n          globalRowStart / innerElementSize + inputCol${batchDims ? ', batchIndices' : ''});\n        `;\n\n  } else {\n    return `\n        mm_Asub[inputRow][inputCol] = mm_readA(batch,\n          globalRow + innerRow,\n          kStart / innerElementSize + inputCol${batchDims ? ', batchIndices' : ''});\n        `;\n  }\n};\n\nconst calculateResultSnippet = (transposeA: boolean, innerElementSize: number) => {\n  if (transposeA) {\n    return `\n        let ACached0 = mm_Asub[k * innerElementSize][localRow];\n        let ACached1 = mm_Asub[k * innerElementSize + 1][localRow];\n        let ACached2 = mm_Asub[k * innerElementSize + 2][localRow];\n        ${innerElementSize === 3 ? '' : 'let ACached3 = mm_Asub[k * innerElementSize + 3][localRow];'}\n        for (var i = 0; i < rowPerThread; i = i + 1) {\n          acc[i] = BCached0 * ACached0[i] + acc[i];\n          acc[i] = BCached1 * ACached1[i] + acc[i];\n          acc[i] = BCached2 * ACached2[i] + acc[i];\n          ${innerElementSize === 3 ? '' : 'acc[i] = BCached3 * ACached3[i] + acc[i];'}\n        }`;\n  } else {\n    return `\n        for (var i = 0; i < rowPerThread; i = i + 1) {\n          let ACached = mm_Asub[tileRow + i][k];\n          acc[i] = BCached0 * ACached.x + acc[i];\n          acc[i] = BCached1 * ACached.y + acc[i];\n          acc[i] = BCached2 * ACached.z + acc[i];\n          ${innerElementSize === 3 ? '' : 'acc[i] = BCached3 * ACached.w + acc[i];'}\n        }`;\n  }\n};\n\nexport const makeMatMulPackedVec4Source =\n    (workPerThread: number[], workgroupSize: [number, number, number], type = 'f32', batchDims?: IndicesHelper,\n     transposeA = false, tileInner = 32, splitK = false, splitedDimInner = 32): string => {\n      const tileAOuter = workgroupSize[1] * workPerThread[1];\n      const tileBOuter = workgroupSize[0] * workPerThread[0];\n      const tileAWidth = transposeA ? tileAOuter : tileInner;\n      const tileAHight = transposeA ? tileInner : tileAOuter;\n      const innerElementSize = tileAWidth / workgroupSize[0];\n      const rowPerThreadB = tileInner / workgroupSize[1];\n\n      if (!(((transposeA && innerElementSize === 4 && workPerThread[1] === 4) ||\n             (!transposeA && (innerElementSize === 3 || innerElementSize === 4))) &&\n            tileAWidth % workgroupSize[0] === 0 && tileInner % workgroupSize[1] === 0 && workPerThread[0] === 4)) {\n        throw new Error(`If transposeA ${transposeA} is true, innerElementSize ${\n            innerElementSize} and workPerThread[1] ${workPerThread[1]} must be 4.\n      Otherwise, innerElementSize ${innerElementSize} must be 3 or 4.\n  tileAWidth ${tileAWidth} must be divisible by workgroupSize[0]${workgroupSize[0]}. tileInner ${\n            tileInner} must be divisible by workgroupSize[1] ${workgroupSize[1]}. colPerThread ${\n            workPerThread[0]} must be 4.`);\n      }\n      return `\nvar<workgroup> mm_Asub: array<array<vec${innerElementSize}<${type}>, ${tileAWidth / innerElementSize}>, ${tileAHight}>;\nvar<workgroup> mm_Bsub: array<array<vec4<${type}>, ${tileBOuter / workPerThread[0]}>, ${tileInner}>;\n\nconst rowPerThread = ${workPerThread[1]};\nconst colPerThread = ${workPerThread[0]};\nconst innerElementSize = ${innerElementSize};\nconst tileInner = ${tileInner};\n\n@compute @workgroup_size(${workgroupSize[0]}, ${workgroupSize[1]}, ${workgroupSize[2]})\nfn main(@builtin(local_invocation_id) localId : vec3<u32>,\n        @builtin(global_invocation_id) globalId : vec3<u32>,\n        @builtin(workgroup_id) workgroupId : vec3<u32>) {\n  let localRow = i32(localId.y);\n  let tileRow = localRow * rowPerThread;\n  let tileCol = i32(localId.x);\n\n  let globalRow =i32(globalId.y) * rowPerThread;\n  let globalCol = i32(globalId.x);\n  let batch = ${splitK ? '0' : 'i32(globalId.z)'};\n  ${batchDims ? `let batchIndices = ${batchDims.offsetToIndices('u32(batch)')};` : ''}\n  let globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n\n  let num_tiles = ${splitK ? `${Math.ceil(splitedDimInner / tileInner)}` : '(uniforms.dim_inner - 1) / tileInner + 1'};\n  var kStart = ${splitK ? `i32(globalId.z) * ${splitedDimInner}` : '0'};\n\n  var acc: array<vec4<${type}>, rowPerThread>;\n\n  // Loop over shared dimension.\n  let tileRowB = localRow * ${rowPerThreadB};\n  for (var t = 0; t < num_tiles; t = t + 1) {\n      // Load one tile of A into local memory.\n      for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n          let inputRow = tileRow + innerRow;\n          let inputCol = tileCol;\n          ${writeDataToSubAVec4Snippet(transposeA, batchDims)}\n      }\n\n      // Load one tile of B into local memory.\n      for (var innerRow = 0; innerRow < ${rowPerThreadB}; innerRow = innerRow + 1) {\n          let inputRow = tileRowB + innerRow;\n          let inputCol = tileCol;\n          mm_Bsub[inputRow][inputCol] = mm_readB(batch, kStart + inputRow, globalCol${\n          batchDims ? ', batchIndices' : ''});\n      }\n      kStart = kStart + tileInner;\n      workgroupBarrier();\n\n      // Compute acc values for a single thread.\n      for (var k = 0; k < tileInner / innerElementSize; k = k + 1) {\n          let BCached0 = mm_Bsub[k * innerElementSize][tileCol];\n          let BCached1 = mm_Bsub[k * innerElementSize + 1][tileCol];\n          let BCached2 = mm_Bsub[k * innerElementSize + 2][tileCol];\n          ${innerElementSize === 3 ? '' : 'let BCached3 = mm_Bsub[k * innerElementSize + 3][tileCol];'}\n\n          ${calculateResultSnippet(transposeA, innerElementSize)}\n      }\n\n      workgroupBarrier();\n  }\n\n  for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      mm_write(batch, globalRow + innerRow, globalCol, acc[innerRow]);\n  }\n}`;\n    };\n\nconst writeDataToSubASnippet = (transpose: boolean, batchDims?: IndicesHelper) => {\n  if (transpose) {\n    return `\n            mm_Asub[inputRow][inputCol] = mm_readA(batch,\n              kStart + inputRow,\n              globalRowStart + inputCol${batchDims ? ', batchIndices' : ''});\n            `;\n\n  } else {\n    return `\n            mm_Asub[inputRow][inputCol] = mm_readA(batch,\n              globalRowStart + inputRow,\n              kStart + inputCol${batchDims ? ', batchIndices' : ''});\n            `;\n  }\n};\n\nconst readDataFromSubASnippet = (transposeA: boolean) =>\n    transposeA ? 'let ACached = mm_Asub[k][tileRow + innerRow];' : 'let ACached = mm_Asub[tileRow + innerRow][k];';\n\n// sequentialAccessByThreads means sequential data in memory is accessed by\n// threads, instead of a single thread (default behavior).\nexport const makeMatMulPackedSource =\n    (workPerThread: number[], workgroupSize: [number, number, number], type = 'f32', batchDims?: IndicesHelper,\n     transposeA = false, tileInner = 32, splitK = false, splitedDimInner = 32,\n     sequentialAccessByThreads = false): string => {\n      const tileAOuter = workPerThread[1] * workgroupSize[1];\n      const tileBOuter = workPerThread[0] * workgroupSize[0];\n      const tileAWidth = transposeA ? tileAOuter : tileInner;\n      const tileAHight = transposeA ? tileInner : tileAOuter;\n\n      if (!(tileAHight % workgroupSize[1] === 0 && tileAWidth % workgroupSize[0] === 0 &&\n            tileInner % workgroupSize[1] === 0)) {\n        throw new Error(`tileAHight ${tileAHight} must be divisible by workgroupSize[1]${\n            workgroupSize[1]}, tileAWidth ${tileAWidth} must be divisible by workgroupSize[0]${\n            workgroupSize[0]}, tileInner ${tileInner} must be divisible by workgroupSize[1]${workgroupSize[1]}`);\n      }\n      const rowPerThreadA = tileAHight / workgroupSize[1];\n      const colPerThreadA = tileAWidth / workgroupSize[0];\n      const rowPerThreadB = tileInner / workgroupSize[1];\n      const matmulSnippet = sequentialAccessByThreads ?\n          `\n    let localRow = i32(localId.y);\n    let localCol = i32(localId.x);\n    let globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n    let globalColStart = i32(workgroupId.x) * ${tileBOuter};\n\n    // Loop over shared dimension.\n    for (var t = 0; t < num_tiles; t = t + 1) {\n      // Load one tile of A into local memory.\n      for (var inputRow = localRow; inputRow < ${tileAHight}; inputRow = inputRow + ${workgroupSize[1]}) {\n        for (var inputCol = localCol; inputCol < ${tileAWidth}; inputCol = inputCol + ${workgroupSize[0]}) {\n          ${writeDataToSubASnippet(transposeA, batchDims)}\n        }\n      }\n      // Load one tile of B into local memory.\n      for (var inputRow = localRow; inputRow < ${tileInner}; inputRow = inputRow + ${workgroupSize[1]}) {\n            for (var inputCol = localCol; inputCol < ${tileBOuter}; inputCol = inputCol + ${workgroupSize[0]}) {\n          mm_Bsub[inputRow][inputCol] = mm_readB(batch,\n            kStart + inputRow,\n            globalColStart + inputCol${batchDims ? ', batchIndices' : ''});\n        }\n      }\n      kStart = kStart + tileInner;\n      workgroupBarrier();\n\n      // Compute acc values for a single thread.\n      var BCached : array<${type}, colPerThread>;\n      for (var k = 0; k < tileInner; k = k + 1) {\n        for (var inner = 0; inner < colPerThread; inner = inner + 1) {\n          BCached[inner] = mm_Bsub[k][localCol + inner * ${workgroupSize[0]}];\n        }\n        for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n          let ACached = ${\n              transposeA ? `mm_Asub[k][localRow + innerRow * ${workgroupSize[1]}];` :\n                           `mm_Asub[localRow + innerRow * ${workgroupSize[1]}][k];`}\n          for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n            acc[innerRow][innerCol] = acc[innerRow][innerCol] +\n                ACached * BCached[innerCol];\n          }\n        }\n      }\n      workgroupBarrier();\n    }\n    for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      let gRow = globalRowStart + localRow + innerRow * ${workgroupSize[1]};\n      for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n        let gCol = globalColStart + localCol + innerCol * ${workgroupSize[0]};\n        mm_write(batch, gRow, gCol, acc[innerRow][innerCol]);\n      }\n    }\n    ` :\n          `\nlet tileRow = i32(localId.y) * rowPerThread;\nlet tileCol = i32(localId.x) * colPerThread;\n\nlet globalRow = i32(globalId.y) * rowPerThread;\nlet globalCol = i32(globalId.x) * colPerThread;\nlet globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n\nlet tileRowA = i32(localId.y) * ${rowPerThreadA};\nlet tileColA = i32(localId.x) * ${colPerThreadA};\nlet tileRowB = i32(localId.y) * ${rowPerThreadB};\n// Loop over shared dimension.\nfor (var t = 0; t < num_tiles; t = t + 1) {\n  // Load one tile of A into local memory.\n  for (var innerRow = 0; innerRow < ${rowPerThreadA}; innerRow = innerRow + 1) {\n    for (var innerCol = 0; innerCol < ${colPerThreadA}; innerCol = innerCol + 1) {\n      let inputRow = tileRowA + innerRow;\n      let inputCol = tileColA + innerCol;\n      ${writeDataToSubASnippet(transposeA, batchDims)}\n    }\n  }\n\n  // Load one tile of B into local memory.\n  for (var innerRow = 0; innerRow < ${rowPerThreadB}; innerRow = innerRow + 1) {\n    for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n      let inputRow = tileRowB + innerRow;\n      let inputCol = tileCol + innerCol;\n      mm_Bsub[inputRow][inputCol] = mm_readB(batch,\n        kStart + inputRow,\n        globalCol + innerCol${batchDims ? ', batchIndices' : ''});\n    }\n  }\n  kStart = kStart + tileInner;\n  workgroupBarrier();\n\n  // Compute acc values for a single thread.\n  var BCached : array<${type}, colPerThread>;\n  for (var k = 0; k < tileInner; k = k + 1) {\n    for (var inner = 0; inner < colPerThread; inner = inner + 1) {\n      BCached[inner] = mm_Bsub[k][tileCol + inner];\n    }\n\n    for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      ${readDataFromSubASnippet(transposeA)}\n      for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n        acc[innerRow][innerCol] = acc[innerRow][innerCol] + ACached * BCached[innerCol];\n      }\n    }\n  }\n\n  workgroupBarrier();\n}\n\nfor (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n  for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n    mm_write(batch, globalRow + innerRow, globalCol + innerCol,\n        acc[innerRow][innerCol]);\n  }\n}\n`;\n\n      return `\n  var<workgroup> mm_Asub : array<array<${type}, ${tileAWidth}>, ${tileAHight}>;\n  var<workgroup> mm_Bsub : array<array<${type}, ${tileBOuter}>, ${tileInner}>;\n  const rowPerThread = ${workPerThread[1]};\n  const colPerThread = ${workPerThread[0]};\n  const tileInner = ${tileInner};\n\n@compute @workgroup_size(${workgroupSize[0]}, ${workgroupSize[1]}, ${workgroupSize[2]})\nfn main(@builtin(local_invocation_id) localId : vec3<u32>,\n        @builtin(global_invocation_id) globalId : vec3<u32>,\n        @builtin(workgroup_id) workgroupId : vec3<u32>) {\n    let batch = ${splitK ? '0' : 'i32(globalId.z)'};\n    ${batchDims ? `let batchIndices = ${batchDims.offsetToIndices('u32(batch)')};` : ''}\n    let num_tiles = ${\n          splitK ? `${Math.ceil(splitedDimInner / tileInner)}` : '(uniforms.dim_inner - 1) / tileInner + 1'};\n    var kStart = ${splitK ? `i32(globalId.z) * ${splitedDimInner}` : '0'};\n\n    var acc : array<array<${type}, colPerThread>, rowPerThread>;\n\n    // Without this initialization strange values show up in acc.\n    for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n        acc[innerRow][innerCol] = 0.0;\n      }\n    }\n    ${matmulSnippet}\n  }\n`;\n    };\n\nconst matMulReadWriteFnSource =\n    (component: number, hasBias: boolean, applyActivation: string, variables: IndicesHelper[],\n     batchShapes: Array<readonly number[]>, isChannelsLast = false): string => {\n      const [batchAShape, batchBShape, batchShape] = batchShapes;\n      const [batchVariable, aVariable, bVariable, outputVariable] = variables;\n      const broadCastADims = getBroadcastDims(batchAShape, batchShape);\n      const broadCastBDims = getBroadcastDims(batchBShape, batchShape);\n      const dataType = tensorTypeToWsglStorageType(variables[0].type.tensor);\n      const getAIndices = () => {\n        const aRank = aVariable.rank;\n        const batchRank = batchVariable.rank;\n        let resStr = `var aIndices: ${aVariable.type.indices};`;\n        for (let i = aRank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) {\n          resStr += `\\naIndices[${i}] = ${batchRank > 1 ? `batchIndices[${j}]` : 'batchIndices'};`;\n        }\n        broadCastADims.forEach(i => {\n          resStr += `\\naIndices[${i}] = 0;`;\n        });\n        resStr += `\\naIndices[${aRank - 2}] = u32(row);\n                   aIndices[${aRank - 1}] = u32(colIn);`;\n        return resStr;\n      };\n      const getBIndices = () => {\n        const bRank = bVariable.rank;\n        const batchRank = batchVariable.rank;\n        let resStr = `var bIndices: ${bVariable.type.indices};`;\n        for (let i = bRank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) {\n          resStr += `\\nbIndices[${i}] = ${batchRank > 1 ? `batchIndices[${j}]` : 'batchIndices'};`;\n        }\n        broadCastBDims.forEach(i => {\n          resStr += `\\nbIndices[${i}] = 0;`;\n        });\n        resStr += `\\nbIndices[${bRank - 2}] = u32(row);\n                   bIndices[${bRank - 1}] = u32(colIn);`;\n        return resStr;\n      };\n      const source = `\n    fn mm_readA(batch: i32, row: i32, colIn: i32, batchIndices: ${batchVariable.type.indices}) -> ${\n          typeSnippet(component, dataType)} {\n      var value = ${typeSnippet(component, dataType)}(0.0);\n      let col = colIn * ${component};\n      if(row < uniforms.dim_a_outer && col < uniforms.dim_inner)\n      {\n        ${getAIndices()}\n        value = ${aVariable.getByIndices('aIndices')};\n      }\n      return value;\n    }\n\n    fn mm_readB(batch: i32, row: i32, colIn: i32, batchIndices: ${batchVariable.type.indices}) -> ${\n          typeSnippet(component, dataType)} {\n      var value = ${typeSnippet(component, dataType)}(0.0);\n      let col = colIn * ${component};\n      if(row < uniforms.dim_inner && col < uniforms.dim_b_outer)\n      {\n        ${getBIndices()}\n        value = ${bVariable.getByIndices('bIndices')};\n      }\n      return value;\n    }\n\n    fn mm_write(batch: i32, row: i32, colIn: i32, valueIn: ${typeSnippet(component, dataType)}) {\n      let col = colIn * ${component};\n      if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer) {\n        var value = valueIn;\n        let coords = vec3<i32>(batch, row, colIn);\n        ${\n          hasBias ?\n              `value = value + ${isChannelsLast ? 'bias[colIn]' : `${typeSnippet(component, dataType)}(bias[row])`};` :\n                                                  ''                                    }\n        ${applyActivation}\n        ${outputVariable.setByIndices('vec3<u32>(coords)', 'value')}\n      }\n    }\n    `;\n      return source;\n    };\n\nexport const createMatmulProgramInfo =\n    (inputs: readonly TensorView[], activationAttributes: InternalActivationAttributes, outputShape: readonly number[],\n     reshapedOutputShape?: readonly number[],\n     isChannelsLast = false /* only used for conv2dByMatMul*/): ProgramInfo => {\n      const aShape = inputs[0].dims;\n      const bShape = inputs[1].dims;\n      const outerDimsA = aShape.slice(0, -2);\n      const outerDimsB = bShape.slice(0, -2);\n      const outerDims = reshapedOutputShape ? reshapedOutputShape.slice(0, -2) : outputShape.slice(0, -2);\n      const batchSize = ShapeUtil.size(outerDims);\n      const dimAOuter = aShape[aShape.length - 2];\n      const dimInner = aShape[aShape.length - 1];\n      const dimBOuter = bShape[bShape.length - 1];\n      const isVec4 = dimInner % 4 === 0 && dimBOuter % 4 === 0;\n\n      // TODO: fine tune size\n      const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];\n      const workgroupSize: [number, number, number] = [8, 8, 1];\n      const dispatch = [\n        Math.ceil(dimBOuter / workgroupSize[0] / elementsPerThread[0]),\n        Math.ceil(dimAOuter / workgroupSize[1] / elementsPerThread[1]),\n        Math.ceil(batchSize / workgroupSize[2] / elementsPerThread[2])\n      ];\n\n      const components = isVec4 ? 4 : 1;\n      const aShapeTemp = [...outerDimsA, dimAOuter, dimInner / components];\n      const aRank = aShapeTemp.length;\n      const bShapeTemp = [...outerDimsB, dimInner, dimBOuter / components];\n      const bRank = bShapeTemp.length;\n      const outputShapeTemp = [batchSize, dimAOuter, dimBOuter / components];\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.int32, data: dimAOuter}, {type: DataType.int32, data: dimBOuter},\n        {type: DataType.int32, data: dimInner}\n      ];\n      appendActivationUniformsData(activationAttributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(outerDims, aShapeTemp, bShapeTemp));\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n\n      const hasBias = inputs.length > 2;\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n        inputDependencies.push('rank');\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShapeTemp));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const batchRank = outerDims.length;\n        const batchDims = internalVariable('batchDims', inputs[0].dataType, batchRank, 1);\n        const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n\n        const A = inputVariable('a', inputs[0].dataType, aRank, components);\n        const B = inputVariable('b', inputs[1].dataType, bRank, components);\n        const output = outputVariable('result', inputs[0].dataType, outputShapeTemp.length, components);\n        const inputVariables = [A, B];\n        if (hasBias) {\n          const biasComponents = isChannelsLast ? components : 1;\n          inputVariables.push(inputVariable('bias', inputs[2].dataType, inputs[2].dims.length, biasComponents));\n        }\n        const uniforms: UniformsArrayType =\n            [{name: 'dim_a_outer', type: 'i32'}, {name: 'dim_b_outer', type: 'i32'}, {name: 'dim_inner', type: 'i32'}];\n        appendActivationUniforms(activationAttributes, uniforms);\n        const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n        const applyActivation = getActivationSnippet(activationAttributes, output.type.value, baseType);\n        const declareFunctions = matMulReadWriteFnSource(\n            components, hasBias, applyActivation, [batchDims, A, B, output], [outerDimsA, outerDimsB, outerDims],\n            isChannelsLast);\n        return `\n  ${\n            shaderHelper.registerUniforms(uniforms).registerInternalVariables(batchDims).declareVariables(\n                ...inputVariables, output)}\n  ${declareFunctions}\n  ${\n            isVec4 ? makeMatMulPackedVec4Source(elementsPerThread, workgroupSize, dataType, batchDims) :\n                     makeMatMulPackedSource(elementsPerThread, workgroupSize, dataType, batchDims)}\n                   `;\n      };\n      return {\n        name: 'MatMul',\n        shaderCache: {\n          hint: `${elementsPerThread};${activationAttributes.activation};${isVec4};${isChannelsLast}`,\n          inputDependencies\n        },\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: dispatch[0], y: dispatch[1], z: dispatch[2]},\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n", "/**\n * @license\n * Copyright 2019 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/conv2d_mm_webgpu.ts\n//\n// modified to fit the needs of the project\n\nimport {DataType} from '../../../../wasm-common';\nimport {LOG_DEBUG} from '../../../log';\nimport {TensorView} from '../../../tensor-view';\nimport {ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../../types';\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from '../common';\nimport {ConvAttributes} from '../conv';\nimport {appendActivationUniforms, appendActivationUniformsData, getActivationSnippet} from '../fuse-utils';\n\nimport {biasSnippet, typeSnippet} from './activation_util';\nimport {utilFunctions} from './conv_util';\nimport {makeMatMulPackedSource, makeMatMulPackedVec4Source} from './matmul_packed_webgpu';\n\nconst conv2dCommonSnippet =\n    (isChannelsLast: boolean, fitAOuter: boolean, fitBOuter: boolean, fitInner: boolean, addBias = false,\n     attributes: ConvAttributes, innerElementSizeX = 4, innerElementSizeW = 4, innerElementSize = 4,\n     dataType = 'f32'): string => {\n      const getXSnippet = (innerElementSize: number) => {\n        switch (innerElementSize) {\n          case 1:\n            return 'resData = x[xIndex];';\n          case 3:\n            return `resData = vec3<${dataType}>(x[xIndex], x[xIndex + 1], x[xIndex + 2]);`;\n          case 4:\n            return 'resData = x[xIndex / 4];';\n          default:\n            throw new Error(`innerElementSize ${innerElementSize} is not supported.`);\n        }\n      };\n      const getWSnippet = (innerElementSize: number) => {\n        switch (innerElementSize) {\n          case 1:\n            return 'return w[row * i32(uniforms.w_shape[3]) + colIn];';\n          case 4:\n            return 'return w[row * i32(uniforms.w_shape[3]) / 4 + colIn];';\n          default:\n            throw new Error(`innerElementSize ${innerElementSize} is not supported.`);\n        }\n      };\n      const coordASnippet = isChannelsLast ? `\n    let coord = vec4<i32>(batch, xRow, xCol, xCh);\n    ` :\n                                             `\n    let coord = vec4<i32>(batch, xCh, xRow, xCol);\n    `;\n\n      const coordResSnippet = isChannelsLast ? `\n    let coords = vec4<i32>(\n      batch,\n      row / outWidth,\n      row % outWidth,\n      col);\n    ` :\n                                               `\n    let coords = vec4<i32>(\n      batch,\n      row,\n      col / outWidth,\n      col % outWidth);\n    `;\n\n      const xHeight = isChannelsLast ? 'i32(uniforms.x_shape[1])' : 'i32(uniforms.x_shape[2])';\n      const xWidth = isChannelsLast ? 'i32(uniforms.x_shape[2])' : 'i32(uniforms.x_shape[3])';\n      const row = isChannelsLast ? 'row' : 'col';\n      const col = isChannelsLast ? 'col' : 'row';\n      const readXSnippet = `\n    let inChannels = i32(uniforms.w_shape[2]);\n    let outWidth = ${isChannelsLast ? 'i32(uniforms.result_shape[2])' : 'i32(uniforms.result_shape[3])'};\n    let outRow = ${row} / outWidth;\n    let outCol = ${row} % outWidth;\n\n    let WRow = ${col} / (i32(uniforms.w_shape[1]) * inChannels);\n    let WCol = ${col} / inChannels % i32(uniforms.w_shape[1]);\n    let xRow = outRow * uniforms.stride[0] + uniforms.dilation[0] * WRow - uniforms.pad[0];\n    let xCol = outCol * uniforms.stride[1] + uniforms.dilation[1] * WCol - uniforms.pad[1];\n    let xCh = ${col} % inChannels;\n    var resData = ${typeSnippet(innerElementSizeX, dataType)}(0.0);\n    // The bounds checking is always needed since we use it to pad zero for\n    // the 'same' padding type.\n    if (xRow >= 0 && xRow < ${xHeight} && xCol >= 0 && xCol < ${xWidth}) {\n      ${coordASnippet}\n      let xIndex = getIndexFromCoords4D(coord, vec4<i32>(uniforms.x_shape));\n      ${getXSnippet(innerElementSizeX)}\n    }\n    return resData;`;\n\n      const sampleX = isChannelsLast ? (fitAOuter && fitInner ? `\n    let col = colIn * ${innerElementSizeX};\n    ${readXSnippet}` :\n                                                                `\n    let col = colIn * ${innerElementSizeX};\n    if (row < uniforms.dim_a_outer && col < uniforms.dim_inner) {\n      ${readXSnippet}\n    }\n    return ${typeSnippet(innerElementSizeX, dataType)}(0.0);`) :\n                                       (fitInner && fitBOuter ? `\n    let col = colIn * ${innerElementSizeX};\n    ${readXSnippet}` :\n                                                                `\n    let col = colIn * ${innerElementSizeX};\n    if (row < uniforms.dim_inner && col < uniforms.dim_b_outer) {\n      ${readXSnippet}\n    }\n    return ${typeSnippet(innerElementSizeX, dataType)}(0.0);`);\n\n      const sampleW = `${getWSnippet(innerElementSizeW)}`;\n\n      const resType = typeSnippet(innerElementSize, dataType);\n      const aType =\n          isChannelsLast ? typeSnippet(innerElementSizeX, dataType) : typeSnippet(innerElementSizeW, dataType);\n      const bType =\n          isChannelsLast ? typeSnippet(innerElementSizeW, dataType) : typeSnippet(innerElementSizeX, dataType);\n      const applyActivation = getActivationSnippet(attributes, resType, dataType);\n      const userCode = `\n    fn mm_readA(batch: i32, row : i32, colIn : i32) -> ${aType} {\n      ${isChannelsLast ? sampleX : sampleW}\n    }\n\n    fn mm_readB(batch: i32, row : i32, colIn : i32) -> ${bType} {\n      ${isChannelsLast ? sampleW : sampleX}\n    }\n\n    fn mm_write(batch: i32, row : i32, colIn : i32, valueIn : ${resType}) {\n      let col = colIn * ${innerElementSize};\n      if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer)\n      {\n      var value = valueIn;\n      let outWidth = ${isChannelsLast ? 'i32(uniforms.result_shape[2])' : 'i32(uniforms.result_shape[3])'};\n      ${coordResSnippet}\n      ${biasSnippet(addBias)}\n      ${applyActivation}\n      setOutputAtCoords(coords[0], coords[1], coords[2], coords[3], value);\n      }\n    }`;\n      return userCode;\n    };\n\nexport const createConv2DMatMulProgramInfo =\n    (inputs: readonly TensorView[], attributes: ConvAttributes, outputShape: readonly number[], dimAOuter: number,\n     dimBOuter: number, dimInner: number, hasBias: boolean, sequentialAccessByThreads: boolean): ProgramInfo => {\n      const isChannelsLast = attributes.format === 'NHWC';\n      const inChannels = isChannelsLast ? inputs[0].dims[3] : inputs[0].dims[1];\n      const batchSize = outputShape[0];\n      const outWidth = isChannelsLast ? outputShape[2] : outputShape[3];\n      const outHeight = isChannelsLast ? outputShape[1] : outputShape[2];\n      const outChannels = isChannelsLast ? outputShape[3] : outputShape[1];\n      // TODO: enable vec4 for NCHW\n      const isVec4 = isChannelsLast && (inChannels % 4 === 0 || inChannels % 3 === 0) && outChannels % 4 === 0;\n\n      // TODO: fine tune size\n      const dispatchX = isChannelsLast ? outChannels : outWidth * outHeight;\n      const dispatchY = isChannelsLast ? outWidth * outHeight : outChannels;\n      const workGroupSize: [number, number, number] = [8, 8, 1];\n      const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];\n      const dispatch = [\n        Math.ceil(dispatchX / workGroupSize[0] / elementsPerThread[0]),\n        Math.ceil(dispatchY / workGroupSize[1] / elementsPerThread[1]),\n        Math.ceil(batchSize / workGroupSize[2] / elementsPerThread[2])\n      ];\n\n      LOG_DEBUG('verbose', () => `[conv2d_mm_webgpu] dispatch = ${dispatch}`);\n\n      const innerElementSize = isVec4 ? (isChannelsLast && inChannels % 4 !== 0 ? 3 : 4) : 1;\n      const tileAOuter = workGroupSize[1] * elementsPerThread[1];\n      const tileBOuter = workGroupSize[0] * elementsPerThread[0];\n      const tileInner = Math.max(workGroupSize[0] * innerElementSize, workGroupSize[1]);\n      const fitAOuter = dimAOuter % tileAOuter === 0;\n      const fitBOuter = dimBOuter % tileBOuter === 0;\n      const fitInner = dimInner % tileInner === 0;\n      const elementsSize = isVec4 ? [innerElementSize, 4, 4] : [1, 1, 1];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.int32, data: dimAOuter}, {type: DataType.int32, data: dimBOuter},\n        {type: DataType.int32, data: dimInner}, {type: DataType.int32, data: [attributes.pads[0], attributes.pads[1]]},\n        {type: DataType.int32, data: attributes.strides}, {type: DataType.int32, data: attributes.dilations}\n      ];\n      appendActivationUniformsData(attributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(inputs[0].dims, inputs[1].dims));\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n        inputDependencies.push('rank');\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShape));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const uniforms: UniformsArrayType = [\n          {name: 'dim_a_outer', type: 'i32'}, {name: 'dim_b_outer', type: 'i32'}, {name: 'dim_inner', type: 'i32'},\n          {name: 'pad', type: 'i32', length: 2}, {name: 'stride', type: 'i32', length: 2},\n          {name: 'dilation', type: 'i32', length: 2}\n        ];\n        appendActivationUniforms(attributes, uniforms);\n\n        // TODO: support component 2, 3.\n        const components = isVec4 ? 4 : 1;\n        const t = tensorTypeToWsglStorageType(inputs[0].dataType);\n        let declareFunctions = `\n      fn setOutputAtIndex(flatIndex : i32, value : ${isVec4 ? `vec4<${t}>` : t}) {\n        result[flatIndex] = ${isVec4 ? `vec4<${t}>` : t}(value);\n      }\n      fn setOutputAtCoords(d0 : i32, d1 : i32, d2 : i32, d3 : i32, value : ${isVec4 ? `vec4<${t}>` : t}) {\n        let flatIndex = getOutputIndexFromCoords(vec4<i32>(d0, d1, d2, d3));\n        setOutputAtIndex(flatIndex ${isVec4 ? '/ 4' : ''}, value);\n      }`;\n        const x = inputVariable(\n            'x', inputs[0].dataType, inputs[0].dims.length, innerElementSize === 3 ? 1 : innerElementSize);\n        const w = inputVariable('w', inputs[1].dataType, inputs[1].dims.length, components);\n        const inputVariables = [x, w];\n        const output = outputVariable('result', inputs[0].dataType, outputShape.length, components);\n        if (hasBias) {\n          const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims.length, components);\n          inputVariables.push(bias);\n          declareFunctions += `\n        fn getBiasByOutputCoords(coords : vec4<i32>) -> ${isVec4 ? `vec4<${t}>` : t} {\n          return bias[coords.${isChannelsLast ? 'w' : 'y'}${isVec4 ? '/ 4' : ''}];\n        }`;\n        }\n\n        return `\n        ${utilFunctions('uniforms.result_strides')}\n        //struct Uniforms { xShape : vec4<i32>, wShape : vec4<i32>, outShape : vec4<i32>,\n        //  outShapeStrides: vec3<i32>, filterDims : vec2<i32>, pad : vec2<i32>, stride : vec2<i32>,\n        //  dilation : vec2<i32>, dimAOuter : i32, dimBOuter : i32, dimInner : i32 };\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n        ${declareFunctions}\n        ${\n            conv2dCommonSnippet(\n                isChannelsLast, fitAOuter, fitBOuter, fitInner, hasBias, attributes, elementsSize[0], elementsSize[1],\n                elementsSize[2], t)}\n        ${\n            isVec4 ?\n                makeMatMulPackedVec4Source(elementsPerThread, workGroupSize, t, undefined, !isChannelsLast, tileInner) :\n                makeMatMulPackedSource(\n                    elementsPerThread, workGroupSize, t, undefined, !isChannelsLast, tileInner, false, undefined,\n                    sequentialAccessByThreads)}`;\n      };\n      return {\n        name: 'Conv2DMatMul',\n        shaderCache: {\n          hint: `${attributes.cacheKey};${innerElementSize};${isVec4};${fitAOuter};${fitBOuter};${fitInner};${\n              tileAOuter};${tileBOuter};${tileInner}`,\n          inputDependencies\n        },\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: dispatch[0], y: dispatch[1], z: dispatch[2]},\n          programUniforms,\n        }),\n        getShaderSource\n      };\n    };\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, getMaxComponents, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from './common';\nimport {calculateOutputShape, ConvAttributes} from './conv';\nimport {appendActivationUniforms, appendActivationUniformsData, getActivationSnippet} from './fuse-utils';\n\n/**\n * naive grouped conv implementation, supports 1d/2d conv\n * @param squeezeOutputShapeFunction - an optional function to squeeze the output shape, only used in conv1d\n */\nexport const createGroupedConvProgramInfo =\n    (inputs: readonly TensorView[], attributes: ConvAttributes,\n     squeezeOutputShapeFunction?: (shape: readonly number[]) => number[]): ProgramInfo => {\n      const hasBias = inputs.length > 2;\n      const processBias = hasBias ? 'value += b[output_channel];' : '';\n      const xShape = inputs[0].dims;\n      const wShape = inputs[1].dims;\n      const outputChannelsPerGroup = wShape[0] / attributes.group;\n\n      const isChannelLast = attributes.format === 'NHWC';\n      const outputShape = calculateOutputShape(\n          xShape, wShape, attributes.dilations, attributes.pads, attributes.strides, isChannelLast);\n      const outputSize = ShapeUtil.size(outputShape);\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: attributes.dilations},\n        {type: DataType.uint32, data: [attributes.strides[0], attributes.strides[1]]},\n        {type: DataType.uint32, data: [attributes.pads[0], attributes.pads[1]]},\n        {type: DataType.uint32, data: outputChannelsPerGroup}\n      ];\n      appendActivationUniformsData(attributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(xShape, wShape));\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n        inputDependencies.push('rank');\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShape));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n        const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n        const applyActivation = getActivationSnippet(attributes, output.type.value, baseType);\n        const x = inputVariable('x', inputs[0].dataType, xShape.length);\n        const w = inputVariable('w', inputs[1].dataType, wShape.length);\n        const inputVars = [x, w];\n        if (hasBias) {\n          inputVars.push(inputVariable('b', inputs[2].dataType, inputs[2].dims.length));\n        }\n\n        const uniforms: UniformsArrayType = [\n          {name: 'output_size', type: 'u32'}, {name: 'dilations', type: 'u32', length: attributes.dilations.length},\n          {name: 'strides', type: 'u32', length: 2}, {name: 'pads', type: 'u32', length: 2},\n          {name: 'output_channels_per_group', type: 'u32'}\n        ];\n        appendActivationUniforms(attributes, uniforms);\n        return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n    let outputIndices = ${output.offsetToIndices('global_idx')};\n    let batch: u32 = outputIndices[0];\n    let output_channel: u32 = outputIndices[${isChannelLast ? 3 : 1}];\n    let xRCCorner: vec2<u32> = vec2<u32>(outputIndices[${isChannelLast ? 1 : 2}], outputIndices[${\n            isChannelLast ? 2 : 3}]) * uniforms.strides - uniforms.pads;\n    let group_id: u32 = output_channel / uniforms.output_channels_per_group;\n\n    var value: ${output.type.value} = ${output.type.value}(0);\n    for (var wInChannel: u32 = 0u; wInChannel < uniforms.w_shape[1]; wInChannel++) {\n      let input_channel = group_id * uniforms.w_shape[1] + wInChannel;\n      for (var wHeight: u32 = 0u; wHeight < uniforms.w_shape[2]; wHeight++) {\n        let xHeight = xRCCorner.x + wHeight * uniforms.dilations[0];\n\n        if (xHeight < 0u || xHeight >= uniforms.x_shape[${isChannelLast ? 1 : 2}]) {\n          continue;\n        }\n\n        for (var wWidth: u32 = 0u; wWidth < uniforms.w_shape[3]; wWidth++) {\n          let xWidth = xRCCorner.y + wWidth * uniforms.dilations[1];\n          if (xWidth < 0u || xWidth >= uniforms.x_shape[${isChannelLast ? 2 : 3}]) {\n            continue;\n          }\n\n          let xVal = ${\n            isChannelLast ? x.get('batch', 'xHeight', 'xWidth', 'input_channel') :\n                            x.get('batch', 'input_channel', 'xHeight', 'xWidth')};\n          let wVal = ${w.get('output_channel', 'wInChannel', 'wHeight', 'wWidth')};\n          value += xVal*wVal;\n        }\n      }\n    }\n    ${processBias}\n    ${applyActivation}\n    ${output.setByOffset('global_idx', 'value')}\n  }`;\n      };\n      return {\n        name: 'GroupedConv',\n        shaderCache: {hint: attributes.cacheKey, inputDependencies},\n        getRunData: () => ({\n          outputs: [{\n            dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,\n            dataType: inputs[0].dataType\n          }],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n\nexport const createGroupedConvVectorizeProgramInfo =\n    (inputs: readonly TensorView[], attributes: ConvAttributes, outputShape: readonly number[]): ProgramInfo => {\n      const hasBias = inputs.length > 2;\n      const components = getMaxComponents(outputShape[3]);\n      const outputNumber = getMaxComponents(outputShape[2]);\n      const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;\n      const xShape = [inputs[0].dims[0], inputs[0].dims[1], inputs[0].dims[2], inputs[0].dims[3] / components];\n      const wShape = [inputs[1].dims[0], inputs[1].dims[1], inputs[1].dims[2], inputs[1].dims[3] / components];\n      const outputShapeInShader = [outputShape[0], outputShape[1], outputShape[2], outputShape[3] / components];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize},\n        {type: DataType.int32, data: [attributes.strides[0], attributes.strides[1]]},\n        {type: DataType.int32, data: [attributes.pads[0], attributes.pads[1]]}\n      ];\n      appendActivationUniformsData(attributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(xShape, wShape, outputShapeInShader));\n      const xNumber = (outputNumber - 1) * attributes.strides[1] + wShape[1];\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const output = outputVariable('output', inputs[0].dataType, outputShapeInShader.length, components);\n        const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n        const applyActivation = getActivationSnippet(attributes, output.type.value, baseType);\n        const x = inputVariable('x', inputs[0].dataType, xShape.length, components);\n        const w = inputVariable('w', inputs[1].dataType, wShape.length, components);\n        const inputVars = [x, w];\n        if (hasBias) {\n          inputVars.push(inputVariable('b', inputs[2].dataType, inputs[2].dims, components));\n        }\n        const processBias = hasBias ? 'value += b[output_channel];' : '';\n        const uniforms: UniformsArrayType = [\n          {name: 'output_size', type: 'u32'},\n          {name: 'strides', type: 'i32', length: 2},\n          {name: 'pads', type: 'i32', length: 2},\n        ];\n        appendActivationUniforms(attributes, uniforms);\n        return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n    let width0 = uniforms.output_shape[3];\n    let output_channel = global_idx % width0;\n    var index1 = global_idx / width0;\n    let width1 = uniforms.output_shape[2] / ${outputNumber}u;\n    let col = (index1 % width1) * ${outputNumber}u;\n    index1 = index1 / width1;\n    let row = index1 % uniforms.output_shape[1];\n    let batch = index1 / uniforms.output_shape[1];\n\n    let x_corner = vec2<i32>(i32(row), i32(col)) * uniforms.strides - uniforms.pads;\n\n    var x_vals: array<${x.type.value}, ${xNumber}>;\n    var values: array<${output.type.value}, ${outputNumber}>;\n    let input_channel = output_channel;\n    // Use constant instead of uniform can give better performance for w's height/width.\n    for (var w_height: u32 = 0u; w_height < ${wShape[0]}; w_height++) {\n      let x_height = x_corner.x + i32(w_height);\n      if (x_height >= 0 && u32(x_height) < uniforms.x_shape[1]) {\n        for (var i = 0; i < ${xNumber}; i++) {\n          let x_width = x_corner.y + i;\n          if (x_width >= 0 && u32(x_width) < uniforms.x_shape[2]) {\n            x_vals[i] = ${x.get('batch', 'u32(x_height)', 'u32(x_width)', 'input_channel')};\n          } else {\n            x_vals[i] = ${x.type.value}(0);\n          }\n        }\n        for (var w_width: u32 = 0u; w_width < ${wShape[1]}; w_width++) {\n          let w_val = ${w.get('w_height', 'w_width', '0', 'output_channel')};\n          for (var i = 0u; i < ${outputNumber}u; i++) {\n            values[i] = fma(x_vals[i * u32(uniforms.strides[1]) + w_width], w_val, values[i]);\n          }\n        }\n      }\n    }\n\n    for (var i = 0u; i < ${outputNumber}u; i++) {\n      var value = values[i];\n      ${processBias}\n      ${applyActivation}\n      ${output.set('batch', 'row', 'col + i', 'output_channel', 'value')};\n    }\n  }`;\n      };\n\n      return {\n        name: 'GroupedConv-Vectorize',\n        shaderCache: {\n          hint: `${attributes.cacheKey};${components};${outputNumber};${xNumber};${wShape[0]};${wShape[1]}`,\n          inputDependencies: hasBias ? ['rank', 'rank', 'type'] : ['rank', 'rank']\n        },\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {BroadcastUtil, ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createMatmulProgramInfo} from './3rd-party/matmul_packed_webgpu';\nimport {createTensorShapeVariables, getBroadcastDims, getMaxComponents, IndicesHelper, inputVariable, internalVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from './common';\nimport {appendActivationUniforms, appendActivationUniformsData, getActivationSnippet, InternalActivationAttributes} from './fuse-utils';\n\nexport const createNaiveMatmulProgramInfo =\n    (inputs: readonly TensorView[], activationAttributes: InternalActivationAttributes, outputShape: readonly number[],\n     reshapedOutputShape?: readonly number[],\n     isChannelsLast = false /* only used for conv2dByMatMul*/): ProgramInfo => {\n      const aShape = inputs[0].dims;\n      const bShape = inputs[1].dims;\n\n      const M = aShape[aShape.length - 2];\n      const N = bShape[bShape.length - 1];\n      const K = aShape[aShape.length - 1];\n      const components = getMaxComponents(N);\n      const aComponents = getMaxComponents(K);\n      const outputNumber = getMaxComponents(M);\n      const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;\n      const hasBias = inputs.length > 2;\n      const outerDims = reshapedOutputShape ? reshapedOutputShape.slice(0, -2) : outputShape.slice(0, -2);\n      const batchSize = ShapeUtil.size(outerDims);\n      const outputShapeInShader = [batchSize, M, N];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: M}, {type: DataType.uint32, data: N},\n        {type: DataType.uint32, data: K}\n      ];\n      appendActivationUniformsData(activationAttributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(outerDims, aShape, bShape));\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShapeInShader));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const batchDims = internalVariable('batch_dims', inputs[0].dataType, outerDims.length);\n        const a = inputVariable('a', inputs[0].dataType, aShape.length, aComponents);\n        const b = inputVariable('b', inputs[1].dataType, bShape.length, components);\n        const output = outputVariable('output', inputs[0].dataType, outputShapeInShader.length, components);\n        const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n        const applyActivation = getActivationSnippet(activationAttributes, output.type.value, baseType);\n        const inputVariables = [a, b];\n        let processBias = '';\n        if (hasBias) {\n          const biasComponents = isChannelsLast ? components : 1;\n          inputVariables.push(inputVariable('bias', inputs[2].dataType, inputs[2].dims.length, biasComponents));\n          processBias = `${\n              isChannelsLast ? `value += bias[col / ${biasComponents}];` :\n                               `value += ${output.type.value}(bias[row + i]);`}`;\n        }\n\n        const outerDimsA = aShape.slice(0, -2);\n        const outerDimsB = bShape.slice(0, -2);\n        const broadCastADims = getBroadcastDims(outerDimsA, outerDims);\n        const broadCastBDims = getBroadcastDims(outerDimsB, outerDims);\n        const uniforms: UniformsArrayType = [\n          {name: 'output_size', type: 'u32'}, {name: 'M', type: 'u32'}, {name: 'N', type: 'u32'},\n          {name: 'K', type: 'u32'}\n        ];\n        appendActivationUniforms(activationAttributes, uniforms);\n\n        const getIndices = (variable: IndicesHelper, broadCastDims: number[]) => {\n          const rank = variable.rank;\n          const name = variable.name;\n          if (rank === 2) {\n            return `var ${name}_indices = ${variable.type.indices}(0u, 0u);`;\n          }\n          const batchRank = batchDims.rank;\n          let resStr = `var ${name}_indices: ${variable.type.indices};`;\n          for (let i = rank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) {\n            resStr += `\\n${name}_indices[${i}] = ${batchRank > 1 ? `batch_indices[${j}]` : 'batch_indices'};`;\n          }\n          broadCastDims.forEach(i => {\n            resStr += `\\n${name}_indices[${i}] = 0;`;\n          });\n          resStr += `${name}_indices[${rank - 2}] = 0u;\n                     ${name}_indices[${rank - 1}] = 0u;`;\n          return resStr;\n        };\n\n        const calcResult = (): string => {\n          let calcStr = `var a_data: ${a.type.value};`;\n          for (let i = 0; i < aComponents; i++) {\n            calcStr += `\n              let b_data${i} = b[(b_offset + (k + ${i}) * uniforms.N + col) / ${components}];`;\n          }\n          for (let i = 0; i < outputNumber; i++) {\n            calcStr += `a_data = a[(a_offset + (row + ${i}) * uniforms.K + k) / ${aComponents}];`;\n\n            for (let j = 0; j < aComponents; j++) {\n              calcStr += `\n            values[${i}] = fma(${b.type.value}(a_data${aComponents === 1 ? '' : `[${j}]`}), b_data${j}, values[${\n                  i}]);\\n`;\n            }\n          }\n          return calcStr;\n        };\n\n        return `\n  ${\n            shaderHelper.registerUniforms(uniforms).registerInternalVariables(batchDims).declareVariables(\n                ...inputVariables, output)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n    let col = (global_idx % (uniforms.N / ${components})) * ${components};\n    var index1 = global_idx / (uniforms.N / ${components});\n    let stride1 = uniforms.M / ${outputNumber};\n    let row = (index1 % stride1) * ${outputNumber};\n    let batch = index1 / stride1;\n\n    ${outputShape.length === 2 ? '' : `let batch_indices = ${batchDims.offsetToIndices('batch')};`}\n    ${getIndices(a, broadCastADims)}\n    let a_offset = ${a.indicesToOffset('a_indices')};\n    ${getIndices(b, broadCastBDims)}\n    let b_offset = ${b.indicesToOffset('b_indices')};\n    var values: array<${output.type.value}, ${outputNumber}>;\n    for (var k: u32 = 0u; k < uniforms.K; k = k + ${aComponents}) {\n      ${calcResult()}\n    }\n    for (var i = 0u; i < ${outputNumber}u; i++) {\n      var value = values[i];\n      ${processBias}\n      ${applyActivation}\n      let cur_indices = ${output.type.indices}(batch, row + i, col);\n      let offset = ${output.indicesToOffset('cur_indices')};\n      ${output.setByOffset(`offset / ${components}`, 'value')};\n    }\n  }\n  `;\n      };\n      return {\n        name: 'MatMulNaive',\n        shaderCache: {\n          hint: `${activationAttributes.activation};${components};${aComponents};${outputNumber};${isChannelsLast}`,\n          inputDependencies: hasBias ? ['rank', 'rank', 'rank'] : ['rank', 'rank']\n        },\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource\n      };\n    };\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('MatMul requires 2 inputs.');\n  }\n\n  if (inputs[0].dims[inputs[0].dims.length - 1] !== inputs[1].dims[inputs[1].dims.length - 2]) {\n    throw new Error('shared dimension does not match.');\n  }\n};\n\nexport const matMul = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  const outputShape = BroadcastUtil.calcShape(context.inputs[0].dims, context.inputs[1].dims, true);\n  if (!outputShape) {\n    throw new Error('Can\\'t use matmul on the given tensors');\n  }\n  const N = outputShape[outputShape.length - 1];\n  const K = context.inputs[0].dims[context.inputs[0].dims.length - 1];\n  if (N < 8 && K < 8) {\n    context.compute(createNaiveMatmulProgramInfo(context.inputs, {activation: ''}, outputShape));\n  } else {\n    context.compute(createMatmulProgramInfo(context.inputs, {activation: ''}, outputShape));\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorView} from '../../tensor-view';\nimport {PoolConvUtil} from '../../util';\nimport {AttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext} from '../types';\n\nimport {createConv2DMatMulProgramInfo} from './3rd-party/conv2d_mm_webgpu';\nimport {createMatmulProgramInfo} from './3rd-party/matmul_packed_webgpu';\nimport {createGroupedConvProgramInfo, createGroupedConvVectorizeProgramInfo} from './conv-grouped';\nimport {InternalActivationAttributes, parseInternalActivationAttributes} from './fuse-utils';\nimport {createNaiveMatmulProgramInfo} from './matmul';\nimport {createTransposeProgramInfo} from './transpose';\n\nexport const calculateOutputShape =\n    (inputShape: readonly number[], kernelShape: readonly number[], dilations: readonly number[],\n     adjustPads: readonly number[], strides: readonly number[], isChannelLast: boolean): number[] => {\n      const batchSize = inputShape[0];\n      const inputSpatialShape = inputShape.slice(isChannelLast ? 1 : 2, isChannelLast ? 3 : 4);\n      const spatialRank = inputSpatialShape.length;\n      const outChannels = kernelShape[0];\n      const kernelSpatialShape = kernelShape.slice(2);\n      const dilatedKernelShape = kernelSpatialShape.map((v, i) => v + (v - 1) * (dilations[i] - 1));\n      const inputSpatialShapeWithPad = inputSpatialShape.map((v, i) => v + adjustPads[i] + adjustPads[i + spatialRank]);\n      const outputShape =\n          inputSpatialShapeWithPad.map((v, i) => Math.floor((v - dilatedKernelShape[i] + strides[i]) / strides[i]));\n      outputShape.splice(0, 0, batchSize);\n      outputShape.splice(isChannelLast ? 3 : 1, 0, outChannels);\n      return outputShape;\n    };\n\nexport interface ConvAttributes extends InternalActivationAttributes, AttributeWithCacheKey {\n  readonly autoPad: string;\n  readonly dilations: readonly number[];\n  readonly format: 'NHWC'|'NCHW';\n  readonly group: number;\n  readonly kernelShape: readonly number[];\n  readonly pads: readonly number[];\n  readonly strides: readonly number[];\n  readonly wIsConst: boolean;\n}\n\n// for transposing weight tensor from [M, C/group, KH, KW] to [KH, KW, C/group, M]\nconst weightTransposeAttribute = [2, 3, 1, 0];\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: ConvAttributes): void => {\n  // Refer to the below link for all input checks\n  // https://github.com/onnx/onnx/blob/master/docs/Operators.md#Conv\n  if (!inputs || (inputs.length !== 2 && inputs.length !== 3)) {\n    throw new Error('Conv requires 2 or 3 inputs');\n  }\n\n  // TODO : Need to add support for multi-dimensional conv\n  if (inputs[0].dims.length !== 4 && inputs[0].dims.length !== 3) {\n    throw new Error('currently only support conv 1D and 2D');\n  }\n\n  if (inputs[0].dims.length !== inputs[1].dims.length) {\n    throw new Error('filter does not have same dimension as input');\n  }\n\n  // FILTER_IN_CHANNEL should be equal to DATA_CHANNEL\n  const dataChannel = inputs[0].dims[attributes.format === 'NHWC' ? inputs[0].dims.length - 1 : 1];\n  const filterInChannel = inputs[1].dims[1] * attributes.group;\n  if (dataChannel !== filterInChannel) {\n    throw new Error('FILTER_IN_CHANNEL should be equal to DATA_CHANNEL');\n  }\n\n  // if bias is provided it should be 1D and the number of elements should be equal to the number of feature maps\n  if (inputs.length === 3 && (inputs[2].dims.length !== 1 || inputs[1].dims[0] !== inputs[2].dims[0])) {\n    throw new Error('invalid bias');\n  }\n\n  const spatialRank = inputs[0].dims.length - 2;\n  // wrong dilations dimension\n  if (attributes.dilations.length !== spatialRank) {\n    throw new Error(`dilations should be ${spatialRank}D`);\n  }\n\n  // Wrong strides dimension\n  if (attributes.strides.length !== spatialRank) {\n    throw new Error(`strides should be ${spatialRank}D`);\n  }\n\n  // Wrong pads dimension\n  if (attributes.pads.length !== spatialRank * 2) {\n    throw new Error(`pads should be ${spatialRank * 2}D`);\n  }\n\n  // if kernelShape is specified, it's data length must be 2 less than dims length of the weights tensor\n  // (the first 2 dims are batch_size and channels)\n  if (attributes.kernelShape.length !== 0 && attributes.kernelShape.length !== inputs[1].dims.length - 2) {\n    throw new Error('invalid kernel shape');\n  }\n};\n\nconst getAdjustedConvAttributes = <T extends ConvAttributes>(attributes: T, inputs: readonly TensorView[]): T => {\n  const kernelShape = attributes.kernelShape.slice();\n  // if kernelShape is not specified in the attributes of this op, infer it from the weight tensor dims\n  for (let i = 2; i < inputs[1].dims.length; ++i) {\n    if (kernelShape[i - 2] === 0) {\n      kernelShape[i - 2] = inputs[1].dims[i];\n    }\n  }\n  const pads = attributes.pads.slice();\n  PoolConvUtil.adjustPadsBasedOnAutoPad(\n      inputs[0].dims, attributes.strides, attributes.dilations, kernelShape, pads, attributes.format === 'NHWC',\n      attributes.autoPad);\n\n  // always return a new object so does not modify the original attributes\n  const newAttributes: T = Object.assign({}, attributes);\n  Object.assign(newAttributes, {kernelShape, pads});\n  return newAttributes;\n};\n\nexport const parseConvAttributes = (attributes: Record<string, unknown>): ConvAttributes => {\n  const activationAttributes = parseInternalActivationAttributes(attributes);\n  // TODO : Make this generic enough to compute default attributes for multi-dimensional conv\n  const format = attributes.format as 'NHWC' | 'NCHW';\n  const autoPad = ['NOTSET', 'VALID', 'SAME_UPPER', 'SAME_LOWER'][attributes.auto_pad as number];\n  const dilations = attributes.dilations as [number, number];\n  const group = attributes.group as number;\n  const kernelShape = attributes.kernel_shape as [number, number];\n  const pads = attributes.pads as [number, number, number, number];\n  const strides = attributes.strides as [number, number];\n  const wIsConst = (attributes.w_is_const as () => boolean)();\n\n  return {\n    autoPad,\n    format,\n    dilations,\n    group,\n    kernelShape,\n    pads,\n    strides,\n    wIsConst,\n    ...activationAttributes,\n    cacheKey: `${attributes.format};${activationAttributes.activation};`\n  };\n};\n\nconst conv2d = (context: ComputeContext, inputs: readonly TensorView[], attributes: ConvAttributes): void => {\n  const adjustedAttributes = getAdjustedConvAttributes(attributes, inputs);\n\n  // check attributes\n\n  // const hasPreluActivationWeights = false; /* TODO: add support for prelu activation weights */\n  const isChannelsLast = attributes.format === 'NHWC';\n  if (attributes.group !== 1) {\n    // NVIDIA GPU with ampere architecture fails with below 2 cases, but we couldn't repro them with any other\n    // GPUs. So just disable vectorize on NVIDIA ampere to ensure always correct outputs.\n    // [webgpu]Conv - conv - vectorize group - B\n    // [webgpu]Conv - conv - vectorize group - D\n    const enableGroupedConvVectorize = !context.adapterInfo.isArchitecture('ampere');\n    if (enableGroupedConvVectorize && isChannelsLast && inputs[1].dims[0] === attributes.group &&\n        inputs[1].dims[1] === 1 && attributes.dilations[0] === 1 && attributes.dilations[1] === 1) {\n      const outputShape = calculateOutputShape(\n          inputs[0].dims, inputs[1].dims, attributes.dilations, adjustedAttributes.pads, attributes.strides,\n          isChannelsLast);\n      const transposedWeight = (context.kernelCustomData.wT as TensorView | undefined) ??\n          context.compute(\n              createTransposeProgramInfo(inputs[1], weightTransposeAttribute),\n              {inputs: [1], outputs: [attributes.wIsConst ? -2 : -1]})[0];\n      if (attributes.wIsConst && !context.kernelCustomData.wT) {\n        context.kernelCustomData.wT = transposedWeight;\n      }\n      const convInputs = [inputs[0], transposedWeight];\n      if (inputs.length === 3) {\n        convInputs.push(inputs[2]);\n      }\n      context.compute(\n          createGroupedConvVectorizeProgramInfo(convInputs, adjustedAttributes, outputShape), {inputs: convInputs});\n    } else {\n      context.compute(createGroupedConvProgramInfo(inputs, adjustedAttributes));\n    }\n    return;\n  }\n\n  const hasBias = inputs.length === 3;\n  const inputHeight = inputs[0].dims[isChannelsLast ? 1 : 2];\n  const inputWidth = inputs[0].dims[isChannelsLast ? 2 : 3];\n  const inputChannels = inputs[0].dims[isChannelsLast ? 3 : 1];\n  const weightHeight = inputs[1].dims[2];\n  const weightWidth = inputs[1].dims[3];\n\n  const outputShape = calculateOutputShape(\n      inputs[0].dims, inputs[1].dims, attributes.dilations, adjustedAttributes.pads, attributes.strides,\n      isChannelsLast);\n  const outHeight = outputShape[isChannelsLast ? 1 : 2];\n  const outWidth = outputShape[isChannelsLast ? 2 : 3];\n  const outChannels = outputShape[isChannelsLast ? 3 : 1];\n\n  const sameSize = isChannelsLast && weightHeight === inputHeight && weightWidth === inputWidth &&\n      attributes.pads[0] === 0 && attributes.pads[1] === 0;\n  if (sameSize ||\n      (weightHeight === 1 && weightWidth === 1 && attributes.dilations[0] === 1 && attributes.dilations[1] === 1 &&\n       attributes.strides[0] === 1 && attributes.strides[1] === 1 && attributes.pads[0] === 0 &&\n       attributes.pads[1] === 0)) {\n    // conv2dByMatMul\n    const batch = outputShape[0];\n    let xReshaped, wReshaped, matmulOutputShape;\n    const matmulInputs = [];\n    if (isChannelsLast) {\n      const transposedWeight = (context.kernelCustomData.wT as TensorView | undefined) ??\n          context.compute(\n              createTransposeProgramInfo(inputs[1], weightTransposeAttribute),\n              {inputs: [1], outputs: [attributes.wIsConst ? -2 : -1]})[0];\n      if (attributes.wIsConst && !context.kernelCustomData.wT) {\n        context.kernelCustomData.wT = transposedWeight;\n      }\n      if (sameSize) {\n        const sharedDim = inputHeight * inputWidth * inputChannels;\n        xReshaped = inputs[0].reshape([1, batch, sharedDim]);\n        wReshaped = transposedWeight.reshape([1, sharedDim, outChannels]);\n        matmulOutputShape = [1, batch, outChannels];\n      } else {\n        xReshaped = inputs[0].reshape([batch, inputHeight * inputWidth, inputChannels]);\n        wReshaped = transposedWeight.reshape([1, inputChannels, outChannels]);\n        matmulOutputShape = [batch, outHeight * outWidth, outChannels];\n      }\n      matmulInputs.push(xReshaped);\n      matmulInputs.push(wReshaped);\n    } else {\n      xReshaped = inputs[0].reshape([batch, inputChannels, inputHeight * inputWidth]);\n      wReshaped = inputs[1].reshape([1, outChannels, inputChannels]);\n      matmulOutputShape = [batch, outChannels, outHeight * outWidth];\n      matmulInputs.push(wReshaped);\n      matmulInputs.push(xReshaped);\n    }\n    if (hasBias) {\n      matmulInputs.push(inputs[2]);\n    }\n    const N = matmulOutputShape[2];\n    const K = matmulInputs[0].dims[matmulInputs[0].dims.length - 1];\n    // Tune the threshold.\n    if (N < 8 && K < 8) {\n      context.compute(\n          createNaiveMatmulProgramInfo(\n              matmulInputs, adjustedAttributes, outputShape, matmulOutputShape, isChannelsLast),\n          {inputs: matmulInputs});\n    } else {\n      context.compute(\n          createMatmulProgramInfo(matmulInputs, adjustedAttributes, outputShape, matmulOutputShape, isChannelsLast),\n          {inputs: matmulInputs});\n    }\n    return;\n  }\n\n  // TODO: implement conv2dWithIm2Col()\n\n  const sequentialAccessByThreads = /* backend.adapterInfo.isIntel() */ true;\n\n  // STEP.1: transpose weight\n  const transposedWeight = (context.kernelCustomData.wT as TensorView | undefined) ??\n      context.compute(\n          createTransposeProgramInfo(inputs[1], weightTransposeAttribute),\n          {inputs: [1], outputs: [attributes.wIsConst ? -2 : -1]})[0];\n  if (attributes.wIsConst && !context.kernelCustomData.wT) {\n    context.kernelCustomData.wT = transposedWeight;\n  }\n\n  // STEP.2: prepare reshaped inputs\n  const convInputs = [inputs[0], transposedWeight];\n  if (hasBias) {\n    convInputs.push(inputs[2]);\n  }\n\n  // STEP.3: compute matmul\n  const dimAOuter = isChannelsLast ? outHeight * outWidth : outChannels;\n  const dimBOuter = isChannelsLast ? outChannels : outHeight * outWidth;\n  const dimInner = weightHeight * weightWidth * inputChannels;\n  context.compute(\n      createConv2DMatMulProgramInfo(\n          convInputs, adjustedAttributes, outputShape, dimAOuter, dimBOuter, dimInner, hasBias,\n          sequentialAccessByThreads),\n      {inputs: convInputs});\n};\n\nconst conv1d = (context: ComputeContext, attributes: ConvAttributes): void => {\n  // extend the input to 2D by adding H dimension\n  const isChannelLast = attributes.format === 'NHWC';\n  const inputs = [\n    context.inputs[0].reshape(\n        isChannelLast ?\n            // [N, W, C] -> [N, H=1, W, C]\n            [context.inputs[0].dims[0], 1, context.inputs[0].dims[1], context.inputs[0].dims[2]] :\n            // [N, C, W] -> [N, C, H=1, W]\n            [context.inputs[0].dims[0], context.inputs[0].dims[1], 1, context.inputs[0].dims[2]]),\n    //[FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kW] -> [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kH=1, kW]\n    context.inputs[1].reshape([context.inputs[1].dims[0], context.inputs[1].dims[1], 1, context.inputs[1].dims[2]])\n  ];\n  if (context.inputs.length === 3) {\n    inputs.push(context.inputs[2]);\n  }\n  const pads = [0, attributes.pads[0], 0, attributes.pads[1]];\n  const strides = [1].concat(attributes.strides);\n  const dilations = [1].concat(attributes.dilations);\n  const kernelShape = [1].concat(attributes.kernelShape);\n  const adjustedAttributes = getAdjustedConvAttributes({...attributes, pads, strides, dilations, kernelShape}, inputs);\n  context.compute(createGroupedConvProgramInfo(\n      inputs, adjustedAttributes,\n      outputShape => isChannelLast ? [outputShape[0], outputShape[2], outputShape[3]] : []));\n};\n\nexport const conv = (context: ComputeContext, attributes: ConvAttributes): void => {\n  validateInputs(context.inputs, attributes);  // currently will fail if not conv1D/2D\n  if (context.inputs[0].dims.length === 3) {\n    conv1d(context, attributes);\n  } else {\n    conv2d(context, context.inputs, attributes);\n  }\n};\n", "/**\n * @license\n * Copyright 2021 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/conv_backprop_mm_webgpu.ts\n//\n// modified to fit the needs of the project\n\nimport {DataType} from '../../../../wasm-common';\nimport {LOG_DEBUG} from '../../../log';\nimport {TensorView} from '../../../tensor-view';\nimport {ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../../types';\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from '../common';\nimport {ConvTransposeAttributes} from '../conv-transpose';\nimport {appendActivationUniforms, appendActivationUniformsData, getActivationSnippet} from '../fuse-utils';\n\nimport {biasSnippet} from './activation_util';\nimport {utilFunctions} from './conv_util';\nimport {makeMatMulPackedSource, makeMatMulPackedVec4Source} from './matmul_packed_webgpu';\n\nconst conv2dTransposeCommonSnippet =\n    (isChannelsLast: boolean, addBias = false, attributes: ConvTransposeAttributes, type: string,\n     innerElementSize = 4): string => {\n      const getWSnippet = (innerElementSize: number) => {\n        switch (innerElementSize) {\n          case 1:\n            return 'return w[getIndexFromCoords4D(coord, vec4<i32>(uniforms.w_shape))];';\n          case 4:\n            return `\n            let coord1 = vec4<i32>(coordX, coordY, col + 1, rowInner);\n            let coord2 = vec4<i32>(coordX, coordY, col + 2, rowInner);\n            let coord3 = vec4<i32>(coordX, coordY, col + 3, rowInner);\n            let v0 = w[getIndexFromCoords4D(coord, vec4<i32>(uniforms.w_shape))];\n            let v1 = w[getIndexFromCoords4D(coord1, vec4<i32>(uniforms.w_shape))];\n            let v2 = w[getIndexFromCoords4D(coord2, vec4<i32>(uniforms.w_shape))];\n            let v3 = w[getIndexFromCoords4D(coord3, vec4<i32>(uniforms.w_shape))];\n            return ${type}(v0, v1, v2, v3);\n            `;\n          default:\n            throw new Error(`innerElementSize ${innerElementSize} is not supported.`);\n        }\n      };\n      const coordASnippet = isChannelsLast ? `\n      let coord = vec4<i32>(batch, iXR, iXC, xCh);\n      ` :\n                                             `\n      let coord = vec4<i32>(batch, xCh, iXR, iXC);\n      `;\n\n      const coordResSnippet = isChannelsLast ? `\n    let coords = vec4<i32>(\n      batch,\n      row / outWidth,\n      row % outWidth,\n      col);\n    ` :\n                                               `\n    let coords = vec4<i32>(\n      batch,\n      row,\n      col / outWidth,\n      col % outWidth);\n    `;\n\n      const xHeight = isChannelsLast ? 'i32(uniforms.x_shape[1])' : 'i32(uniforms.x_shape[2])';\n      const xWidth = isChannelsLast ? 'i32(uniforms.x_shape[2])' : 'i32(uniforms.x_shape[3])';\n      const row = isChannelsLast ? 'row' : 'col';\n      const col = isChannelsLast ? 'col' : 'row';\n\n      const readASnippet = `\n      let inChannels = ${isChannelsLast ? 'i32(uniforms.x_shape[3])' : 'i32(uniforms.x_shape[1])'};\n      let outWidth = ${isChannelsLast ? 'i32(uniforms.result_shape[2])' : 'i32(uniforms.result_shape[3])'};\n      let outRow = ${row} / outWidth;\n      let outCol = ${row} % outWidth;\n\n      let WRow = ${col} / (uniforms.filter_dims[1] * inChannels);\n      let WCol = ${col} / inChannels % uniforms.filter_dims[1];\n      let xR = f32(outRow - uniforms.pads[0] + uniforms.dilations[0] * WRow) / f32(uniforms.strides[0]);\n      let xC = f32(outCol - uniforms.pads[1] + uniforms.dilations[1] * WCol) / f32(uniforms.strides[1]);\n      if (xR < 0.0 || xR >= f32(${xHeight}) || fract(xR) > 0.0) {\n        return ${type}(0.0);\n      }\n      if (xC < 0.0 || xC >= f32(${xWidth}) || fract(xC) > 0.0) {\n        return ${type}(0.0);\n      }\n      let iXR = i32(xR);\n      let iXC = i32(xC);\n      let xCh = ${col} % inChannels;\n      ${coordASnippet}\n      return x[getIndexFromCoords4D(coord, vec4<i32>(uniforms.x_shape))/${innerElementSize}];`;\n\n      const sampleA = isChannelsLast ? `\n      let col = colIn * ${innerElementSize};\n      if (row < uniforms.dim_a_outer && col < uniforms.dim_inner) {\n        ${readASnippet}\n      }\n      return ${type}(0.0);` :\n                                       `\n      let col = colIn * ${innerElementSize};\n      if (row < uniforms.dim_inner && col < uniforms.dim_b_outer) {\n        ${readASnippet}\n      }\n      return ${type}(0.0);`;\n\n      const sampleW = `\n      let col = colIn * ${innerElementSize};\n      let inChannels = ${isChannelsLast ? 'i32(uniforms.x_shape[3])' : 'i32(uniforms.x_shape[1])'};\n      let coordX = uniforms.filter_dims[0] - 1 - row / (uniforms.filter_dims[1] * inChannels);\n      let coordY = uniforms.filter_dims[1] - 1 - (row / inChannels) % uniforms.filter_dims[1];\n      if (${\n          isChannelsLast ? 'row < uniforms.dim_inner && col < uniforms.dim_b_outer' :\n                           'row < uniforms.dim_inner && col < uniforms.dim_a_outer'}  && coordX >= 0 && coordY >= 0) {\n        let rowInner = row % inChannels;\n        let coord = vec4<i32>(coordX, coordY, col, rowInner);\n        ${getWSnippet(innerElementSize)}\n      }\n      return ${type}(0.0);\n      `;\n\n      const applyActivation = getActivationSnippet(attributes, type);\n      const userCode = `\n  fn mm_readA(batch: i32, row : i32, colIn : i32) -> ${type} {\n    ${isChannelsLast ? sampleA : sampleW}\n  }\n\n  fn mm_readB(batch: i32, row : i32, colIn : i32) -> ${type} {\n    ${isChannelsLast ? sampleW : sampleA}\n  }\n\n  fn mm_write(batch: i32, row : i32, colIn : i32, valueInput : ${type}) {\n    let col = colIn * ${innerElementSize};\n    if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer) {\n      var value = valueInput;\n      let outWidth = ${isChannelsLast ? 'i32(uniforms.result_shape[2])' : 'i32(uniforms.result_shape[3])'};\n      ${coordResSnippet}\n      ${biasSnippet(addBias)}\n      ${applyActivation}\n      result[getIndexFromCoords4D(coords, vec4<i32>(uniforms.result_shape))/${innerElementSize}] = value;\n    }\n  }`;\n      return userCode;\n    };\n\nexport const createConv2DTransposeMatMulProgramInfo =\n    (inputs: readonly TensorView[], attributes: ConvTransposeAttributes, outputShape: readonly number[],\n     dimAOuter: number, dimBOuter: number, dimInner: number, hasBias: boolean,\n     sequentialAccessByThreads: boolean): ProgramInfo => {\n      const isChannelsLast = attributes.format === 'NHWC';\n      const inChannels = isChannelsLast ? inputs[0].dims[3] : inputs[0].dims[1];\n      const batchSize = outputShape[0];\n      const outWidth = isChannelsLast ? outputShape[2] : outputShape[3];\n      const outHeight = isChannelsLast ? outputShape[1] : outputShape[2];\n      const outChannels = isChannelsLast ? outputShape[3] : outputShape[1];\n      // TODO: enable vec4 for NCHW\n      const isVec4 = isChannelsLast && (inChannels % 4 === 0 && inChannels % 3) && outChannels % 4 === 0;\n\n      // TODO: fine tune size\n      const dispatchX = isChannelsLast ? outChannels : outWidth * outHeight;\n      const dispatchY = isChannelsLast ? outWidth * outHeight : outChannels;\n      const workGroupSize: [number, number, number] = [8, 8, 1];\n      const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];\n      const dispatch = [\n        Math.ceil(dispatchX / workGroupSize[0] / elementsPerThread[0]),\n        Math.ceil(dispatchY / workGroupSize[1] / elementsPerThread[1]),\n        Math.ceil(batchSize / workGroupSize[2] / elementsPerThread[2])\n      ];\n\n      LOG_DEBUG('verbose', () => `[conv_backprop_mm_webgpu] dispatch = ${dispatch}`);\n\n      const innerElementSize = isVec4 ? 4 : 1;\n      const tileInner = Math.max(workGroupSize[0] * innerElementSize, workGroupSize[1]);\n      const components = isVec4 ? 4 : 1;\n      const filterDims =\n          [attributes.kernelShape[isChannelsLast ? 1 : 2], attributes.kernelShape[isChannelsLast ? 2 : 3]];\n      const effectiveFilterDims = [\n        filterDims[0] + (attributes.dilations[0] <= 1 ? 0 : (filterDims[0] - 1) * (attributes.dilations[0] - 1)),\n        filterDims[1] + (attributes.dilations[1] <= 1 ? 0 : (filterDims[1] - 1) * (attributes.dilations[1] - 1))\n      ];\n      const pads = [\n        effectiveFilterDims[0] - 1 - Math.floor((attributes.pads[0] + attributes.pads[2]) / 2),\n        effectiveFilterDims[1] - 1 - Math.floor((attributes.pads[1] + attributes.pads[3]) / 2)\n      ];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.int32, data: dimAOuter}, {type: DataType.int32, data: dimBOuter},\n        {type: DataType.int32, data: dimInner}, {type: DataType.int32, data: attributes.strides},\n        {type: DataType.int32, data: attributes.dilations}, {type: DataType.int32, data: filterDims},\n        {type: DataType.int32, data: pads}\n      ];\n      appendActivationUniformsData(attributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(inputs[0].dims, inputs[1].dims));\n\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n        inputDependencies.push('rank');\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShape));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const x = inputVariable('x', inputs[0].dataType, inputs[0].dims.length, components);\n        const w = inputVariable('w', inputs[1].dataType, inputs[1].dims.length, 1);\n        const output = outputVariable('result', inputs[0].dataType, outputShape.length, components);\n        const inputVariables = [x, w];\n\n        let declareFunctions = '';\n        if (hasBias) {\n          const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims.length, components);\n          inputVariables.push(bias);\n          declareFunctions += `\n          fn getBiasByOutputCoords(coords : vec4<i32>) -> ${bias.type.value} {\n            return bias[coords.${isChannelsLast ? 'w' : 'y'}${isVec4 ? '/ 4' : ''}];\n          }`;\n        }\n\n        const uniforms: UniformsArrayType = [\n          {name: 'dim_a_outer', type: 'i32'}, {name: 'dim_b_outer', type: 'i32'}, {name: 'dim_inner', type: 'i32'},\n          {name: 'strides', type: 'i32', length: 2}, {name: 'dilations', type: 'i32', length: 2},\n          {name: 'filter_dims', type: 'i32', length: filterDims.length},\n          {name: 'pads', type: 'i32', length: pads.length}\n        ];\n        appendActivationUniforms(attributes, uniforms);\n        const elemType = tensorTypeToWsglStorageType(inputs[0].dataType, 1);\n        if (elemType !== 'f16' && elemType !== 'f32') {\n          throw new Error(`elemType ${elemType} is not supported.`);\n        }\n        return `\n        ${utilFunctions('uniforms.result_strides')}\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)};\n        ${declareFunctions}\n        ${conv2dTransposeCommonSnippet(isChannelsLast, hasBias, attributes, x.type.value, innerElementSize)}\n        ${\n            isVec4 ? makeMatMulPackedVec4Source(\n                         elementsPerThread, workGroupSize, elemType, undefined, !isChannelsLast, tileInner) :\n                     makeMatMulPackedSource(\n                         elementsPerThread, workGroupSize, elemType, undefined, !isChannelsLast, tileInner, false,\n                         undefined, sequentialAccessByThreads)}`;\n      };\n\n      return {\n        name: 'Conv2DTransposeMatMul',\n        shaderCache:\n            {hint: `${attributes.cacheKey};${elementsPerThread};${workGroupSize};${isVec4}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: dispatch[0], y: dispatch[1], z: dispatch[2]},\n          programUniforms\n        }),\n        getShaderSource\n      };\n    };\n", "/**\n * @license\n * Copyright 2021 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/conv_backprop_webgpu.ts\n\nimport {DataType} from '../../../../wasm-common';\nimport {LOG_DEBUG} from '../../../log';\nimport {TensorView} from '../../../tensor-view';\nimport {ShapeUtil} from '../../../util';\nimport {ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../../types';\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from '../common';\nimport {ConvTransposeAttributes} from '../conv-transpose';\n\nconst createConvTranspose2DOpProgramShaderSource =\n    (shaderHelper: ShaderHelper, inputs: readonly TensorView[], outputShape: readonly number[], hasBias: boolean,\n     is1DimensionDispatch: boolean, isVec4 = false, dataType: string, uniforms: UniformsArrayType,\n     isChannelsLast = false): string => {\n      const rowDim = isChannelsLast ? 1 : 2;\n      const colDim = isChannelsLast ? 2 : 3;\n      const channelDim = isChannelsLast ? 3 : 1;\n      const workPerThread = isVec4 ? 2 : 1;\n\n      let declareFunctions = `\n  fn setOutputAtIndex(flatIndex : u32, value : ${isVec4 ? `vec4<${dataType}>` : dataType}) {\n    result[flatIndex] = ${isVec4 ? `vec4<${dataType}>` : dataType}(value);\n  }`;\n      if (hasBias) {\n        declareFunctions += `\n    fn getBiasByOutputCoords(coords : vec4<u32>) -> ${isVec4 ? `vec4<${dataType}>` : dataType} {\n      return bias[coords.${isChannelsLast ? 'w' : 'y'}${isVec4 ? '/ 4' : ''}];\n    }`;\n      }\n      const components = isVec4 ? 4 : 1;\n      const w = inputVariable('W', inputs[1].dataType, inputs[1].dims.length, components);\n      const dy = inputVariable('Dy', inputs[0].dataType, inputs[0].dims.length, components);\n      const inputVariables = [dy, w];\n      if (hasBias) {\n        inputVariables.push(inputVariable('bias', inputs[2].dataType, [outputShape[channelDim]].length, components));\n      }\n      const output = outputVariable('result', inputs[0].dataType, outputShape.length, components);\n\n      const codeSnippet4 = `{\n        let batch: u32 = ${is1DimensionDispatch ? 'global_id.z' : 'workgroup_id.z'} / uniforms.result_shape[1];\n        let r = ${is1DimensionDispatch ? 'global_id.z' : 'workgroup_id.z'} % uniforms.result_shape[1];\n        let c = ${is1DimensionDispatch ? 'global_id.y' : 'workgroup_id.y'} * ${workPerThread};\n        let d1: u32 = ${is1DimensionDispatch ? 'global_id.x' : 'workgroup_id.x'} * 4;\n\n        let dyCorner = vec2<i32>(i32(r), i32(c)) - vec2<i32>(uniforms.pads);\n\n        // Convolve dy(?, ?, d2) with w(:, :, d1, d2) to compute dx(xR, xC, d1).\n        // ? = to be determined. : = across all values in that axis.\n        var dotProd: array<vec4<${dataType}>, ${workPerThread}>;\n        for (var i = 0; i < ${workPerThread}; i++) {\n          dotProd[i] = vec4<${dataType}>(0.0);\n        }\n        for (var wR: u32 = 0; wR < uniforms.filter_dims[0]; wR = wR + 1) {\n          var dyR = (${dataType}(dyCorner.x) + ${dataType}(wR)) / ${dataType}(uniforms.strides.x);\n          let wRPerm = uniforms.filter_dims[0] - 1 - wR;\n          if (dyR < 0.0 || dyR >= ${dataType}(uniforms.Dy_shape[1]) ||\n              fract(dyR) > 0.0 || wRPerm < 0) {\n            continue;\n          }\n          let idyR: u32 = u32(dyR);\n\n          for (var wC: u32 = 0; wC < uniforms.filter_dims[1]; wC = wC + 1) {\n            let dyC = (${dataType}(dyCorner.y) + ${dataType}(wC)) / ${dataType}(uniforms.strides.y);\n            let dyC2 = (${dataType}(dyCorner.y) + 1.0 + ${dataType}(wC)) / ${dataType}(uniforms.strides.y);\n            let wCPerm = uniforms.filter_dims[1] - 1 - wC;\n            if (wCPerm < 0) {\n              continue;\n            }\n            var bDyCVal = true;\n            var bDyCVal2 = true;\n            if (dyC < 0.0 || dyC >= ${dataType}(uniforms.Dy_shape[2]) ||\n                fract(dyC) > 0.0) {\n              bDyCVal = false;\n            }\n            if (dyC2 < 0.0 || dyC2 >= ${dataType}(uniforms.Dy_shape[2]) ||\n                fract(dyC2) > 0.0) {\n              bDyCVal2 = false;\n            }\n\n            let idyC: u32 = u32(dyC);\n            let idyC2: u32 = u32(dyC2);\n            if (bDyCVal && bDyCVal2) {\n              let d2Length = uniforms.Dy_shape[3];\n              for (var d2 :u32 = 0; d2 < d2Length; d2 = d2 + 4) {\n                let wValue0 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1', 'd2')};\n                let wValue1 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 1', 'd2')};\n                let wValue2 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 2', 'd2')};\n                let wValue3 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 3', 'd2')};\n\n                var xValue = ${dy.get('batch', 'idyR', 'idyC', 'd2')};\n                let tmpval = vec4<${dataType}>(dot(xValue, wValue0),\n                                      dot(xValue, wValue1),\n                                      dot(xValue, wValue2),\n                                      dot(xValue, wValue3));\n                dotProd[0] = dotProd[0] + tmpval;\n\n                xValue =  ${dy.get('batch', 'idyR', 'idyC2', 'd2')};\n\n                dotProd[1] = dotProd[1] + vec4<${dataType}>(dot(xValue, wValue0),\n                                                    dot(xValue, wValue1),\n                                                    dot(xValue, wValue2),\n                                                    dot(xValue, wValue3));\n              }\n            } else if (bDyCVal) {\n              let d2Length = uniforms.Dy_shape[${channelDim}];\n              for (var d2: u32 = 0; d2 < d2Length; d2 = d2 + 4) {\n                let wValue0 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1', 'd2')};\n                let wValue1 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 1', 'd2')};\n                let wValue2 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 2', 'd2')};\n                let wValue3 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 3', 'd2')};\n\n                var xValue = ${dy.get('batch', 'idyR', 'idyC', 'd2')};\n                let tmpval = vec4<${dataType}>(dot(xValue, wValue0),\n                                      dot(xValue, wValue1),\n                                      dot(xValue, wValue2),\n                                      dot(xValue, wValue3));\n                dotProd[0] = dotProd[0] + tmpval;\n              }\n            } else if (bDyCVal2) {\n              let d2Length = uniforms.Dy_shape[3];\n              for (var d2: u32 = 0; d2 < d2Length; d2 = d2 + 4) {\n                let wValue0 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1', 'd2')};\n                let wValue1 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 1', 'd2')};\n                let wValue2 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 2', 'd2')};\n                let wValue3 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 3', 'd2')};\n\n                var xValue = ${dy.get('batch', 'idyR', 'idyC2', 'd2')};\n                let tmpval = vec4<${dataType}>(dot(xValue, wValue0),\n                                      dot(xValue, wValue1),\n                                      dot(xValue, wValue2),\n                                      dot(xValue, wValue3));\n                dotProd[1] = dotProd[1] + tmpval;\n              }\n            }\n          }\n        }\n\n        for (var i: u32 = 0; i < ${workPerThread}; i = i + 1) {\n          let value = dotProd[i] + ${hasBias ? 'bias[c+i]' : `vec4<${dataType}>(0.0)`};\n          ${output.set('batch', 'r', 'c + i', 'd1', 'value')};\n        }\n      }`;\n      const codeSnippet = `\n          let outputIndices = ${output.offsetToIndices('global_idx')};\n          let batch = ${output.indicesGet('outputIndices', 0)};\n          let d1 = ${output.indicesGet('outputIndices', channelDim)};\n          let r = ${output.indicesGet('outputIndices', rowDim)};\n          let c = ${output.indicesGet('outputIndices', colDim)};\n          let dyCorner = vec2<i32>(i32(r), i32(c)) - uniforms.pads;\n          let dyRCorner = dyCorner.x;\n          let dyCCorner = dyCorner.y;\n          let groupId = d1 / uniforms.output_channels_per_group;\n          let wOutChannel = d1 - groupId * uniforms.output_channels_per_group;\n          // Convolve dy(?, ?, d2) with w(:, :, d1, d2) to compute dx(xR, xC, d1).\n          // ? = to be determined. : = across all values in that axis.\n          var dotProd = ${dataType}(0.0);\n          for (var wR: u32 = 0; wR < uniforms.effective_filter_dims.x; wR = wR + 1) {\n            if (wR % uniforms.dilations.x != 0) {\n              continue;\n            }\n            let dyR = (${dataType}(dyRCorner) + ${dataType}(wR)) / ${dataType}(uniforms.strides[0]);\n            let wRPerm = uniforms.filter_dims.x - 1 - wR / uniforms.dilations.x;\n            if (dyR < 0.0 || dyR >= ${dataType}(uniforms.Dy_shape[${rowDim}]) || fract(dyR) > 0.0 ||\n                wRPerm < 0) {\n              continue;\n            }\n            let idyR: u32 = u32(dyR);\n\n            for (var wC: u32 = 0; wC < uniforms.effective_filter_dims.y; wC = wC + 1) {\n              if (wC % uniforms.dilations.y != 0) {\n                continue;\n              }\n              let dyC = (${dataType}(dyCCorner) + ${dataType}(wC)) / ${dataType}(uniforms.strides.y);\n              let wCPerm = uniforms.filter_dims.y - 1 - wC / uniforms.dilations.y;\n              if (dyC < 0.0 || dyC >= ${dataType}(uniforms.Dy_shape[${colDim}]) ||\n                  fract(dyC) > 0.0 || wCPerm < 0) {\n                continue;\n              }\n              let idyC: u32 = u32(dyC);\n              var inputChannel = groupId * uniforms.input_channels_per_group;\n              for (var d2: u32 = 0; d2 < uniforms.input_channels_per_group; d2 = d2 + 1) {\n                let xValue = ${\n          isChannelsLast ? dy.get('batch', 'idyR', 'idyC', 'inputChannel') :\n                           dy.get('batch', 'inputChannel', 'idyR', 'idyC')};\n                let wValue = ${w.get('inputChannel', 'wOutChannel', 'u32(wRPerm)', 'u32(wCPerm)')};\n                dotProd = dotProd + xValue * wValue;\n                inputChannel = inputChannel + 1;\n              }\n            }\n          }\n          let value = dotProd + ${hasBias ? 'bias[d1]' : `${dataType}(0.0)`};\n          ${output.setByOffset('global_idx', 'value')};\n        `;\n\n      return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n  ${declareFunctions}\n\n    ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')};\n  ${isVec4 ? codeSnippet4 : codeSnippet}}`;\n    };\n\nexport const createConvTranspose2DProgramInfo =\n    (inputs: readonly TensorView[], attributes: ConvTransposeAttributes,\n     squeezeOutputShapeFunction?: (shape: readonly number[]) => number[]): ProgramInfo => {\n      const hasBias = inputs.length > 2;\n      // const isChannelsLast = attributes.format === 'NHWC';\n      const outputShape = attributes.outputShape;\n      const outputSize = ShapeUtil.size(outputShape);\n\n      // const inChannels = inputs[0].dims[isChannelsLast ? 3 : 1];\n      // TODO Enable isVec4 for performance\n      // Disabled due to weight matrix layout issue\n      // const isVec4 = attributes.group === 1 && isChannelsLast && inChannels % 4 === 0 && outChannels % 4 === 0;\n      const dispatch = [\n        Math.ceil(outputSize / 64),\n        1,\n        1,\n      ];\n      LOG_DEBUG('verbose', () => `[conv2d_backprop_webgpu] dispatch = ${dispatch}`);\n\n      const isChannelsLast = attributes.format === 'NHWC';\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n      const strides = [attributes.strides[0], attributes.strides[1]];\n      const filterDims =\n          [attributes.kernelShape[isChannelsLast ? 1 : 2], attributes.kernelShape[isChannelsLast ? 2 : 3]];\n      const dilations = [attributes.dilations[0], attributes.dilations[1]];\n      const effectiveFilterDims = [\n        filterDims[0] +\n            (attributes.dilations[0] <= 1 ?\n                 0 :\n                 (attributes.kernelShape[isChannelsLast ? 1 : 2] - 1) * (attributes.dilations[0] - 1)),\n        filterDims[1] +\n            (attributes.dilations[1] <= 1 ?\n                 0 :\n                 (attributes.kernelShape[isChannelsLast ? 2 : 3] - 1) * (attributes.dilations[1] - 1))\n      ];\n      const pads = [\n        effectiveFilterDims[0] - 1 - Math.floor((attributes.pads[0] + attributes.pads[2]) / 2),\n        effectiveFilterDims[1] - 1 - Math.floor(attributes.pads[1] + attributes.pads[3]) / 2\n      ];\n\n      const isVec4 = false;\n      const group = attributes.group;\n      const wShape = inputs[1].dims;\n      const inputChannelsPerGroup = wShape[0] / group;\n      const outputChannelsPerGroup = wShape[1];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: strides},\n        {type: DataType.uint32, data: filterDims}, {type: DataType.uint32, data: dilations},\n        {type: DataType.uint32, data: effectiveFilterDims}, {type: DataType.int32, data: pads},\n        {type: DataType.uint32, data: inputChannelsPerGroup}, {type: DataType.uint32, data: outputChannelsPerGroup},\n        ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims)\n      ];\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n        inputDependencies.push('rank');\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShape));\n\n      const is1DimensionDispatch = dispatch[1] === 1 && dispatch[2] === 1;\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const uniforms: UniformsArrayType = [\n          {name: 'output_size', type: 'u32'}, {name: 'strides', type: 'u32', length: strides.length},\n          {name: 'filter_dims', type: 'u32', length: filterDims.length},\n          {name: 'dilations', type: 'u32', length: filterDims.length},\n          {name: 'effective_filter_dims', type: 'u32', length: effectiveFilterDims.length},\n          {name: 'pads', type: 'i32', length: pads.length}, {name: 'input_channels_per_group', type: 'u32'},\n          {name: 'output_channels_per_group', type: 'u32'}\n        ];\n        const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n        return `${\n            createConvTranspose2DOpProgramShaderSource(\n                shaderHelper, inputs, outputShape, hasBias, is1DimensionDispatch, isVec4, dataType, uniforms,\n                isChannelsLast)}`;\n      };\n      return {\n        name: 'ConvTranspose2D',\n        shaderCache: {hint: `${attributes.cacheKey};`, inputDependencies},\n        getRunData: () => ({\n          dispatchGroup: {x: dispatch[0], y: dispatch[1], z: dispatch[2]},\n          outputs: [{\n            dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,\n            dataType: inputs[0].dataType\n          }],\n          programUniforms\n        }),\n        getShaderSource\n      };\n    };\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorView} from '../../tensor-view';\nimport {ComputeContext} from '../types';\n\nimport {createConv2DTransposeMatMulProgramInfo} from './3rd-party/conv_backprop_mm_webgpu';\nimport {createConvTranspose2DProgramInfo} from './3rd-party/conv_backprop_webgpu';\nimport {ConvAttributes} from './conv';\nimport {parseInternalActivationAttributes} from './fuse-utils';\nimport {createTransposeProgramInfo} from './transpose';\n\nconst computeTotalPad =\n    (inDim: number, stride: number, adj: number, kernel: number, dilation: number, outSize: number) =>\n        (inDim - 1) * stride + adj + (kernel - 1) * dilation + 1 - outSize;\n\nconst distributePadding = (totalPad: number, autoPad: string, pads: number[], head: number, tail: number) => {\n  const smallPad = Math.floor(totalPad / 2);\n  if (autoPad === 'SAME_UPPER') {\n    pads[head] = smallPad;\n    pads[tail] = totalPad - smallPad;\n  } else if (autoPad === 'SAME_LOWER') {\n    pads[head] = totalPad - smallPad;\n    pads[tail] = smallPad;\n  }\n};\n\nconst calculateOutputShapeAndPads =\n    (inputShape: readonly number[], kernelShape: readonly number[], dilations: readonly number[], autoPad: string,\n     group: number, pads: number[], strides: readonly number[], isChannelLast: boolean, outputPadding: number[],\n     outputShape: number[]) => {\n      const spatialRank = inputShape.length - 2;\n      const updateOutputShape = outputShape.length === 0;\n      if (outputPadding.length === 0) {\n        for (let i = 0; i < spatialRank; ++i) {\n          outputPadding.push(0);\n        }\n      }\n      const batchSize = inputShape[0];\n      const outChannels = kernelShape[isChannelLast ? 3 : 1] * group;\n      for (let i = 0, j = inputShape.length - spatialRank - (isChannelLast ? 1 : 0); i < spatialRank; ++i, ++j) {\n        const inSize = inputShape[j];\n        const outSize = updateOutputShape ? inSize * strides[i] : outputShape[i];\n        const totalPad = computeTotalPad(inSize, strides[i], pads[i], kernelShape[j], dilations[i], outSize);\n        distributePadding(totalPad, autoPad, pads, i, i + spatialRank);\n        if (updateOutputShape) {\n          outputShape.push(\n              strides[i] * (inSize - 1) + outputPadding[i] + (kernelShape[j] - 1) * dilations[i] + 1 - pads[i] -\n              pads[i + spatialRank]);\n        }\n      }\n      outputShape.splice(0, 0, batchSize);\n      outputShape.splice(isChannelLast ? 3 : 1, 0, outChannels);\n    };\n\nexport interface ConvTransposeAttributes extends ConvAttributes {\n  readonly outputPadding: readonly number[];\n  readonly outputShape: readonly number[];\n}\n\nconst getAdjustedConvTransposeAttributes =\n    <T extends ConvTransposeAttributes>(attributes: T, inputs: readonly TensorView[]): T => {\n      const kernelShape = attributes.kernelShape.slice();\n      // if kernelShape is not specified in the attributes of this op, infer it from the weight tensor dims\n      if (attributes.kernelShape.length === 0 || attributes.kernelShape.reduce((a, b) => a * b, 1) === 0) {\n        kernelShape.length = 0;\n        for (let i = 2; i < inputs[1].dims.length; ++i) {\n          kernelShape.push(inputs[1].dims[i]);\n        }\n      }\n      const isChannelsLast = attributes.format === 'NHWC';\n      kernelShape.splice(0, 0, inputs[1].dims[0]);\n      kernelShape.splice(isChannelsLast ? 3 : 1, 0, inputs[1].dims[1]);\n\n      const pads = attributes.pads.slice();\n      const outputShape = attributes.outputShape.slice();\n      const outputPadding = attributes.outputPadding.slice();\n      const inputShape = inputs[0].dims;\n      let dilations = attributes.dilations.slice();\n      if (dilations.reduce((a, b) => a + b, 0) === 0) {\n        const spatialRank = inputs[0].dims.length - 2;\n        dilations = new Array(spatialRank).fill(1);\n      }\n      let strides = attributes.strides.slice();\n      if (strides.reduce((a, b) => a + b, 0) === 0) {\n        const spatialRank = inputs[0].dims.length - 2;\n        strides = new Array(spatialRank).fill(1);\n      }\n      // If outputShape is not specified in the attributes of this op, infer it from the parameters\n      // Similarly, automatically infer pads if not specified\n      calculateOutputShapeAndPads(\n          inputShape, kernelShape, dilations, attributes.autoPad, attributes.group, pads, strides, isChannelsLast,\n          outputPadding, outputShape);\n\n      // always return a new object so does not modify the original attributes\n      const newAttributes: T = Object.assign({}, attributes);\n      Object.assign(newAttributes, {kernelShape, pads, outputPadding, outputShape, dilations, strides});\n      return newAttributes;\n    };\n\nexport const parseConvTransposeAttributes = (attributes: Record<string, unknown>): ConvTransposeAttributes => {\n  const activationAttributes = parseInternalActivationAttributes(attributes);\n  // TODO : Make this generic enough to compute default attributes for multi-dimensional conv\n  const format = attributes.format as 'NHWC' | 'NCHW';\n  const autoPad =\n      ['NOTSET', 'VALID', 'SAME_UPPER',\n       'SAME_LOWER'][typeof attributes.autoPad == 'undefined' ? 0 : attributes.autoPad as number];\n  const dilations = attributes.dilations as [number, number];\n  const group = attributes.group as number;\n  const kernelShape = attributes.kernelShape as [number, number];\n  const pads = attributes.pads as [number, number, number, number];\n  const strides = attributes.strides as [number, number];\n  const wIsConst = (attributes.wIsConst as () => boolean)();\n  const outputPadding = attributes.outputPadding as [number, number, number, number];\n  const outputShape = attributes.outputShape as [number, number];\n  return {\n    autoPad,\n    format,\n    dilations,\n    group,\n    kernelShape,\n    outputPadding,\n    outputShape,\n    pads,\n    strides,\n    wIsConst,\n    ...activationAttributes,\n    cacheKey: `${attributes.format};${activationAttributes.activation};`\n  };\n};\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: ConvTransposeAttributes): void => {\n  // Refer to the below link for all input checks\n  // https://github.com/onnx/onnx/blob/main/docs/Operators.md#ConvTranspose\n  if (!inputs || (inputs.length !== 2 && inputs.length !== 3)) {\n    throw new Error('Conv requires 2 or 3 inputs');\n  }\n\n  // TODO : Need to add support for multi-dimensional conv\n  if (inputs[0].dims.length !== 4 && inputs[0].dims.length !== 3) {\n    throw new Error('currently only support 2-dimensional conv');\n  }\n\n  if (inputs[0].dims.length !== inputs[1].dims.length) {\n    throw new Error('filter does not have same dimension as input');\n  }\n\n  // FILTER_IN_CHANNEL should be equal to DATA_CHANNEL\n  const dataChannel = inputs[0].dims[attributes.format === 'NHWC' ? inputs[0].dims.length - 1 : 1];\n  const filterInChannel = inputs[1].dims[0];\n  if (dataChannel !== filterInChannel) {\n    throw new Error('FILTER_IN_CHANNEL should be equal to DATA_CHANNEL');\n  }\n\n  const featureMaps = inputs[1].dims[1] * attributes.group;\n\n  // if bias is provided it should be 1D and the number of elements should be equal to the number of feature maps\n  if (inputs.length === 3 && (inputs[2].dims.length !== 1 || inputs[2].dims[0] !== featureMaps)) {\n    throw new Error('invalid bias');\n  }\n\n  const spatialRank = inputs[0].dims.length - 2;\n  const dilationsSet = attributes.dilations.reduce((a, b) => a + b, 0) > 0;\n  // wrong dilations dimension\n  if (dilationsSet && attributes.dilations.length !== spatialRank) {\n    throw new Error(`dilations should be ${spatialRank}D`);\n  }\n\n  const stridesSet = attributes.strides.reduce((a, b) => a + b, 0) > 0;\n  // Wrong strides dimension\n  if (stridesSet && attributes.strides.length !== spatialRank) {\n    throw new Error(`strides should be ${spatialRank}D`);\n  }\n\n  // Wrong pads dimension\n  const padsSet = attributes.pads.reduce((a, b) => a + b, 0) > 0;\n  if (padsSet && attributes.pads.length !== spatialRank * 2) {\n    throw new Error(`pads should be ${spatialRank * 2}D`);\n  }\n\n  // Wrong output padding dimension\n  if (attributes.outputPadding.length !== spatialRank && attributes.outputPadding.length !== 0) {\n    throw new Error(`output_padding should be ${spatialRank}D`);\n  }\n\n  // if kernelShape is specified, it's data length must be 2 less than dims length of the weights tensor\n  // (the first 2 dims are batch_size and channels)\n  const kernelShapeSet = attributes.kernelShape.reduce((a, b) => a + b, 0) > 0;\n  if (kernelShapeSet && attributes.kernelShape.length !== 0 &&\n      attributes.kernelShape.length !== inputs[1].dims.length - 2) {\n    throw new Error('invalid kernel shape');\n  }\n\n  // as with kernelShape, must have same number of spatial dims as input\n  if (attributes.outputShape.length !== 0 && attributes.outputShape.length !== inputs[0].dims.length - 2) {\n    throw new Error('invalid output shape');\n  }\n};\n\n// for transposing weight tensor from [C, M/group, KH, KW] to [KH, KW, M/group, C]\nconst weightTransposePerm = [2, 3, 1, 0];\n\nconst convTranspose2d =\n    (context: ComputeContext, inputs: readonly TensorView[], attributes: ConvTransposeAttributes): void => {\n      const adjustedAttributes = getAdjustedConvTransposeAttributes(attributes, inputs);\n      const isChannelsLast = attributes.format === 'NHWC';\n      const outputShape = adjustedAttributes.outputShape;\n      const outChannels = outputShape[isChannelsLast ? 3 : 1];\n      const inputChannels = inputs[0].dims[isChannelsLast ? 3 : 1];\n      // Switch to naive method when outChannels and inputChannels are very small. It's because that in this case it's\n      // not suitable for matmul version since matmul uses tile size 32x32 resulting the underlying execution unit\n      // utilization rate is very low.\n      if (adjustedAttributes.group !== 1 || (outChannels === 1 && inputChannels === 1)) {\n        context.compute(createConvTranspose2DProgramInfo(inputs, adjustedAttributes));\n        return;\n      }\n      const outHeight = outputShape[isChannelsLast ? 1 : 2];\n      const outWidth = outputShape[isChannelsLast ? 2 : 3];\n      const weightHeight = inputs[1].dims[2];\n      const weightWidth = inputs[1].dims[3];\n\n      const dimAOuter = isChannelsLast ? outHeight * outWidth : outChannels;\n      const dimBOuter = isChannelsLast ? outChannels : outHeight * outWidth;\n      const dimInner = weightHeight * weightWidth * inputChannels;\n\n      const sequentialAccessByThreads = /* backend.adapterInfo.isIntel() */ true;\n\n\n      // STEP.1: transpose weight\n      const transposedWeight = (context.kernelCustomData.wT as TensorView | undefined) ??\n          context.compute(\n              createTransposeProgramInfo(inputs[1], weightTransposePerm),\n              {inputs: [1], outputs: [attributes.wIsConst ? -2 : -1]})[0];\n      if (attributes.wIsConst && !context.kernelCustomData.wT) {\n        context.kernelCustomData.wT = transposedWeight;\n      }\n\n      // STEP.2: prepare reshaped inputs\n      const convTransposeInputs = [inputs[0], transposedWeight];\n      const hasBias = inputs.length === 3;\n      if (hasBias) {\n        if (!isChannelsLast && inputs[2].dims.length === 1) {\n          convTransposeInputs.push(inputs[2].reshape([inputs[2].dims[0], 1, 1]));\n        } else {\n          convTransposeInputs.push(inputs[2]);\n        }\n      }\n\n      // STEP.3: compute matmul\n      context.compute(\n          createConv2DTransposeMatMulProgramInfo(\n              convTransposeInputs, adjustedAttributes, outputShape, dimAOuter, dimBOuter, dimInner, hasBias,\n              sequentialAccessByThreads),\n          {inputs: convTransposeInputs});\n    };\n\nconst convTranspose1d = (context: ComputeContext, attributes: ConvTransposeAttributes): void => {\n  // extend the input to 2D by adding H dimension\n  const isChannelLast = attributes.format === 'NHWC';\n\n  const inputs = [\n    context.inputs[0].reshape(\n        isChannelLast ?\n            // [N, W, C] -> [N, H=1, W, C]\n            [context.inputs[0].dims[0], 1, context.inputs[0].dims[1], context.inputs[0].dims[2]] :\n            // [N, C, W] -> [N, C, H=1, W]\n            [context.inputs[0].dims[0], context.inputs[0].dims[1], 1, context.inputs[0].dims[2]]),\n    //[FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kW] -> [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kH=1, kW]\n    context.inputs[1].reshape([context.inputs[1].dims[0], context.inputs[1].dims[1], 1, context.inputs[1].dims[2]])\n  ];\n  if (context.inputs.length === 3) {\n    inputs.push(context.inputs[2]);\n  }\n  let kernelShape = attributes.kernelShape;\n  if (kernelShape.length === 0 || kernelShape[0] === 0) {\n    kernelShape = [context.inputs[1].dims[2]];\n  }\n  let dilations = attributes.dilations;\n  if (dilations.length === 0 || dilations[0] === 0) {\n    dilations = [1];\n  }\n  let strides = attributes.strides;\n  if (strides.length === 0 || strides[0] === 0) {\n    strides = [1];\n  }\n  let pads = attributes.pads;\n  if (pads.length === 0) {\n    pads = [0, 0];\n  }\n  pads = [0, pads[0], 0, pads[1]];\n  strides = [1].concat(strides);\n  dilations = [1].concat(dilations);\n  kernelShape = [1].concat(kernelShape);\n  const adjustedAttributes =\n      getAdjustedConvTransposeAttributes({...attributes, pads, strides, dilations, kernelShape}, inputs);\n  context.compute(createConvTranspose2DProgramInfo(\n      inputs, adjustedAttributes,\n      outputShape => isChannelLast ? [outputShape[0], outputShape[2], outputShape[3]] :\n                                     [outputShape[0], outputShape[1], outputShape[3]]));\n};\n\nexport const convTranspose = (context: ComputeContext, attributes: ConvTransposeAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  if (context.inputs[0].dims.length === 3) {\n    convTranspose1d(context, attributes);\n  } else {\n    convTranspose2d(context, context.inputs, attributes);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, inputVariable, outputVariable, ShaderHelper} from './common';\n\n\nexport interface CumSumAttributes extends AttributeWithCacheKey {\n  readonly exclusive: boolean;\n  readonly reverse: boolean;\n}\nconst createCumsumProgramInfo =\n    (inputType: number, inputShape: readonly number[], axisInput: TensorView, attributes: CumSumAttributes):\n        ProgramInfo => {\n          const outputSize = ShapeUtil.size(inputShape);  // outputShape is same as inputShape.\n          const rank = inputShape.length;                 // input/output rank\n          const input = inputVariable('input', inputType, rank);\n          const output = outputVariable('output', inputType, rank);\n          const axisValue = axisInput.dataType === DataType.int32 ? axisInput.getInt32Array()[0] :\n                                                                    Number(axisInput.getBigInt64Array()[0]);\n          const axis = ShapeUtil.normalizeAxis(axisValue, rank);\n          const getShaderSource = (shaderHelper: ShaderHelper) => {\n            const index = ` i32(${input.indicesGet('inputIndices', 'uniforms.axis')}) `;\n            const max = getElementAt('uniforms.input_shape', 'uniforms.axis', rank);\n            const lowerLimit = attributes.reverse ? index + (attributes.exclusive ? ' + 1' : '') : '0';\n            const upperLimit = attributes.reverse ? max : index + (attributes.exclusive ? '' : ' + 1');\n            return `\n                ${\n                shaderHelper.registerUniform('outputSize', 'u32')\n                    .registerUniform('axis', 'u32')\n                    .declareVariables(input, output)}\n                ${shaderHelper.mainStart()}\n                  ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n                  var inputIndices = ${output.offsetToIndices('global_idx')};\n                  var sum = ${output.type.value}(0);\n                  let first : i32 = ${lowerLimit};\n                  let last : i32 = ${upperLimit};\n                  for (var i : i32 = first; i < last; i++) {\n                    ${input.indicesSet('inputIndices', 'uniforms.axis', 'u32(i)')};\n                    sum = sum + ${input.getByIndices('inputIndices')};\n                  }\n                  ${output.setByOffset('global_idx', 'sum')};\n                }`;\n          };\n          return {\n            name: 'CumSum',\n            shaderCache: {hint: attributes.cacheKey, inputDependencies: ['rank']},\n            getRunData: () => ({\n              outputs: [{dims: inputShape, dataType: inputType}],\n              dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n              programUniforms: [\n                {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: axis},\n                ...createTensorShapeVariables(inputShape, inputShape)\n              ]\n\n            }),\n            getShaderSource\n          };\n        };\n\n\nexport const cumsum = (context: ComputeContext, attributes: CumSumAttributes): void => {\n  const inputShape = context.inputs[0].dims;\n  const inputType = context.inputs[0].dataType;\n  const axis = context.inputs[1];\n  context.compute(createCumsumProgramInfo(inputType, inputShape, axis, attributes), {inputs: [0]});\n};\n\nexport const parseCumSumAttributes = (attributes: Record<string, unknown>): CumSumAttributes => {\n  const exclusive = attributes.exclusive as number === 1;\n  const reverse = attributes.reverse as number === 1;\n  return createAttributeWithCacheKey({exclusive, reverse});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface FormatAttributes {\n  readonly format: 'NHWC'|'NCHW';\n}\n\nexport interface DepthToSpaceAttributes extends FormatAttributes, AttributeWithCacheKey {\n  readonly blocksize: number;\n  readonly mode: string;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('DepthToSpace requires 1 input.');\n  }\n  if (inputs[0].dims.length !== 4) {\n    throw new Error('DepthToSpace requires 4D input.');\n  }\n};\n\nconst permFunctionBody = (perm: number[], rank: number, input: IndicesHelper, output: IndicesHelper): string => {\n  const reverseFunc = [];\n  reverseFunc.push(`fn perm(i: ${output.type.indices}) -> ${input.type.indices} {\n    var a: ${input.type.indices};`);\n  for (let i = 0; i < rank; ++i) {\n    reverseFunc.push(input.indicesSet('a', perm[i], `i[${i}]`));\n  }\n  reverseFunc.push('return a;}');\n  return reverseFunc.join('\\n');\n};\n\nconst createDepthToSpaceProgramInfo = (inputTensor: TensorView, attributes: DepthToSpaceAttributes): ProgramInfo => {\n  let n: number, h: number, w: number, c: number;\n  let shape: number[];\n  let perm: number[];\n  const isChannelLast = attributes.format === 'NHWC';\n  const blocksize = attributes.blocksize;\n  const isDCRmode = attributes.mode === 'DCR';\n  if (isChannelLast) {\n    [n, h, w, c] = inputTensor.dims;\n    shape = isDCRmode ? [n, h, w, blocksize, blocksize, c / (blocksize ** 2)] :\n                        [n, h, w, c / (blocksize ** 2), blocksize, blocksize];\n    perm = isDCRmode ? [0, 1, 3, 2, 4, 5] : [0, 1, 4, 2, 5, 3];\n  } else {\n    [n, h, w, c] = [inputTensor.dims[0], inputTensor.dims[2], inputTensor.dims[3], inputTensor.dims[1]];\n    shape = isDCRmode ? [n, blocksize, blocksize, c / (blocksize ** 2), h, w] :\n                        [n, c / (blocksize ** 2), blocksize, blocksize, h, w];\n    perm = isDCRmode ? [0, 3, 4, 1, 5, 2] : [0, 1, 4, 2, 5, 3];\n  }\n  const reshapedInputTensor = inputTensor.reshape(shape);\n  const reshapedInputRank = reshapedInputTensor.dims.length;\n  const inputDataType = inputTensor.dataType;\n\n  const reshapedInput = inputVariable('a', inputDataType, reshapedInputRank);\n  const permedOutput = outputVariable('output', inputDataType, reshapedInputRank);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(reshapedInput, permedOutput)}\n\n  ${permFunctionBody(perm, reshapedInputRank, reshapedInput, permedOutput)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n    let indices = ${permedOutput.offsetToIndices('global_idx')};\n    let aIndices = perm(indices);\n\n    ${permedOutput.setByOffset('global_idx', reshapedInput.getByIndices('aIndices'))}\n  }`;\n\n  return {\n    name: 'DepthToSpace',\n    shaderCache: {hint: `${inputTensor.dims};${attributes.blocksize};${attributes.mode}`, inputDependencies: ['rank']},\n    getRunData: (inputs) => {\n      const outputShape = isChannelLast ? [n, h * blocksize, w * blocksize, c / (blocksize ** 2)] :\n                                          [n, c / (blocksize ** 2), h * blocksize, w * blocksize];\n      const outputSize = ShapeUtil.size(outputShape);\n      const shapeBeforePerm = reshapedInputTensor.dims;\n      const shapeAfterPerm = ShapeUtil.sortBasedOnPerm(shapeBeforePerm, perm);\n      return {\n        outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n        dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n        programUniforms:\n            [{type: DataType.uint32, data: outputSize}, ...createTensorShapeVariables(shapeBeforePerm, shapeAfterPerm)],\n      };\n    },\n    getShaderSource,\n  };\n};\n\nexport const depthToSpace = (context: ComputeContext, attributes: DepthToSpaceAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createDepthToSpaceProgramInfo(context.inputs[0], attributes));\n};\n\nexport const parseDepthToSpaceAttributes = (attributes: Record<string, unknown>): DepthToSpaceAttributes =>\n    createAttributeWithCacheKey({\n      blocksize: attributes.blocksize as number,\n      mode: attributes.mode as string,\n      format: attributes.format as 'NHWC' | 'NCHW'\n    });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface EinsumAttributes extends AttributeWithCacheKey {\n  readonly equation: string;\n}\n// The equation attribute value is a string which consists of left hand side (LHS) and optionally right hand side (RHS)\n// separated by '->'. Ex. \"ij,jk -> ik\" expresses matrix multiplication\n//     \"ij->ji\" expresses matrix transpose\n//      \"ii->i\" diagonal elements of a square matrix\n// LHS consists of a sequence of terms separated by commas. Each term corresponds to an input variable.\n// Each symbol corresponds to a dimension in the input variable. The symbol can be either a letter, 'a' to 'z' or 'A' to\n// 'Z' or '...' to represent arbitrary dimensions.\n\nconst symbolPattern =\n    '[a-zA-Z]|\\\\.\\\\.\\\\.';  // The pattern each symbol in each term in the symbolic equation should match\nconst termPattern = '(' + symbolPattern + ')+';   // The pattern each term in the symbolic equation should match\nconst termPatternOnly = '^' + termPattern + '$';  // The patterns only matchs a term begin to end.\nconst lhsPattern = '(' + termPattern + ',)*' + termPattern;  // The pattern the LHS should match\nconst lhsPatternOnly = '^' + lhsPattern + '$';               // The patterns only matchs a LHS begin to end.\n\ninterface SymbolInfo {\n  count: number;           // Symbol corresponding to a dimmension of an input\n  inputIndices: number[];  // Number of input variables the symbol corresponds to\n  dimValue: number;        // Number of dimensions the symbol corresponds to\n}\n\nclass EinsumTerm {\n  constructor(inputIndex = -1) {\n    this.symbolToIndices = new Map<string, number[]>();\n    this.inputIndex = inputIndex;\n  }\n\n  // Add a symbol to the term\n  addSymbol(symbol: string, index: number) {\n    let value = this.symbolToIndices.get(symbol);\n    if (value === undefined) {\n      value = [index];\n    } else {\n      value.push(index);\n    }\n    this.symbolToIndices.set(symbol, value);\n  }\n\n  symbolToIndices: Map<string, number[]>;  // Map from symbol to dimensions of the input corresponding to the term\n  inputIndex: number;                      // -1 for output and 0, 1, 2, ... for inputs\n}\n\nclass EinsumEquation {\n  constructor(inputs: readonly TensorView[], public readonly equation: string) {\n    this.hasEllipsis = false;\n    this.symbolToInfo = new Map<string, SymbolInfo>();\n    this.lhs = new Array<EinsumTerm>();\n    this.outputDims = [];\n    // As rhs needs to be updated allow using let instead of const for both lhs and rhs.\n    // eslint-disable-next-line prefer-const\n    let [lhs, rhs] = equation.includes('->') ? equation.split('->', 2) : [equation, ''];\n    if (!lhs.match(RegExp(lhsPatternOnly))) {\n      throw new Error('Invalid LHS term');\n    }\n    const inputTerms = lhs.split(',');\n    inputTerms.forEach((inputTerm, index) => {\n      const dims = inputs[index].dims.slice();\n      if (!inputTerm.match(RegExp(termPatternOnly))) {\n        throw new Error('Invalid LHS term');\n      }\n      const einsumTerm = this.processTerm(inputTerm, true, dims, index);\n      this.lhs.push(einsumTerm);\n    });\n\n    // Initialize the RHS if not specified\n    if (rhs === '') {\n      // Construct RHS from LHS terms/symbols\n      rhs += [...this.symbolToInfo.entries()]\n                 .filter(([sym, info]) => (info.count === 1 || sym === '...'))\n                 .map(([sym]) => sym)\n                 .join('');\n    } else {\n      if (!rhs.match(RegExp(termPattern))) {\n        throw new Error('Invalid RHS');\n      }\n    }\n\n    // Compute output dims\n    const rhsSymbols = rhs.match(RegExp(symbolPattern, 'g'));\n    rhsSymbols?.forEach((symbol) => {\n      if (symbol === '...') {\n        this.outputDims = this.outputDims.concat(this.ellipsisDims);\n      } else {\n        const info = this.symbolToInfo.get(symbol);\n        if (info === undefined) {\n          throw new Error('Invalid RHS symbol');\n        }\n        this.outputDims.push(info.dimValue);\n      }\n    });\n    this.rhs = this.processTerm(rhs, false, this.outputDims);\n  }  // End of EinsumEqation constructor\n\n  // Add a symbol to the equation\n  addSymbol(symbol: string, dimValue: number, inputIndex: number) {\n    let info = this.symbolToInfo.get(symbol);\n    if (info !== undefined) {\n      if (info.dimValue !== dimValue && info.count !== 1) {\n        throw new Error('Dimension mismatch');\n      } else {\n        info.count++;\n        info.inputIndices.push(inputIndex);\n      }\n    } else {\n      info = {count: 1, dimValue, inputIndices: [inputIndex]};\n    }\n    this.symbolToInfo.set(symbol, info);\n  }\n\n  // Process one input/output term\n  processTerm(term: string, isInput: boolean, dims: readonly number[], index = -1): EinsumTerm {\n    const rank = dims.length;\n    let ellipsis = false;\n    let ellipsisDims = [];\n    let nextDim = 0;\n    // For output empty string is allowed because the output may be reduced to a scalar value\n    if (!term.match(RegExp(termPatternOnly)) && (!isInput && term !== '')) {\n      throw new Error('Invalid LHS term');\n    }\n    const indexSymbols = term.match(RegExp(symbolPattern, 'g'));\n    const einsumTerm = new EinsumTerm(index);\n    // symbol can be either a lettre, 'a' to 'z' or 'A' to 'Z', or '...'\n    indexSymbols?.forEach((symbol: string, i: number) => {\n      if (symbol === '...') {\n        if (ellipsis) {\n          throw new Error('Only one ellipsis is allowed per input term');\n        }\n        ellipsis = true;\n        const ellipsisDimLength = rank - indexSymbols.length + 1;\n        if (ellipsisDimLength < 0) {\n          throw new Error('Ellipsis out of bounds');\n        }\n        ellipsisDims = dims.slice(nextDim, nextDim + ellipsisDimLength);\n        if (this.hasEllipsis) {\n          if (this.ellipsisDims.length !== ellipsisDims.length ||\n              this.ellipsisDims.toString() !== ellipsisDims.toString()) {\n            throw new Error('Ellipsis dimensions mismatch');\n          }\n        } else if (isInput) {\n          this.hasEllipsis = true;\n          this.ellipsisDims = ellipsisDims;\n        } else {\n          throw new Error('Ellipsis must be specified in the LHS');\n        }\n        // Add '0', '1', '2', '3', '4', etc to represent ellipsis dimensions to avoid special handling\n        for (let j = 0; j < ellipsisDims.length; j++) {\n          const symbol = String.fromCharCode('0'.charCodeAt(0) + j);\n          einsumTerm.addSymbol(symbol, i + j);\n          this.addSymbol(symbol, dims[nextDim++], index);\n        }\n      } else {\n        einsumTerm.addSymbol(symbol, i + (this.hasEllipsis ? this.ellipsisDims.length - 1 : 0));\n        this.addSymbol(symbol, dims[nextDim++], index);\n      }\n    });\n    return einsumTerm;\n  }\n\n  symbolToInfo: Map<string, SymbolInfo>;  // All symbols in the equation\n  hasEllipsis: boolean;                   // The equation has ellipsis or not\n  ellipsisDims: number[];                 // The dimensions of the equation ellipsis corresponds to.\n  lhs: EinsumTerm[];                      // Terms on the left-hand side of the equation\n  rhs: EinsumTerm;                        // Term on the right-hand side of the equation\n  outputDims: number[];                   // Output dimensions of the equation\n}  // End of class EinsumEquation\n\nconst appendMax = (name: string): string => name + '_max';\n\nconst createEinsumProgramInfo =\n    (inputShapes: Array<readonly number[]>, dataType: number, einsumEquation: EinsumEquation,\n     outputShape: readonly number[]): ProgramInfo => {\n      const ranks = inputShapes.map((dims) => dims.length);\n      const inputVars = ranks.map((rank, index) => inputVariable(`input${index}`, dataType, rank));\n      const outputSize = ShapeUtil.size(outputShape);\n      const output = outputVariable('output', dataType, outputShape.length);\n      const uniformsSymbols =\n          [...einsumEquation.symbolToInfo.keys()].filter((symbol) => !einsumEquation.rhs.symbolToIndices.has(symbol));\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const idxCopy: string[] = [];\n        const initProd = 'var prod = 1.0;';\n        const initSum = 'var sum = 0.0;';\n        const updateSum = 'sum += prod;';\n        const reduceOpsSetIndices: string[] = [];\n        const reduceOpsLoopHeaders: string[] = [];\n        const reduceOpsLoopFooters: string[] = [];\n        const reduceOpCompute: string[] = [];\n        const isReduceOpsWithoutLoop = einsumEquation.symbolToInfo.size === einsumEquation.rhs.symbolToIndices.size;\n        einsumEquation.symbolToInfo.forEach((info, symbol) => {\n          if (einsumEquation.rhs.symbolToIndices.has(symbol)) {\n            const outputIndex = einsumEquation.rhs.symbolToIndices.get(symbol)?.[0];\n            if (outputIndex !== undefined) {\n              einsumEquation.lhs.forEach((term, i) => {\n                if (info.inputIndices.includes(i)) {\n                  const indices = term.symbolToIndices.get(symbol);\n                  if (indices === undefined) {\n                    throw new Error('Invalid symbol error');\n                  }\n                  indices.forEach((index) => {\n                    idxCopy.push(`${\n                        inputVars[i].indicesSet(\n                            `input${i}Indices`, index, output.indicesGet('outputIndices', outputIndex))}`);\n                  });\n                }\n              });\n            }\n          } else {\n            einsumEquation.lhs.forEach((term, i) => {\n              if (info.inputIndices.includes(i)) {\n                const indices = term.symbolToIndices.get(symbol);\n                if (indices === undefined) {\n                  throw new Error('Invalid symbol error');\n                }\n                indices.forEach((index) => {\n                  reduceOpsSetIndices.push(`${inputVars[i].indicesSet(`input${i}Indices`, index, `${symbol}`)}`);\n                });\n                reduceOpCompute.push(`prod *= ${inputVars[i].getByIndices(`input${i}Indices`)};`);\n              }\n            });\n            reduceOpsLoopHeaders.push(\n                `for(var ${symbol}: u32 = 0; ${symbol} < uniforms.${appendMax(symbol)}; ${symbol}++) {`);\n            reduceOpsLoopFooters.push('}');\n          }\n        });\n        const reduceOps = isReduceOpsWithoutLoop ?\n            [\n              ...idxCopy,\n              `let sum = ${inputVars.map((inputVar, i) => inputVar.getByIndices(`input${i}Indices`)).join(' * ')};`\n            ] :\n            [\n              ...idxCopy,\n              initSum,\n              ...reduceOpsLoopHeaders,\n              ...reduceOpsSetIndices,\n              initProd,\n              ...reduceOpCompute,\n              updateSum,\n              ...reduceOpsLoopFooters,\n            ];\n        return `\n            ${\n            shaderHelper\n                .registerUniforms(uniformsSymbols.map((symbol) => ({name: `${appendMax(symbol)}`, type: 'u32'})))\n                .registerUniform('outputSize', 'u32')\n                .declareVariables(...inputVars, output)}\n\n            ${shaderHelper.mainStart()}\n            ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n            var outputIndices = ${output.offsetToIndices('global_idx')};\n            ${inputVars.map((_var, i) => `var input${i}Indices: ${inputVars[i].type.indices};`).join('\\n')}\n            ${reduceOps.join('\\n')};\n            ${output.setByOffset('global_idx', 'sum')};\n          }`;\n      };\n      return {\n        name: 'Einsum',\n        shaderCache: {hint: einsumEquation.equation, inputDependencies: inputShapes.map(() => 'rank')},\n        getRunData: () => {\n          // The symbols from uniformSymbols array are guaranteed to exist in einsumEquations.symbolToInfo map. The\n          // filter is added to make sure that dimValue is never 0.\n          const programUniformsInit: ProgramUniform[] =\n              uniformsSymbols.filter((symbol) => einsumEquation.symbolToInfo.has(symbol))\n                  .map(\n                      (symbol) =>\n                          ({type: DataType.uint32, data: einsumEquation.symbolToInfo.get(symbol)?.dimValue || 0}));\n          programUniformsInit.push({type: DataType.uint32, data: outputSize});\n          const programUniforms: ProgramUniform[] =\n              inputShapes.map((dims, _) => [...createTensorShapeVariables(dims)])\n                  .reduce((acc, inputProgramUniforms) => acc.concat(inputProgramUniforms), programUniformsInit);\n          programUniforms.push(...createTensorShapeVariables(outputShape));\n          return ({\n            outputs: [{dims: outputShape, dataType}],\n            dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n            programUniforms\n          });\n        },\n        getShaderSource,\n      };\n    };\n\nexport const einsum = (context: ComputeContext, attributes: EinsumAttributes): void => {\n  const einsumEquation = new EinsumEquation(context.inputs, attributes.equation);\n  const outputShape = einsumEquation.outputDims;\n  const inputShapes = context.inputs.map((input, _) => input.dims);\n  context.compute(createEinsumProgramInfo(inputShapes, context.inputs[0].dataType, einsumEquation, outputShape));\n};\n\nexport const parseEinsumAttributes = (attributes: Record<string, unknown>): EinsumAttributes => {\n  const equation = (attributes.equation as string).replace(/\\s+/g, '');\n  return createAttributeWithCacheKey({equation});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('Expand requires 2 input.');\n  }\n  const inputShape = inputs[0].dims;\n  const shape = Array.from(inputs[1].getBigInt64Array(), Number);\n\n  let shapeIndex = shape.length < inputShape.length ? 0 : shape.length - inputShape.length;\n  let inputShapeIndex = inputShape.length < shape.length ? 0 : inputShape.length - shape.length;\n  for (; shapeIndex < shape.length && inputShapeIndex < inputShape.length; ++shapeIndex, ++inputShapeIndex) {\n    if (shape[shapeIndex] !== inputShape[inputShapeIndex] && shape[shapeIndex] !== 1 &&\n        inputShape[inputShapeIndex] !== 1) {\n      throw new Error('Expand requires shape to be broadcastable to input');\n    }\n  }\n};\n\nconst getAdjustedShape = (shape1: readonly number[], shape2: readonly number[]): number[] => {\n  const diff = shape1.length - shape2.length;\n  const shape: number[] = [];\n  for (let i = 0; i < diff; ++i) {\n    shape.push(shape1[i]);\n  }\n  for (let i = 0; i < shape2.length; ++i) {\n    shape.push(shape2[i] === 1 ? shape1[i + diff] : shape2[i]);\n  }\n  return shape;\n};\n\nconst calculateOutputShape = (inputShape: readonly number[], shape: readonly number[]): number[] =>\n    (inputShape.length > shape.length) ? getAdjustedShape(inputShape, shape) : getAdjustedShape(shape, inputShape);\n\n\nconst createExpandProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const shape = Array.from(inputs[1].getBigInt64Array(), Number);\n  const outputShape: number[] = calculateOutputShape(inputShape, shape);\n  const dataType = inputs[0].dataType;\n  const components = dataType === DataType.bool ? 4 : 1;\n  const outputSize = Math.ceil(ShapeUtil.size(outputShape) / components);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const input = inputVariable('input', dataType, inputShape.length, components);\n    const output = outputVariable('output', dataType, outputShape.length, components);\n    let assignment: string;\n    if (dataType === DataType.bool) {\n      const singleAssignment = (resStr: string, x: number, typeCast = '') => `\n          let outputIndices${x} = ${output.offsetToIndices(`outputOffset + ${x}u`)};\n          let offset${x} = ${input.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n          let index${x} = offset${x} / 4u;\n          let component${x} = offset${x} % 4u;\n          ${resStr}[${x}] = ${typeCast}(${input.getByOffset(`index${x}`)}[component${x}]);\n        `;\n      assignment = `\n        let outputOffset = global_idx * ${components};\n        var data = vec4<u32>(0);\n        ${singleAssignment('data', 0, 'u32')}\n        ${singleAssignment('data', 1, 'u32')}\n        ${singleAssignment('data', 2, 'u32')}\n        ${singleAssignment('data', 3, 'u32')}\n        ${output.setByOffset('global_idx', 'data')}\n      }`;\n    } else {\n      assignment = `\n        let outputIndices = ${output.offsetToIndices('global_idx')};\n        let inputOffset = ${input.broadcastedIndicesToOffset('outputIndices', output)};\n        ${output.setByOffset('global_idx', input.getByOffset('inputOffset'))}\n      }`;\n    }\n    return `\n    ${shaderHelper.registerUniform('vec_size', 'u32').declareVariables(input, output)}\n    ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.vec_size')}\n    ${assignment}`;\n  };\n\n  const programUniforms: ProgramUniform[] =\n      [{type: DataType.uint32, data: outputSize}, ...createTensorShapeVariables(inputShape, outputShape)];\n  return {\n    name: 'Expand',\n    shaderCache: {hint: `${outputShape.length}`, inputDependencies: ['rank']},\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n      programUniforms\n    })\n  };\n};\n\nexport const expand = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  context.compute(createExpandProgramInfo(context.inputs), {inputs: [0]});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglValueType, UniformsArrayType, WORKGROUP_SIZE} from './common';\nimport * as unary from './unary-op';\n\n// GELU is defined as Y=0.5*X*(1+tanh(0.797885*X+0.035677*X*X*X)), where X may pre-add a bias.\n\nconst createFastGeluProgramInfo = (inputTensors: readonly TensorView[]): ProgramInfo => {\n  const dataType = inputTensors[0].dataType;\n  const outputSize = ShapeUtil.size(inputTensors[0].dims);\n  const biasLength = ShapeUtil.size(inputTensors[1].dims);\n  // can only use vec4 when bias length is multiple of 4\n  const useVec4 = biasLength % 4 === 0;\n  const getShaderSource = (shaderHelper: ShaderHelper): string => {\n    const x = inputVariable('x', dataType, [1], 4);\n    const bias = inputVariable('bias', dataType, [1], 4);\n    const y = outputVariable('y', dataType, [1], 4);\n\n    const uniforms: UniformsArrayType = [{name: 'output_vec_size', type: 'u32'}, {name: 'bias_size', type: 'u32'}];\n\n    const singleElementBias = (i: 0|1|2|3) => `\n      let bias${i}_offset: u32 = (global_idx * 4 + ${i}) % uniforms.bias_size;\n      let bias${i} = ${bias.getByOffset(`bias${i}_offset / 4`)}[bias${i}_offset % 4];`;\n    const biasGetExpression = useVec4 ?\n        `\n      let bias = ${bias.getByOffset('global_idx % (uniforms.bias_size / 4)')};` :\n        `${singleElementBias(0)}${singleElementBias(1)}${singleElementBias(2)}${singleElementBias(3)}\n      let bias = ${x.type.value}(bias0, bias1, bias2, bias3);`;\n\n    return `${shaderHelper.registerUniforms(uniforms).declareVariables(x, bias, y)}\n\n    ${unary.fastGeluImpl(tensorTypeToWsglValueType(dataType))}\n\n    ${shaderHelper.mainStart(WORKGROUP_SIZE)}\n      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_vec_size')}\n\n      let x = ${x.getByOffset('global_idx')};\n      ${biasGetExpression}\n      let x_in = x + bias;\n      ${y.setByOffset('global_idx', unary.fastGeluExpression('x_in'))}\n    }`;\n  };\n\n  return {\n    name: 'FastGeluWithBias',\n    shaderCache: {hint: `${useVec4}`, inputDependencies: ['type', 'type']},\n    getShaderSource,\n    getRunData: (inputs) => ({\n      outputs: [{dims: inputs[0].dims, dataType: inputs[0].dataType}],\n      programUniforms:\n          [{type: DataType.uint32, data: Math.ceil(outputSize / 4)}, {type: DataType.uint32, data: biasLength}],\n      dispatchGroup: {x: Math.ceil(outputSize / WORKGROUP_SIZE / 4)}\n    })\n  };\n};\n\nexport const fastGelu = (context: ComputeContext): void => {\n  if (context.inputs.length < 2 || ShapeUtil.size(context.inputs[1].dims) === 0) {\n    unary.fastGelu(context);\n  } else {\n    context.compute(createFastGeluProgramInfo(context.inputs));\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface GatherAttributes extends AttributeWithCacheKey {\n  axis: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('Gather requires 2 inputs.');\n  }\n};\n\nconst createGatherProgramInfo = (inputs: readonly TensorView[], attributes: GatherAttributes): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const indicesShape = inputs[1].dims;\n\n  const inputRank = inputShape.length;\n  const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank);\n\n  const outputShape = inputShape.slice(0);\n  outputShape.splice(axis, 1, ...indicesShape);\n\n  const axisDimLimit = inputShape[axis];\n  const components = inputs[0].dataType === DataType.bool ? 4 : 1;\n  const outputSize = Math.ceil(ShapeUtil.size(outputShape) / components);\n\n  const programUniforms: ProgramUniform[] = [\n    {type: DataType.uint32, data: outputSize}, {type: DataType.int32, data: axisDimLimit},\n    {type: DataType.uint32, data: axis}, ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims, outputShape)\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const data = inputVariable('data', inputs[0].dataType, inputs[0].dims.length, components);\n    const indices = inputVariable('inputIndices', inputs[1].dataType, inputs[1].dims.length);\n    const output = outputVariable('output', inputs[0].dataType, outputShape.length, components);\n\n    const calcDataIndices = (x: number|string): string => {\n      const indicesRank = indicesShape.length;\n      let calcStr = `var indicesIndices${x}  = ${indices.type.indices}(0);`;\n      for (let i = 0; i < indicesRank; i++) {\n        calcStr += `${indicesRank > 1 ? `indicesIndices${x}[${i}]` : `indicesIndices${x}`} = ${\n            outputShape.length > 1 ? `outputIndices${x}[uniforms.axis + ${i}]` : `outputIndices${x}`};`;\n      }\n      calcStr += `\n          var idx${x} = ${indices.getByIndices(`indicesIndices${x}`)};\n          if (idx${x} < 0) {\n            idx${x} = idx${x} + uniforms.axisDimLimit;\n          }\n          var dataIndices${x} : ${data.type.indices};\n        `;\n      for (let i = 0, j = 0; i < inputRank; i++) {\n        if (i === axis) {\n          calcStr += `${inputRank > 1 ? `dataIndices${x}[${i}]` : `dataIndices${x}`} = u32(idx${x});`;\n          j += indicesRank;\n        } else {\n          calcStr += `${inputRank > 1 ? `dataIndices${x}[${i}]` : `dataIndices${x}`} = ${\n              outputShape.length > 1 ? `outputIndices${x}[${j}]` : `outputIndices${x}`};`;\n          j++;\n        }\n      }\n      return calcStr;\n    };\n    let assignment: string;\n    if (inputs[0].dataType === DataType.bool) {\n      const singleAssignment = (resStr: string, x: number, typeCast = '') => `\n          let outputIndices${x} = ${output.offsetToIndices(`outputOffset + ${x}u`)};\n          ${calcDataIndices(x)};\n          let offset${x} = ${data.indicesToOffset(`dataIndices${x}`)};\n          let index${x} = offset${x} / 4u;\n          let component${x} = offset${x} % 4u;\n          ${resStr}[${x}] = ${typeCast}(${data.getByOffset(`index${x}`)}[component${x}]);\n        `;\n      assignment = `\n        let outputOffset = global_idx * ${components};\n        var value = vec4<u32>(0);\n        ${singleAssignment('value', 0, 'u32')}\n        ${singleAssignment('value', 1, 'u32')}\n        ${singleAssignment('value', 2, 'u32')}\n        ${singleAssignment('value', 3, 'u32')}\n        ${output.setByOffset('global_idx', 'value')}\n      `;\n    } else {\n      assignment = `\n      let outputIndices = ${output.offsetToIndices('global_idx')};\n      ${calcDataIndices('')};\n      let value = ${data.getByIndices('dataIndices')};\n      ${output.setByOffset('global_idx', 'value')};\n      `;\n    }\n    return `\n      ${\n        shaderHelper.registerUniform('outputSize', 'u32')\n            .registerUniform('axisDimLimit', 'i32')\n            .registerUniform('axis', 'u32')\n            .declareVariables(data, indices, output)}\n      ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n        ${assignment}\n      }`;\n  };\n  return {\n    name: 'Gather',\n    shaderCache: {hint: attributes.cacheKey, inputDependencies: ['rank', 'rank']},\n    getRunData: () => ({\n      outputs: [\n        {dims: outputShape, dataType: inputs[0].dataType},\n      ],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n      programUniforms\n    }),\n    getShaderSource,\n  };\n};\n\nexport const parseGatherAttributes = (attributes: Record<string, unknown>): GatherAttributes =>\n    createAttributeWithCacheKey({axis: attributes.axis as number});\n\nexport const gather = (context: ComputeContext, attributes: GatherAttributes): void => {\n  const inputs = context.inputs;\n  validateInputs(inputs);\n  context.compute(createGatherProgramInfo(context.inputs, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface GatherElementsAttributes extends AttributeWithCacheKey {\n  axis: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('GatherElements requires 2 inputs.');\n  }\n\n  if (inputs[0].dims.length < 1) {\n    throw new Error('GatherElements requires that the data input be rank >= 1.');\n  }\n\n  if (inputs[0].dims.length !== inputs[1].dims.length) {\n    throw new Error(`GatherElements requires that the data input and\n                     indices input tensors be of same rank.`);\n  }\n};\n\nconst createGatherElementsProgramInfo =\n    (inputs: readonly TensorView[], attributes: GatherElementsAttributes): ProgramInfo => {\n      const inputShape = inputs[0].dims;\n      const inputOutputDataType = inputs[0].dataType;\n      const inputRank = inputShape.length;\n\n      const indicesShape = inputs[1].dims;\n      const indicesDataType = inputs[1].dataType;\n      const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank);\n      const axisDimLimit = inputShape[axis];\n\n      const outputShape = indicesShape.slice(0);\n      const outputSize = ShapeUtil.size(outputShape);\n\n      const input = inputVariable('input', inputOutputDataType, inputRank);\n      const indices = inputVariable('indicesInput', indicesDataType, indicesShape.length);\n      const output = outputVariable('output', inputOutputDataType, outputShape.length);\n\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize}, {type: DataType.int32, data: axisDimLimit},\n        {type: DataType.uint32, data: axis}\n      ];\n      programUniforms.push(...createTensorShapeVariables(inputShape, indicesShape, outputShape));\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n\n      // int64 indices would be treated as little endian i32 with assumption they fall in i32 limits\n      // That assumption is safe as it's not possible to allocate >2gb buffer for input tensor\n      // Input data will be treated as u32 or two u32 for 8-byte tensors\n      const getShaderSource = (shaderHelper: ShaderHelper) => `\n      ${\n          shaderHelper.registerUniform('outputSize', 'u32')\n              .registerUniform('axisDimLimit', 'i32')\n              .registerUniform('axis', 'u32')\n              .declareVariables(input, indices, output)}\n      ${shaderHelper.mainStart()}\n      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n\n      let outputIndices = ${output.offsetToIndices('global_idx')};\n\n      var idx = ${indices.getByOffset('global_idx')};\n      if (idx < 0) {\n        idx = idx + uniforms.axisDimLimit;\n      }\n      var inputIndices = ${input.type.indices}(outputIndices);\n      ${input.indicesSet('inputIndices', 'uniforms.axis', 'u32(idx)')};\n      let value = ${input.getByIndices('inputIndices')};\n\n      ${output.setByOffset('global_idx', 'value')};\n  }`;\n\n      return {\n        name: 'GatherElements',\n        shaderCache: {inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n\nexport const parseGatherElementsAttributes = (attributes: Record<string, unknown>): GatherElementsAttributes =>\n    createAttributeWithCacheKey({axis: attributes.axis as number});\n\nexport const gatherElements = (context: ComputeContext, attributes: GatherElementsAttributes): void => {\n  const inputs = context.inputs;\n  validateInputs(inputs);\n  context.compute(createGatherElementsProgramInfo(context.inputs, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {GemmUtil, ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper, UniformsArrayType} from './common';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs) {\n    throw new Error('Input is missing');\n  }\n  if (inputs.length < 2 || inputs.length > 3) {\n    throw new Error('Invaid input number.');\n  }\n\n  // 'C' can be of dimensionality 0, 1 or 2 only\n  if (inputs.length === 3 && inputs[2].dims.length > 2) {\n    throw new Error('Invalid input shape of C');\n  }\n\n  if ((inputs[0].dataType !== inputs[1].dataType) ||\n      (inputs.length === 3 && inputs[0].dataType !== inputs[2].dataType)) {\n    throw new Error('Input types are mismatched');\n  }\n};\n\nexport interface GemmAttributes extends AttributeWithCacheKey {\n  transA: boolean;\n  transB: boolean;\n  alpha: number;\n  beta: number;\n}\n\nconst createGemmProgramInfo = (inputs: readonly TensorView[], attributes: GemmAttributes): ProgramInfo => {\n  const aShape = inputs[0].dims.slice();\n  const bShape = inputs[1].dims.slice();\n  const [M, N, K] = GemmUtil.getShapeOfGemmResult(\n      aShape, attributes.transA, bShape, attributes.transB, inputs.length === 3 ? inputs[2].dims : undefined);\n  const outputShape = [M, N];\n  if (!outputShape) {\n    throw new Error('Can\\'t use gemm on the given tensors');\n  }\n  const outputSize = ShapeUtil.size(outputShape);\n  const programUniforms: ProgramUniform[] = [\n    {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: M}, {type: DataType.uint32, data: N},\n    {type: DataType.uint32, data: K}, {type: DataType.float, data: attributes.alpha},\n    {type: DataType.float, data: attributes.beta}\n  ];\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n  if (inputs.length === 3) {\n    programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n    inputDependencies.push('rank');\n  }\n  programUniforms.push(...createTensorShapeVariables(outputShape));\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    let line = '';\n    if (attributes.transA && attributes.transB) {\n      line = 'value += a[k * uniforms.M + m] * b[n * uniforms.K + k];';\n    } else if (attributes.transA && !attributes.transB) {\n      line = 'value += a[k * uniforms.M + m] * b[k * uniforms.N + n];';\n    } else if (!attributes.transA && attributes.transB) {\n      line = 'value += a[m * uniforms.K + k] * b[n * uniforms.K + k];';\n    } else if (!attributes.transA && !attributes.transB) {\n      line = 'value += a[m * uniforms.K + k] * b[k * uniforms.N + n];';\n    }\n\n    const calculateAlpha = attributes.alpha === 1 ? '' : 'value *= uniforms.alpha;';\n    const a = inputVariable('a', inputs[0].dataType, inputs[0].dims);\n    const b = inputVariable('b', inputs[1].dataType, inputs[1].dims);\n    const dataType = a.type.value;\n    let c: IndicesHelper|null = null;\n    const variables = [a, b];\n    if (inputs.length === 3) {\n      c = inputVariable('c', inputs[2].dataType, inputs[2].dims.length);\n      variables.push(c);\n    }\n    const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n    variables.push(output);\n    const uniforms: UniformsArrayType = [\n      {name: 'output_size', type: 'u32'}, {name: 'M', type: 'u32'}, {name: 'N', type: 'u32'}, {name: 'K', type: 'u32'},\n      {name: 'alpha', type: 'f32'}, {name: 'beta', type: 'f32'}\n    ];\n    return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n    let m = global_idx / uniforms.N;\n    let n = global_idx % uniforms.N;\n\n    var value = ${dataType}(0);\n    for (var k: u32 = 0u; k < uniforms.K; k++) {\n      ${line}\n    }\n\n    ${calculateAlpha}\n    ${(() => {\n      if (c != null) {\n        return `let cOffset = ${c.broadcastedIndicesToOffset('vec2(m, n)', output)}; value += ${\n            dataType}(uniforms.beta) * ${c.getByOffset('cOffset')};`;\n      }\n      return '';\n    })()}\n    output[global_idx] = value;\n  }`;\n  };\n\n  return {\n    name: 'Gemm',\n    shaderCache: {hint: `${attributes.cacheKey}`, inputDependencies},\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n      programUniforms\n    }),\n    getShaderSource,\n  };\n};\n\nexport const parseGemmAttributes = (attributes: Record<string, unknown>): GemmAttributes => {\n  const transA = attributes.transA as boolean;\n  const transB = attributes.transB as boolean;\n  const alpha = attributes.alpha as number;\n  const beta = attributes.beta as number;\n  return {transA, transB, alpha, beta, cacheKey: `${attributes.transA};${attributes.transB};${attributes.alpha === 1}`};\n};\n\nexport const gemm = (context: ComputeContext, attributes: GemmAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createGemmProgramInfo(context.inputs, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, fillVector, getMaxComponents, inputVariable, outputVariable, ShaderHelper, sumVector, tensorTypeToWsglStorageType, UniformsArrayType} from './common';\n\nexport interface InstanceNormAttributes {\n  epsilon: number;\n  format: 'NHWC'|'NCHW';\n}\n\nconst createInstanceNormProgramInfo =\n    (inputs: readonly TensorView[], attributes: InstanceNormAttributes): ProgramInfo => {\n      const xShape = inputs[0].dims;\n      const outputShape = xShape;\n      const axis = 2;\n      const normCount = ShapeUtil.sizeToDimension(xShape, axis);\n      const normSize = ShapeUtil.sizeFromDimension(xShape, axis);\n      const components = getMaxComponents(normSize);\n      const normPackedSize = normSize / components;\n      const inputShape = [xShape[0], xShape[1], normPackedSize];\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'type', 'type'];\n      const programUniforms: ProgramUniform[] =\n          [{type: DataType.uint32, data: normSize}, {type: DataType.uint32, data: normPackedSize}];\n      programUniforms.push(...createTensorShapeVariables(inputShape, inputShape));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const x = inputVariable('x', inputs[0].dataType, inputShape.length, components);\n        const scale = inputVariable('scale', inputs[1].dataType, inputs[1].dims);\n        const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims);\n        const output = outputVariable('output', inputs[0].dataType, inputShape.length, components);\n        const variables = [x, scale, bias, output];\n        const dataType = x.type.value;\n        const f32Type = components === 1 ? 'f32' : `vec${components}<f32>`;\n        const workgroupSize = 64;\n\n        const uniforms: UniformsArrayType = [{name: 'normSize', type: 'u32'}, {name: 'normPackedSize', type: 'u32'}];\n        return `\n  var<workgroup> meanShared : f32;\n  var<workgroup> squaredNormShared : f32;\n  var<workgroup> workgroupShared : array<${f32Type}, ${workgroupSize}>;\n  const workgroupSize = ${workgroupSize}u;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n  ${shaderHelper.mainStart(workgroupSize)}\n    let norm = global_idx / workgroupSize;\n    let batch = norm / uniforms.x_shape[1];\n    let channel = norm % uniforms.x_shape[1];\n    let localIndex = local_id.x;\n\n    // initialize workgroup memory\n    var initial = ${f32Type}(0);\n    for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) {\n      initial = initial + ${f32Type}(${x.get('batch', 'channel', 'h')});\n    }\n    workgroupShared[localIndex] = initial;\n    workgroupBarrier();\n\n    // Calculate the mean of current channel data.\n    for (var currSize = workgroupSize >> 1;  currSize > 0; currSize = currSize >> 1) {\n      if (localIndex < currSize) {\n        workgroupShared[localIndex] = workgroupShared[localIndex] + workgroupShared[localIndex + currSize];\n      }\n      workgroupBarrier();\n    }\n    if (localIndex == 0) {\n      meanShared = ${sumVector('workgroupShared[0]', components)} / f32(uniforms.normSize);\n    }\n    workgroupBarrier();\n\n    // reinitialize workgroup memory.\n    initial = ${f32Type}(0);\n    for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) {\n      let deviation =  ${f32Type}(${x.get('batch', 'channel', 'h')}) - ${f32Type}(meanShared);\n      initial = initial + deviation * deviation;\n    }\n    workgroupShared[localIndex] = initial;\n    workgroupBarrier();\n\n    // Calculate the sum of square of deviation of current channel data.\n    for (var currSize = workgroupSize >> 1;  currSize > 0; currSize = currSize >> 1) {\n      if (localIndex < currSize) {\n        workgroupShared[localIndex] = workgroupShared[localIndex] + workgroupShared[localIndex + currSize];\n      }\n      workgroupBarrier();\n    }\n    if (localIndex == 0) {\n      squaredNormShared = ${sumVector('workgroupShared[0]', components)};\n    }\n    workgroupBarrier();\n\n    let invStdDev = inverseSqrt(squaredNormShared / f32(uniforms.normSize) + f32(${attributes.epsilon}));\n    let channelScale = invStdDev * f32(${scale.getByOffset('channel')});\n    let channelShift = f32(${bias.getByOffset('channel')}) - meanShared * channelScale;\n    for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) {\n      let value = ${x.get('batch', 'channel', 'h')} * ${dataType}(${f32Type}(channelScale)) + ${dataType}(${\n            f32Type}(channelShift));\n      ${output.set('batch', 'channel', 'h', 'value')};\n    }\n  }`;\n      };\n      return {\n        ...{name: 'InstanceNormalization'},\n        // TODO: use epsilon as uniform. Currently epsilon as uniform fails test_instancenorm_epsilon.\n        shaderCache: {hint: `${attributes.epsilon};${components}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [\n            {dims: outputShape, dataType: inputs[0].dataType},\n          ],\n          dispatchGroup: {x: normCount},\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n\nconst computeMean =\n    (context: ComputeContext, input: TensorView, scale: TensorView, bias: TensorView, n: number, h: number, c: number,\n     epsilon: number) => {\n      const components = getMaxComponents(c);\n      const WG = 64;\n      // we will store channel scale and channel shift in [2, components] matrix\n      // or in vec2 when components == 1\n      const outputType = components === 1 ? 'vec2f' : `mat2x${components}f`;\n      const sumCastType = components === 1 ? 'f32' : `vec${components}f`;\n      const setOutputValue = (var1: string, var2: string) => `${outputType}(${var1}, ${var2})`;\n      const unitsOfWork = n * c / components;\n      const wgSize = Math.ceil(h / WG);\n\n      const meanInputDependencies: ProgramInputTensorInfoDependency[] = ['type'];\n      const meanProgramUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: wgSize}, {type: DataType.uint32, data: h},\n        {type: DataType.uint32, data: Math.floor(c / components)},\n        {type: DataType.uint32, data: Math.floor(h * c / components)}\n      ];\n\n      const getMeanShaderSource = (shaderHelper: ShaderHelper) => {\n        const inputHelper = inputVariable('input', input.dataType, input.dims, components);\n        return `\n  ${shaderHelper.declareVariables(inputHelper)}\n  @group(0) @binding(1) var<storage, read_write> output : array<${outputType}>;\n  struct Uniforms {wg_size:u32, H:u32, C:u32, image_size:u32};\n  @group(0) @binding(2) var<uniform> uniforms: Uniforms;\n\n  ${shaderHelper.mainStart(WG)}\n    let currentImageNumber = global_idx / ${WG} / uniforms.C;\n    let currentChannelNumber = (global_idx / ${WG}) % uniforms.C;\n    let wgOffset = local_id.x * uniforms.wg_size;\n    if (wgOffset >= uniforms.H) {\n        return;\n    }\n    let wgMax = min(wgOffset + uniforms.wg_size, uniforms.H);\n\n    let offset = currentImageNumber * uniforms.image_size + currentChannelNumber;\n    var sum = ${fillVector('f32', components)};\n    var squaredSum = ${fillVector('f32', components)};\n    for (var i: u32 = wgOffset; i < wgMax; i++) {\n        let value = ${sumCastType}(input[offset + i * uniforms.C]);\n        sum += value;\n        squaredSum += value * value;\n    }\n    output[global_idx] = ${setOutputValue('sum', 'squaredSum')};\n  }`;\n      };\n\n      const meanValues = context.compute(\n          {\n            name: 'InstanceNormComputeMean',\n            shaderCache: {hint: `${components}`, inputDependencies: meanInputDependencies},\n            getRunData: () => ({\n              outputs: [\n                {dims: [n, c, WG, 2], dataType: DataType.float},\n              ],\n              dispatchGroup: {x: n * c / components},\n              programUniforms: meanProgramUniforms\n            }),\n            getShaderSource: getMeanShaderSource,\n          },\n          {inputs: [input], outputs: [-1]})[0];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: unitsOfWork}, {type: DataType.uint32, data: h},\n        {type: DataType.uint32, data: Math.floor(c / components)},\n        {type: DataType.uint32, data: Math.floor(WG * c / components)}\n      ];\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type', 'type'];\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const scaleHelper = inputVariable('scale', scale.dataType, scale.dims, components);\n        const biasHelper = inputVariable('bias', bias.dataType, bias.dims, components);\n        return `\n  @group(0) @binding(0) var<storage, read> input : array<${outputType}>;\n  @group(0) @binding(1) var<storage, read> scale : array<${scaleHelper.type.storage}>;\n  @group(0) @binding(2) var<storage, read> bias : array<${biasHelper.type.storage}>;\n  @group(0) @binding(3) var<storage, read_write> output : array<${outputType}>;\n  struct Uniforms {units_of_work : u32, H: u32, C : u32, image_size : u32};\n  @group(0) @binding(4) var<uniform> uniforms: Uniforms;\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.units_of_work')}\n    let currentImageNumber = global_idx / uniforms.C;\n    let currentChannelNumber = global_idx % uniforms.C;\n\n    let offset = currentImageNumber * uniforms.image_size;\n    var sum = ${fillVector('f32', components)};\n    var squaredSum = ${fillVector('f32', components)};\n    for (var i: u32 = 0; i < min(${WG}, uniforms.H); i++) {\n        let value = input[offset + i + currentChannelNumber * ${WG}];\n        sum += value[0];\n        squaredSum += value[1];\n    }\n    sum = sum / f32(uniforms.H);\n    squaredSum = squaredSum / f32(uniforms.H);\n    let invStdDev = inverseSqrt(squaredSum - sum * sum + f32(${epsilon}));\n    let channelScale = invStdDev * ${sumCastType}(scale[currentChannelNumber]);\n    let channelShift = ${sumCastType}(bias[currentChannelNumber]) - sum * channelScale;\n\n    output[global_idx] = ${setOutputValue('channelScale', 'channelShift')};\n  }`;\n      };\n      return context.compute(\n          {\n            name: 'InstanceNormComputeChannelScaleShift',\n            // TODO: use epsilon as uniform. Currently epsilon as uniform fails test_instancenorm_epsilon.\n            shaderCache: {hint: `${components};${epsilon}`, inputDependencies},\n            getRunData: () => ({\n              outputs: [\n                {dims: [n, c, 2], dataType: DataType.float},\n              ],\n              dispatchGroup: {x: Math.ceil(unitsOfWork / 64 /* workgroup size */)},\n              programUniforms\n            }),\n            getShaderSource,\n          },\n          {inputs: [meanValues, scale, bias], outputs: [-1]})[0];\n    };\n\nconst createInstanceNormNHWCProgramInfo =\n    (context: ComputeContext, inputs: readonly TensorView[], attributes: InstanceNormAttributes) => {\n      const xShape = inputs[0].dims;\n      const outputShape = xShape;\n      const N = xShape[0];\n      const C = xShape[xShape.length - 1];\n      const H = ShapeUtil.sizeFromDimension(xShape, 1) / C;\n      const components = getMaxComponents(C);\n      const outputSize = ShapeUtil.size(outputShape) / components;\n      const programUniforms: ProgramUniform[] =\n          [{type: DataType.uint32, data: H}, {type: DataType.uint32, data: Math.floor(C / components)}];\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n      // first compute mean\n      const channelScaleShift = computeMean(context, inputs[0], inputs[1], inputs[2], N, H, C, attributes.epsilon);\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n        const scaleType = components === 1 ? 'vec2f' : `mat2x${components}f`;\n        const scaleCastType = components === 1 ? dataType : `vec${components}<${dataType}>`;\n\n        const inputHelper = inputVariable('input', inputs[0].dataType, inputs[0].dims, components);\n        const outputHelper = outputVariable('output', inputs[0].dataType, outputShape, components);\n\n        return `\n  @group(0) @binding(0) var<storage, read> input : array<${inputHelper.type.storage}>;\n  @group(0) @binding(1) var<storage, read> scaleInput : array<${scaleType}>;\n  @group(0) @binding(2) var<storage, read_write> output : array<${outputHelper.type.storage}>;\n  struct Uniforms {H: u32, C : u32};\n  @group(0) @binding(3) var<uniform> uniforms: Uniforms;\n\n  ${shaderHelper.mainStart()}\n    let currentImageNumber = global_idx / (uniforms.C * uniforms.H);\n    let currentChannelNumber = global_idx % uniforms.C;\n\n    let scaleOffset = currentImageNumber * uniforms.C + currentChannelNumber;\n    let scale = scaleInput[scaleOffset];\n    output[global_idx] = fma(input[global_idx], ${scaleCastType}(scale[0]), ${scaleCastType}(scale[1]));\n  }`;\n      };\n      context.compute(\n          {\n            name: 'InstanceNormalizationNHWC',\n            shaderCache: {hint: `${components}`, inputDependencies},\n            getRunData: () => ({\n              outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n              dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n              programUniforms\n            }),\n            getShaderSource,\n          },\n          {inputs: [inputs[0], channelScaleShift]});\n    };\n\nexport const instanceNorm = (context: ComputeContext, attributes: InstanceNormAttributes): void => {\n  if (attributes.format === 'NHWC') {\n    createInstanceNormNHWCProgramInfo(context, context.inputs, attributes);\n  } else {\n    context.compute(createInstanceNormProgramInfo(context.inputs, attributes));\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {castToF32, fillVector, getMaxComponents, inputVariable, outputVariable, ShaderHelper, sumVector, tensorTypeToWsglStorageType, UniformsArrayType,} from './common';\n\ninterface LayerNormAttributes {\n  simplified: boolean;\n  axis: number;\n  epsilon: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length < 2) {\n    throw new Error('layerNorm requires at least 2 inputs.');\n  }\n};\n\nconst createLayerNormProgramInfo =\n    (inputs: readonly TensorView[], attributes: LayerNormAttributes, outputCount: number): ProgramInfo => {\n      const simplified = attributes.simplified;\n\n      const xShape = inputs[0].dims;\n      const scale = inputs[1];\n      const bias = !simplified && inputs[2];\n\n      const outputShape = xShape;\n      const axis = ShapeUtil.normalizeAxis(attributes.axis, xShape.length);\n      const normCount = ShapeUtil.sizeToDimension(xShape, axis);\n      const normSize = ShapeUtil.sizeFromDimension(xShape, axis);\n\n      const scaleSize = ShapeUtil.size(scale.dims);\n      const biasSize = bias ? ShapeUtil.size(bias.dims) : 0;\n      if (scaleSize !== normSize || (bias && biasSize !== normSize)) {\n        throw new Error(`Size of X.shape()[axis:] == ${normSize}.\n       Size of scale and bias (if provided) must match this.\n       Got scale size of ${scaleSize} and bias size of ${biasSize}`);\n      }\n\n      const meanInvStdDevDim: number[] = [];\n      for (let i = 0; i < xShape.length; ++i) {\n        if (i < axis) {\n          meanInvStdDevDim.push(xShape[i]);\n        } else {\n          meanInvStdDevDim.push(1);\n        }\n      }\n      const components = getMaxComponents(normSize);\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: normCount}, {type: DataType.float, data: normSize},\n        {type: DataType.uint32, data: Math.floor(normSize / components)},\n        {type: DataType.float, data: attributes.epsilon}\n      ];\n      if (bias) {\n        inputDependencies.push('type');\n      }\n      const hasMeanDataOutput = outputCount > 1;\n      const hasInvStdOutput = outputCount > 2;\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n        const variables = [\n          inputVariable('x', inputs[0].dataType, inputs[0].dims, components),\n          inputVariable('scale', scale.dataType, scale.dims, components),\n        ];\n        if (bias) {\n          variables.push(inputVariable('bias', bias.dataType, bias.dims, components));\n        }\n        variables.push(outputVariable('output', inputs[0].dataType, outputShape, components));\n        if (hasMeanDataOutput) {\n          variables.push(outputVariable('mean_data_output', DataType.float, meanInvStdDevDim));\n        }\n        if (hasInvStdOutput) {\n          variables.push(outputVariable('inv_std_output', DataType.float, meanInvStdDevDim));\n        }\n\n        const uniforms: UniformsArrayType = [\n          {name: 'norm_count', type: 'u32'}, {name: 'norm_size', type: 'f32'},\n          {name: 'norm_size_vectorized', type: 'u32'}, {name: 'epsilon', type: 'f32'}\n        ];\n        return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.norm_count')}\n    let offset = global_idx * uniforms.norm_size_vectorized;\n    var mean_vector = ${fillVector('f32', components)};\n    var mean_square_vector = ${fillVector('f32', components)};\n\n    for (var h: u32 = 0u; h < uniforms.norm_size_vectorized; h++) {\n      let value = ${castToF32(dataType, components, 'x[h + offset]')};\n      mean_vector += value;\n      mean_square_vector += value * value;\n    }\n    let mean = ${sumVector('mean_vector', components)} / uniforms.norm_size;\n    let inv_std_dev = inverseSqrt(${sumVector('mean_square_vector', components)} / uniforms.norm_size ${\n            simplified ? '' : '- mean * mean'} + uniforms.epsilon);\n\n    for (var j: u32 = 0; j < uniforms.norm_size_vectorized; j++) {\n      let f32input = ${castToF32(dataType, components, 'x[j + offset]')};\n      let f32scale = ${castToF32(dataType, components, 'scale[j]')};\n      output[j + offset] = ${variables[0].type.value}((f32input ${simplified ? '' : '- mean'}) * inv_std_dev * f32scale\n        ${bias ? `+ ${castToF32(dataType, components, 'bias[j]')}` : ''}\n      );\n    }\n\n    ${hasMeanDataOutput ? 'mean_data_output[global_idx] = mean' : ''};\n    ${hasInvStdOutput ? 'inv_std_output[global_idx] = inv_std_dev' : ''};\n  }`;\n      };\n      const outputs = [{dims: outputShape, dataType: inputs[0].dataType}];\n      if (hasMeanDataOutput) {\n        outputs.push({dims: meanInvStdDevDim, dataType: DataType.float});\n      }\n      if (hasInvStdOutput) {\n        outputs.push({dims: meanInvStdDevDim, dataType: DataType.float});\n      }\n\n      return {\n        name: 'LayerNormalization',\n        shaderCache: {hint: `${components};${outputCount};${simplified}`, inputDependencies},\n        getRunData: () =>\n            ({outputs, dispatchGroup: {x: Math.ceil(normCount / 64 /* workgroup size */)}, programUniforms}),\n        getShaderSource,\n      };\n    };\n\nexport const layerNorm = (context: ComputeContext, attributes: LayerNormAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createLayerNormProgramInfo(context.inputs, attributes, context.outputCount));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType, getTensorElementSize} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, getMaxComponents, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from './common';\n\n//  TODO support quantization bits not equal to 4\nexport interface MatMulNBitsAttributes extends AttributeWithCacheKey {\n  k: number;\n  n: number;\n  accuracyLevel: number;\n  bits: number;\n  blockSize: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: MatMulNBitsAttributes): void => {\n  if (inputs.length < 3 || inputs.length > 4) {\n    throw new Error('MatMulNBits requires 3 or 4 inputs');\n  }\n  const a = inputs[0];\n  const aRank = a.dims.length;\n  if (a.dims[aRank - 1] !== attributes.k) {\n    throw new Error('The last dim of input shape does not match the k value');\n  }\n  const nBlocksPerCol = Math.floor((attributes.k + attributes.blockSize - 1) / attributes.blockSize);\n  const blobSize = attributes.blockSize / 8 * attributes.bits;\n  const b = inputs[1];\n  if (!ShapeUtil.areEqual(b.dims, [attributes.n, nBlocksPerCol, blobSize])) {\n    throw new Error('The second inputs must be 3D tensor with shape N X nBlocksPerCol X blobSize');\n  }\n  const scales = inputs[2];\n  const scalesShape = scales.dims;\n  if (ShapeUtil.size(scalesShape) !== attributes.n * nBlocksPerCol) {\n    throw new Error('scales input size error.');\n  }\n  if (inputs.length === 4) {\n    const zeroPoints = inputs[3];\n    const zeroPointsShape = zeroPoints.dims;\n    const expectedZeroPointsSize =\n        attributes.bits > 4 ? (attributes.n * nBlocksPerCol) : attributes.n * Math.floor((nBlocksPerCol + 1) / 2);\n    if (ShapeUtil.size(zeroPointsShape) !== expectedZeroPointsSize) {\n      throw new Error('zeroPoints input size error.');\n    }\n  }\n};\n\nexport const createMatMulNBitsProgramInfo =\n    (inputs: readonly TensorView[], attributes: MatMulNBitsAttributes,\n     maxComputeWorkgroupSizes: [number, number, number], maxComputeWorkgroupStorageSize: number): ProgramInfo => {\n      const inputShape = inputs[0].dims;\n      const aRank = inputShape.length;\n      const nBlocksPerCol = Math.floor((attributes.k + attributes.blockSize - 1) / attributes.blockSize);\n      const dimAOuter = inputShape[aRank - 2];\n      const dimInner = attributes.k;\n      const dimBOuter = attributes.n;\n      const batchDims = inputShape.slice(0, aRank - 2);\n      const batchSize = ShapeUtil.size(batchDims);\n      const blobSize = attributes.blockSize / 8 * attributes.bits;\n      const blobSizeInWords = blobSize / 4;\n      const dataType = inputs[0].dataType;\n      const outputNumber = getMaxComponents(dimAOuter);\n      const aComponents = getMaxComponents(attributes.k);\n      const bComponents = getMaxComponents(blobSizeInWords);\n      const elementSize = getTensorElementSize(dataType)!;\n      const workgroupOutputSize = dimAOuter * nBlocksPerCol * elementSize;\n      const maxNumberOfComponents = Math.floor(maxComputeWorkgroupStorageSize / workgroupOutputSize);\n      const useBlockwiseMatMulNBits = nBlocksPerCol <= maxComputeWorkgroupSizes[0] && maxNumberOfComponents > 0;\n      const components = (!useBlockwiseMatMulNBits || maxNumberOfComponents >= 4) ? getMaxComponents(dimBOuter) :\n          ((maxNumberOfComponents >= 2) && getMaxComponents(dimBOuter) >= 2)      ? 2 :\n                                                                                    1;\n      const outputShape = batchDims.concat([dimAOuter, dimBOuter]);\n      const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;\n\n      const programUniforms: ProgramUniform[] = useBlockwiseMatMulNBits ?\n          [] :\n          [{type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: attributes.blockSize}];\n      const inputShapeTemp = [batchSize, dimAOuter, dimInner / aComponents];\n      const bShape = ShapeUtil.convertShape(inputs[1].dims).slice();\n      bShape.splice(-1, 1, blobSizeInWords / bComponents);\n      programUniforms.push(...createTensorShapeVariables(inputShapeTemp));\n      programUniforms.push(...createTensorShapeVariables(bShape));\n      programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n      if (inputs.length === 4) {\n        programUniforms.push(...createTensorShapeVariables(ShapeUtil.convertShape(inputs[3].dims)));\n      }\n      const outputShapeTemp = [batchSize, dimAOuter, dimBOuter / components];\n      programUniforms.push(...createTensorShapeVariables(outputShapeTemp));\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const inputRank = inputShapeTemp.length;\n        const a = inputVariable('a', inputs[0].dataType, inputRank, aComponents);\n        const b = inputVariable('b', DataType.uint32, bShape.length, bComponents);\n        const scales = inputVariable('scales', inputs[2].dataType, inputs[2].dims.length);\n        const inputVariables = [a, b, scales];\n        const zeroPoints =\n            inputs.length === 4 ? inputVariable('zero_points', DataType.uint32, inputs[3].dims.length) : undefined;\n        if (zeroPoints) {\n          inputVariables.push(zeroPoints);\n        }\n        const outputRank = outputShapeTemp.length;\n        const output = outputVariable('output', inputs[0].dataType, outputRank, components);\n        const uniforms: UniformsArrayType = [{name: 'output_size', type: 'u32'}, {name: 'block_size', type: 'u32'}];\n        const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n\n        const qDqDataType = (() => {\n          switch (aComponents) {\n            case 1:\n              return `array<${dataType}, 8>`;\n            case 2:\n              return `mat4x2<${dataType}>`;\n            case 4:\n              return `mat2x4<${dataType}>`;\n            default:\n              throw new Error(`${aComponents}-component is not supported.`);\n          }\n        })();\n\n        const processOneBlock = `\n        for (var word: u32 = 0; word < ${blobSizeInWords}; word += ${bComponents}) {\n          ${b.indicesSet('b_indices', '2', 'word')};\n          let b_data = ${b.getByIndices('b_indices')};\n          for (var i: u32 = 0; i < ${bComponents}; i++) {\n            let b_value: u32 = ${bComponents === 1 ? 'b_data' : 'b_data[word + i]'};\n            let b_mask: u32 = 0x0F0F0F0Fu;\n            let b_value_lower: vec4<u32> = unpack4xU8(b_value & b_mask);\n            let b_value_upper: vec4<u32> = unpack4xU8((b_value >> 4) & b_mask);\n            let b_quantized_values = ${qDqDataType}(${\n            Array.from({length: 4}, (_, i) => `${dataType}(b_value_lower[${i}]), ${dataType}(b_value_upper[${i}])`)\n                .join(', ')});\n            let b_dequantized_values = ${(() => {\n          if (aComponents === 1) {\n            return `${qDqDataType}(${\n                Array.from({length: 8}, (_, i) => `(b_quantized_values[${i}] - zero_point) * scale`).join(', ')});`;\n          } else {\n            return `(b_quantized_values - ${qDqDataType}(${Array(8).fill('zero_point').join(',')})) * scale;`;\n          }\n        })()};\n            // Number of B elements per 32-bit word is 32/bits = 32/4 = 8\n            for (var m: u32 = 0; m < ${useBlockwiseMatMulNBits ? dimAOuter : outputNumber}u; m++) {\n              ${a.indicesSet('a_indices', inputRank - 2, useBlockwiseMatMulNBits ? 'm' : `row * ${outputNumber} + m`)};\n              ${a.indicesSet('a_indices', inputRank - 1, 'word_offset')};\n              var input_offset = ${a.indicesToOffset('a_indices')};\n              var a_data: ${qDqDataType};\n              for (var j: u32 = 0; j < ${8 / aComponents}; j++) {\n                a_data[j] = ${a.getByOffset('input_offset')};\n                input_offset++;\n              }\n              ${useBlockwiseMatMulNBits ? 'workgroup_shared[workgroup_shared_offset + m]' : 'output_values[m]'}${\n            components > 1 ? '[c]' : ''} += ${\n            Array\n                .from(\n                    {length: 8 / aComponents},\n                    (_, i) => `${\n                        aComponents === 1 ? `a_data[${i}] * b_dequantized_values[${i}]` :\n                                            `dot(a_data[${i}], b_dequantized_values[${i}])`}`)\n                .join(' + ')};\n            }\n            word_offset += ${8 / aComponents};\n          }\n        }`;\n        const updateZeroPointIndex = zeroPoints ? `\n          zero_point_offset += 4;\n          if (zero_point_offset == 32) {\n            zero_point_offset = 0;\n            zero_point_index++;\n            zero_point_word = ${zeroPoints.getByOffset('zero_point_index')};\n          }` :\n                                                  '';\n\n        return useBlockwiseMatMulNBits ? `\n        var<workgroup> workgroup_shared: array<${output.type.value}, ${dimAOuter * nBlocksPerCol}>;\n        ${shaderHelper.declareVariables(...inputVariables, output)}\n        ${shaderHelper.mainStart([\n          nBlocksPerCol, 1, 1\n        ])}\n          var a_indices: ${a.type.indices};\n          var block = local_id.x;\n          var col = workgroup_id.y;\n          var batch = workgroup_id.z;\n          ${a.indicesSet('a_indices', '0', 'batch')};\n          // Two zero points are packed into one byte when uniforms.bits is 4.\n          for (var c: u32 = 0; c < ${components}; c++) {\n            let col_times_components_plus_c = col * ${components} + c;\n              ${\n                                             zeroPoints ? `\n            var zero_point_bytes_per_col: u32 = (${nBlocksPerCol} + 1) / 2;\n            var zero_point_byte_count: u32 = col_times_components_plus_c * zero_point_bytes_per_col + (block >> 0x1u);\n            var zero_point_word_index: u32 = zero_point_byte_count >> 0x2u;\n            var zero_point_byte_offset: u32 = zero_point_byte_count & 0x3u;\n            var zero_point_nibble_offset: u32 = block & 0x1u;\n            var zero_point_bits_offset: u32 = (zero_point_byte_offset << 3) + (zero_point_nibble_offset << 2);\n            var zero_point_word: u32 = ${zeroPoints.getByOffset('zero_point_word_index')} >> zero_point_bits_offset;` :\n                                                          ''}\n            var b_indices: ${b.type.indices};\n            ${b.indicesSet('b_indices', '0', 'col_times_components_plus_c')};\n            // The scale and zero points are computed per block.\n            var scales_index = col_times_components_plus_c * ${nBlocksPerCol} + block;\n            let scale = ${scales.getByOffset('scales_index')};\n            // The default zero point is 8 for unsigned 4-bit quantization.\n            let zero_point = ${dataType}(${zeroPoints ? '(zero_point_word) & 0xFu' : 8.0});\n            ${b.indicesSet('b_indices', '1', 'block')};\n            var word_offset: u32 = block * ${attributes.blockSize / aComponents};\n            var workgroup_shared_offset: u32 = block * ${dimAOuter};\n            ${processOneBlock}\n          }\n          workgroupBarrier();\n          if (local_id.x == 0u) {\n            var output_indices: ${output.type.indices};\n            ${output.indicesSet('output_indices', '0', 'batch')};\n            ${output.indicesSet('output_indices', outputRank - 1, 'col')};\n            ${output.indicesSet('output_indices', outputRank - 2, '0')};\n            var output_offset = ${output.indicesToOffset('output_indices')};\n            for (var m: u32 = 0u; m < ${dimAOuter}u; m++) {\n              var output_value: ${output.type.value} = ${output.type.value}(0);\n              var workgroup_shared_offset: u32 = m;\n              for (var b: u32 = 0u; b < ${nBlocksPerCol}u; b++) {\n                output_value += workgroup_shared[workgroup_shared_offset];\n                workgroup_shared_offset += ${dimAOuter};\n              }\n              ${output.setByOffset('output_offset', 'output_value')};\n              output_offset += ${dimBOuter / components};\n            }\n          }\n        }` :\n                                         `\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n        ${shaderHelper.mainStart()}\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n          var output_values: array<${output.type.value}, ${outputNumber}>;\n          var output_indices = ${output.offsetToIndices('global_idx')};\n          var col = ${output.indicesGet('output_indices', outputRank - 1)};\n          var row = ${output.indicesGet('output_indices', outputRank - 2)};\n          var a_indices: ${a.type.indices} = output_indices;\n          // Two zero points are packed into one byte because uniforms.bits <= 4.\n          // zero_point_offset is either 0 or 4. It is bit offset within one byte.\n          // TODO support zero_point_offset for bits > 4\n          ${\n                                             zeroPoints ? `\n          var zero_point_abs_offset = col * ${components} * ((${nBlocksPerCol} + 1) / 2);\n          var zero_point_index: u32 = zero_point_abs_offset / 4;\n          var zero_point_word: u32 = ${zeroPoints.getByOffset('zero_point_index')};\n          var zero_point_offset: u32 = (zero_point_abs_offset % 4) * 8;` :\n                                                          ''}\n          var scale_index = col * ${nBlocksPerCol * components};\n          var b_indices: ${b.type.indices};\n          for (var c: u32 = 0; c < ${components}; c++) {\n            ${b.indicesSet('b_indices', '0', `col * ${components} + c`)};\n            var block_offset: u32 = 0;\n            for (var block: u32 = 0; block < ${nBlocksPerCol}; block++) {\n              // The scale and zero points are computed per block.\n              let scale = ${scales.getByOffset('scale_index')};\n              // The default zero point is 8 for unsigned 4-bit quantization.\n              let zero_point = ${dataType}(${zeroPoints ? 'extractBits(zero_point_word, zero_point_offset, 4)' : 8.0});\n              ${b.indicesSet('b_indices', '1', 'block')};\n              var word_offset: u32 = block_offset;\n              ${processOneBlock}\n              scale_index++;\n              ${updateZeroPointIndex}\n              block_offset += uniforms.block_size / ${aComponents};\n            }\n            // Drop the trailing 4 bits if the zero_poit_offset is not a byte boundary to align with the next byte.\n            ${\n                                             zeroPoints ? `if (zero_point_offset % 8 > 0) {\n                ${updateZeroPointIndex}\n              }` :\n                                                          ''}\n            }\n            for (var k: u32 = 0u; k < ${outputNumber}u; k++) {\n              ${output.indicesSet('output_indices', outputRank - 2, `${outputNumber} * row + k`)};\n              ${output.setByIndices('output_indices', 'output_values[k]')}\n            }\n        }`;\n      };\n      return {\n        name: useBlockwiseMatMulNBits ? 'BlockwiseMatMulNBits' : 'MatMulNBits',\n        shaderCache: {\n          hint: `${attributes.cacheKey};${dimAOuter};${dataType};${inputs.length}`,\n          inputDependencies: Array(inputs.length).fill('rank')\n        },\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType}],\n          name: useBlockwiseMatMulNBits ? 'BlockwiseMatMulNBits' : 'MatMulNBits',\n          dispatchGroup: useBlockwiseMatMulNBits ? {x: 1, y: Math.ceil(dimBOuter / components), z: batchSize} :\n                                                   {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource\n      };\n    };\n\nexport const matMulNBits = (context: ComputeContext, attributes: MatMulNBitsAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  const maxComputeWorkgroupSizes: [number, number, number] = context.getMaxComputeWorkgroupSizes();\n  const maxComputeWorkgroupStorageSize = context.getMaxComputeWorkgroupStoragesize();\n  context.compute(createMatMulNBitsProgramInfo(\n      context.inputs, attributes, maxComputeWorkgroupSizes, maxComputeWorkgroupStorageSize));\n};\n\nexport const parseMatMulNBitsAttributes = (attributes: Record<string, unknown>): MatMulNBitsAttributes =>\n    createAttributeWithCacheKey(attributes as Omit<MatMulNBitsAttributes, keyof AttributeWithCacheKey>);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, GpuDataType, ProgramUniform} from '../types';\n\nimport {applyAttention, AttentionAttrs, AttentionMaskType, AttentionParameters, AttentionQkvFormat} from './attention';\nimport {inputVariable, outputVariable, ShaderHelper, UniformsArrayType} from './common';\nimport {createTransposeProgramInfo, TransposeAttributes} from './transpose';\n\nconst getInput = (inputs: readonly TensorView[], i: number) =>\n    (inputs.length > i) && (inputs[i].dims.length > 0) && (ShapeUtil.size(inputs[i].dims)) > 0 ? inputs[i] : undefined;\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: AttentionAttrs): AttentionParameters => {\n  const query = inputs[0];\n  const key = getInput(inputs, 1);\n  const value = getInput(inputs, 2);\n  const bias = getInput(inputs, 3);\n  const keyPaddingMask = getInput(inputs, 4);\n  const relativePositionBias = getInput(inputs, 5);\n  const pastKey = getInput(inputs, 6);\n  const pastValue = getInput(inputs, 7);\n\n  // Abbreviation and Meanings:\n  //   B:    batch_size\n  //   S:    sequence_length (input sequence length of query)\n  //   P:    past_sequence_length (past sequence length of key or value)\n  //   L:    kv_sequence_length (input sequence length of key or value)\n  //   M:    max_sequence_length\n  //   T:    total_sequence_length = past_sequence_length + kv_sequence_length\n  //   N:    num_heads\n  //   H:    head size for Q and K, aka q_head_size or k_head_size or qk_head_size\n  //   H_v:  v_head_size\n  //   D_i:  input hidden size\n  //   D:    hidden size for Q and K (D = N * H), aka q_hidden_size or k_hidden_size or qk_hidden_size\n  //   D_v:  v_hidden_size = num_heads * v_head_size\n\n  //     key_padding_mask (K/V)     : (B) or (2*B + 1) or (B, L) or None\n  //     relative_position_bias     : (B, 1, S, L)\n  //     past_key                   : (B, N, S*, H)\n  //     past_value                 : (B, N, S*, H)\n  // When no packing for q/k/v:\n  //     query            (Q)       : (B, S, D)\n  //     key              (K)       : (B, L, D) or (B, N, S*, H)\n  //     value            (V)       : (B, L, D_v) or (B, N, S*, H)\n  //     bias             (Q/K/V)   : (D + D + D_v)\n  // When packed kv is used:\n  //     query            (Q)       : (B, S, D)\n  //     key              (K)       : (B, L, N, 2, H)\n  //     value            (V)       : None\n  //     bias             (Q/K/V)   : None\n  // When packed qkv is used:\n  //     query            (Q)       : (B, L, N, 3, H) or (B, S, 3*D)\n  //     key              (K)       : None\n  //     value            (V)       : None\n  //     bias             (Q/K/V)   : None or (D + D + D_v)\n\n  if (query.dims.length !== 3 && query.dims.length !== 5) {\n    throw new Error('Input query is expected to have 3 or 5 dimensions');\n  }\n\n  const dmmhaPacking = false;\n  const batchSize = query.dims[0];\n  const sequenceLength = query.dims[1];\n  const hiddenSize = query.dims.length === 3 ? (dmmhaPacking ? query.dims[2] / 3 : query.dims[2]) :\n                                               attributes.numHeads * query.dims[4];\n  let kvSequenceLength = sequenceLength;\n\n  let pastSequenceLength = 0;\n  let maxSequenceLength = 0;\n  const headSize = Math.floor(hiddenSize / attributes.numHeads);\n  if (pastKey && pastValue) {\n    if (pastKey.dims.length !== 4) {\n      throw new Error('Input \"past_key\" is expected to have 4 dimensions');\n    }\n    if (pastKey.dims[0] !== batchSize || pastKey.dims[1] !== attributes.numHeads || pastKey.dims[3] !== headSize) {\n      throw new Error('Input \"past_key\" shape (batch_size, num_heads, past_sequence_length, head_size)');\n    }\n    if (pastValue.dims[0] !== batchSize || pastValue.dims[1] !== attributes.numHeads ||\n        pastValue.dims[3] !== headSize) {\n      throw new Error('Input \"past_value\" shape (batch_size, num_heads, past_sequence_length, head_size)');\n    }\n    if (pastKey.dims[2] !== pastValue.dims[2]) {\n      throw new Error('Input \"past_key\" and \"past_value\" shall have same dim 2 (past_sequence_length)');\n    }\n    if (pastValue.dims.length !== 4) {\n      throw new Error('Input \"past_value\" is expected to have 4 dimensions');\n    }\n    pastSequenceLength = pastKey.dims[2];\n    maxSequenceLength = pastKey.dims[2];\n  } else if (pastKey || pastValue) {\n    throw new Error('Input \"past_key\" and \"past_value\" shall be both present or both absent');\n  }\n\n  let qkvFormat: AttentionQkvFormat;\n  if (key) {\n    if (query.dims.length !== 3) {\n      throw new Error('Input \"query\" is expected to have 3 dimensions when key is given');\n    }\n    if (key.dims.length < 3 || key.dims.length > 5) {\n      throw new Error('Input \"key\" is expected to have 3, 4, or 5 dimensions');\n    }\n    if (query.dims[0] !== key.dims[0]) {\n      throw new Error('Input \"query\" and \"key\" shall have same dim 0 (batch size)');\n    }\n\n    if (key.dims.length === 3) {\n      if (key.dims[2] !== query.dims[2]) {\n        throw new Error('Input \"query\" and \"key\" shall have same dim 2 (hidden_size)');\n      }\n      qkvFormat = AttentionQkvFormat.qkvBSNH;\n      kvSequenceLength = key.dims[1];\n    } else if (key.dims.length === 5) {\n      if (key.dims[2] !== attributes.numHeads || key.dims[3] !== 2 || key.dims[4] !== headSize) {\n        throw new Error('Expect \"key\" shape (batch_size, kv_sequence_length, num_heads, 2, head_size) for packed kv');\n      }\n      if (value) {\n        throw new Error('Expect \"value\" be none when \"key\" has packed kv format.');\n      }\n      qkvFormat = AttentionQkvFormat.qKvBSNHxBSN2H;\n      kvSequenceLength = key.dims[1];\n    } else {  // key_dims.size() == 4 (cross-attention with past_key)\n      if (key.dims[1] !== attributes.numHeads || key.dims[3] !== headSize) {\n        throw new Error('Expect \"key\" shape (batch_size, num_heads, kv_sequence_length, head_size) for past_key');\n      }\n\n      qkvFormat = AttentionQkvFormat.unknown;\n      kvSequenceLength = key.dims[2];\n    }\n  } else {  // packed QKV\n    if (query.dims.length !== 3 && query.dims.length !== 5) {\n      throw new Error('Input \"query\" is expected to have 3 or 5 dimensions when key is empty');\n    }\n    if (query.dims.length === 5 && (query.dims[2] !== attributes.numHeads || query.dims[3] !== 3)) {\n      throw new Error('Expect \"query\" shape (batch_size, kv_sequence_length, num_heads, 3, head_size) for packed kv');\n    }\n\n    qkvFormat = AttentionQkvFormat.qkvBSN3H;\n  }\n\n  if (bias) {\n    if (bias.dims.length !== 1) {\n      throw new Error('Input \"bias\" is expected to have 1 dimension');\n    }\n\n    if (value) {\n      if (query.dims.length === 5 && query.dims[3] === 2) {\n        throw new Error('bias is not allowed for packed kv.');\n      }\n    }\n  }\n\n  let maskType: AttentionMaskType = AttentionMaskType.none;\n  if (keyPaddingMask) {\n    maskType = AttentionMaskType.maskUnknown;\n    const maskDims = keyPaddingMask.dims;\n    if (maskDims.length === 1) {\n      if (maskDims[0] === batchSize) {\n        maskType = AttentionMaskType.mask1dKeySeqLen;\n      } else if (maskDims[0] === 3 * batchSize + 2) {\n        maskType = AttentionMaskType.mask1DKeySeqLenStart;\n      }\n    } else if (maskDims.length === 2 && maskDims[0] === batchSize && maskDims[1] === kvSequenceLength) {\n      maskType = AttentionMaskType.mask2dKeyPadding;\n    }\n    if (maskType === AttentionMaskType.maskUnknown) {\n      throw new Error('Input \"key_padding_mask\" shape shall be (batch_size) or (batch_size, kv_sequence_length)');\n    }\n    throw new Error('Mask not supported');\n  }\n\n  let passPastInKv = false;\n  let vHiddenSize = hiddenSize;\n  if (value) {\n    if (value.dims.length !== 3 && value.dims.length !== 4) {\n      throw new Error('Input \"value\" is expected to have 3 or 4 dimensions');\n    }\n\n    if (query.dims[0] !== value.dims[0]) {\n      throw new Error('Input \"query\" and \"value\" shall have same dim 0 (batch_size)');\n    }\n\n    if (value.dims.length === 3) {\n      if (kvSequenceLength !== value.dims[1]) {\n        throw new Error('Input \"key\" and \"value\" shall have the same dim 1 (kv_sequence_length)');\n      }\n      vHiddenSize = value.dims[2];\n    } else {\n      if (kvSequenceLength !== value.dims[2]) {\n        throw new Error('Input \"past_key\" and \"past_value\" shall have the same dim 2 (kv_sequence_length)');\n      }\n      vHiddenSize = value.dims[1] * value.dims[3];\n      passPastInKv = true;\n    }\n  }\n\n  const totalSequenceLength = pastSequenceLength + kvSequenceLength;\n  const broadcastResPosBias = false;\n\n  if (keyPaddingMask) {\n    throw new Error('Key padding mask is not supported');\n  }\n\n  if (relativePositionBias) {\n    if (relativePositionBias.dims.length !== 4) {\n      throw new Error('Input \"relative_position_bias\" is expected to have 4 dimensions');\n    }\n    if ((relativePositionBias.dims[0] !== batchSize && relativePositionBias.dims[0] !== 1) ||\n        relativePositionBias.dims[1] !== attributes.numHeads || relativePositionBias.dims[2] !== sequenceLength ||\n        relativePositionBias.dims[3] !== totalSequenceLength) {\n      throw new Error('Input \"relative_position_bias\" shape (batch_size, 1, sequence_length, kv_sequence_length)');\n    }\n  }\n\n  return {\n    batchSize,\n    sequenceLength,\n    pastSequenceLength,\n    kvSequenceLength,\n    totalSequenceLength,\n    maxSequenceLength,\n    inputHiddenSize: 0,\n    hiddenSize,\n    vHiddenSize,\n    headSize,\n    vHeadSize: Math.floor(vHiddenSize / attributes.numHeads),\n    numHeads: attributes.numHeads,\n    isUnidirectional: false,\n    pastPresentShareBuffer: false,\n    maskFilterValue: attributes.maskFilterValue,\n    maskType,\n    scale: attributes.scale,\n    broadcastResPosBias,\n    passPastInKv,\n    qkvFormat,\n  };\n};\n\nexport const parseMultiHeadAttentionAttributes = (attributes: AttentionAttrs): AttentionAttrs =>\n    createAttributeWithCacheKey({...attributes});\n\nconst weightTransposeAttribute: TransposeAttributes = createAttributeWithCacheKey({perm: [0, 2, 1, 3]});\n\nconst addBiasTranspose =\n    (context: ComputeContext, qkv: TensorView, bias: TensorView, batchSize: number, sequenceLength: number,\n     hiddenSize: number, biasOffset: number) => {\n      const outputShape = [batchSize, sequenceLength, hiddenSize];\n      const outputSize = ShapeUtil.size(outputShape);\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: biasOffset},\n        {type: DataType.uint32, data: hiddenSize}\n      ];\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const output = outputVariable('qkv_with_bias', qkv.dataType, outputShape);\n        const qkvInput = inputVariable('qkv', qkv.dataType, outputShape);\n        const biasInput = inputVariable('bias', bias.dataType, outputShape);\n\n        const uniforms: UniformsArrayType = [\n          {name: 'output_size', type: 'u32'}, {name: 'bias_offset', type: 'u32'}, {name: 'hidden_size', type: 'u32'}\n        ];\n        return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(qkvInput, biasInput, output)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n    let bias_offset_idx = (global_idx % uniforms.hidden_size) + uniforms.bias_offset;\n\n    qkv_with_bias[global_idx] = qkv[global_idx] + bias[bias_offset_idx];\n  }`;\n      };\n\n      return context.compute(\n          {\n            name: 'MultiHeadAttentionAddBias',\n            shaderCache: {inputDependencies: ['type', 'type']},\n            getRunData: () => ({\n              outputs: [{dims: outputShape, dataType: qkv.dataType, gpuDataType: GpuDataType.default}],\n              dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n              programUniforms\n            }),\n            getShaderSource,\n          },\n          {inputs: [qkv, bias], outputs: [-1]})[0];\n    };\n\nconst maybeTransposeToBNSHAndAddBias =\n    (context: ComputeContext, batchSize: number, numHeads: number, sequenceLength: number, headSize: number,\n     input: TensorView, bias?: TensorView, biasOffset?: number) => {\n      // const newDims = [];\n\n      let reshapedInput = input;\n      if (!bias) {\n        if (input.dims.length === 3) {\n          reshapedInput = input.reshape([batchSize, sequenceLength, numHeads, headSize]);\n        }\n        return context.compute(\n            createTransposeProgramInfo(reshapedInput, weightTransposeAttribute.perm),\n            {inputs: [reshapedInput], outputs: [-1]})[0];\n      } else {\n        if (sequenceLength === 1) {\n          throw new Error('AddBiasReshape is not implemented. Please export your model with packed QKV or KV');\n        } else {\n          reshapedInput =\n              addBiasTranspose(context, input, bias, batchSize, sequenceLength, numHeads * headSize, biasOffset!);\n          reshapedInput = reshapedInput.reshape([batchSize, sequenceLength, numHeads, headSize]);\n          return context.compute(\n              createTransposeProgramInfo(reshapedInput, weightTransposeAttribute.perm),\n              {inputs: [reshapedInput], outputs: [-1]})[0];\n        }\n      }\n    };\n\nexport const multiHeadAttention = (context: ComputeContext, attributes: AttentionAttrs): void => {\n  const params = validateInputs(context.inputs, attributes);\n  const query = context.inputs[0];\n  const key = getInput(context.inputs, 1);\n  const value = getInput(context.inputs, 2);\n  const bias = getInput(context.inputs, 3);\n  const keyPaddingMask = getInput(context.inputs, 4);\n  const relativePositionBias = getInput(context.inputs, 5);\n  const pastKey = getInput(context.inputs, 6);\n  const pastValue = getInput(context.inputs, 7);\n  if (query.dims.length === 5) {\n    throw new Error('Packed QKV is not implemented');\n  }\n\n  if (key?.dims.length === 5) {\n    throw new Error('Packed KV is not implemented');\n  }\n\n  // applyAttention expects BNSH inputs\n  const kvBNSH = key && value && key.dims.length === 4 && value.dims.length === 4;\n\n  const Q = maybeTransposeToBNSHAndAddBias(\n      context, params.batchSize, params.numHeads, params.sequenceLength, params.headSize, query, bias, 0);\n\n  if (kvBNSH) {\n    return applyAttention(\n        context, Q, key, value, keyPaddingMask, undefined, pastKey, pastValue, relativePositionBias, params,\n        attributes);\n  }\n  if (!key || !value) {\n    throw new Error('key and value must be provided');\n  }\n  const K = maybeTransposeToBNSHAndAddBias(\n      context, params.batchSize, params.numHeads, params.kvSequenceLength, params.headSize, key, bias,\n      params.hiddenSize);\n\n  const V = maybeTransposeToBNSHAndAddBias(\n      context, params.batchSize, params.numHeads, params.kvSequenceLength, params.vHeadSize, value, bias,\n      2 * params.hiddenSize);\n\n  applyAttention(\n      context, Q, K, V, keyPaddingMask, undefined, pastKey, pastValue, relativePositionBias, params, attributes);\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, IndicesHelper, inputVariable, outputVariable, ShaderHelper, UniformDataElementType, UniformsArrayType} from './common';\n\ninterface PadAttributes {\n  // 0-constant, 1-reflect, 2-edge, 3-wrap\n  readonly mode: number;\n  readonly value: number;\n  readonly pads: number[];\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length < 1) {\n    throw new Error('Too few inputs');\n  }\n  if (inputs[0].dataType !== DataType.float && inputs[0].dataType !== DataType.float16) {\n    throw new Error('Input type must be float or float16.');\n  }\n\n  if (inputs.length >= 2) {\n    let validPads = inputs[0].dims.length * 2 === inputs[1].dims[0];\n    if (inputs.length === 4) {\n      validPads = inputs[3].dims[0] * 2 === inputs[1].dims[0];\n    }\n    if (!validPads) {\n      throw new Error('The pads should be a 1D tensor of shape [2 * input_rank] or [2 * num_axes].');\n    }\n  }\n};\n\nconst getPadConstant = (output: IndicesHelper, inputRank: number, padsLength: number): string => {\n  let block = '';\n  for (let i = inputRank - 1; i >= 0; --i) {\n    block += `\n            k = i32(${output.indicesGet('indices', i)}) - ${getElementAt('uniforms.pads', i, padsLength)};\n            if (k < 0) {\n              break;\n            }\n            if (k >= i32(${getElementAt('uniforms.x_shape', i, inputRank)})) {\n              break;\n            }\n            offset += k * i32(${getElementAt('uniforms.x_strides', i, inputRank)});\n        `;\n  }\n\n  return `\n          value = ${output.type.value}(uniforms.constant_value);\n          for (var i = 0; i < 1; i++) {\n            var offset = 0;\n            var k = 0;\n            ${block}\n            value = x[offset];\n          }\n      `;\n};\n\nconst getPadReflect = (output: IndicesHelper, inputRank: number, padsLength: number): string => {\n  let block = '';\n  for (let i = inputRank - 1; i >= 0; --i) {\n    block += `\n                k = i32(${output.indicesGet('indices', i)}) - ${getElementAt('uniforms.pads', i, padsLength)};\n                if (k < 0) {\n                  k = -k;\n                }\n                {\n                  let _2n_1 = 2 * (i32(${getElementAt('uniforms.x_shape', i, inputRank)}) - 1);\n                  k = k % _2n_1;\n                  if(k >= i32(${getElementAt('uniforms.x_shape', i, inputRank)})) {\n                    k = _2n_1 - k;\n                  }\n                }\n                offset += k * i32(${getElementAt('uniforms.x_strides', i, inputRank)});\n            `;\n  }\n\n  return `\n              var offset = 0;\n              var k = 0;\n              ${block}\n              value = x[offset];\n          `;\n};\n\nconst getPadEdge = (output: IndicesHelper, inputRank: number, padsLength: number): string => {\n  let block = '';\n  for (let i = inputRank - 1; i >= 0; --i) {\n    block += `\n                k = i32(${output.indicesGet('indices', i)}) - ${getElementAt('uniforms.pads', i, padsLength)};\n                if (k < 0) {\n                  k = 0;\n                }\n                if (k >= i32(${getElementAt('uniforms.x_shape', i, inputRank)})) {\n                  k = i32(${getElementAt('uniforms.x_shape', i, inputRank)}) - 1;\n                }\n                offset += k * i32(${getElementAt('uniforms.x_strides', i, inputRank)});\n            `;\n  }\n\n  return `\n              var offset = 0;\n              var k = 0;\n              ${block}\n              value = x[offset];\n          `;\n};\n\nconst getPadWrap = (output: IndicesHelper, inputRank: number, padsLength: number): string => {\n  let block = '';\n  for (let i = inputRank - 1; i >= 0; --i) {\n    block += `\n                k = i32(${output.indicesGet('indices', i)}) - ${getElementAt('uniforms.pads', i, padsLength)};\n                if (k < 0)  {\n                  k += i32(${getElementAt('uniforms.x_shape', i, inputRank)}]);\n                }\n                if (k >= i32(${getElementAt('uniforms.x_shape', i, inputRank)})) {\n                  k -= i32(${getElementAt('uniforms.x_shape', i, inputRank)});\n                }\n                offset += k * i32(${getElementAt('uniforms.x_strides', i, inputRank)});\n            `;\n  }\n\n  return `\n              var offset = 0;\n              var k = 0;\n              ${block}\n              value = x[offset];\n          `;\n};\n\nconst getPadSnippet = (output: IndicesHelper, inputRank: number, attributes: PadAttributes): string => {\n  switch (attributes.mode) {\n    case 0:\n      return getPadConstant(output, inputRank, attributes.pads.length);\n    case 1:\n      return getPadReflect(output, inputRank, attributes.pads.length);\n    case 2:\n      return getPadEdge(output, inputRank, attributes.pads.length);\n    case 3:\n      return getPadWrap(output, inputRank, attributes.pads.length);\n    default:\n      throw new Error('Invalid mode');\n  }\n};\n\nconst createPadProgramInfo = (inputs: readonly TensorView[], attributes: PadAttributes): ProgramInfo => {\n  const outputShape = ShapeUtil.padShape(inputs[0].dims.slice(), attributes.pads);\n  const inputDims = inputs[0].dims;\n  const outputSize = ShapeUtil.size(outputShape);\n  const programUniforms: ProgramUniform[] =\n      [{type: DataType.uint32, data: outputSize}, {type: DataType.int32, data: attributes.pads}];\n  if (attributes.mode === 0) {\n    programUniforms.push({type: inputs[0].dataType, data: attributes.value});\n  }\n\n  programUniforms.push(...createTensorShapeVariables(inputs[0].dims, outputShape));\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank'];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n    const input = inputVariable('x', inputs[0].dataType, inputDims.length);\n    const dataType = input.type.value;\n    const padSnippet = getPadSnippet(output, inputDims.length, attributes);\n    const uniforms: UniformsArrayType =\n        [{name: 'output_size', type: 'u32'}, {name: 'pads', type: 'i32', length: attributes.pads.length}];\n    if (attributes.mode === 0) {\n      uniforms.push({name: 'constant_value', type: dataType as UniformDataElementType});\n    }\n\n    return `\n            ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)}\n            ${shaderHelper.mainStart()}\n            ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n            let indices = ${output.offsetToIndices('global_idx')};\n\n            var value = ${dataType}(0);\n            ${padSnippet}\n            output[global_idx] = value;\n        }`;\n  };\n\n  return {\n    name: 'Pad',\n    shaderCache: {hint: `${attributes.mode}`, inputDependencies},\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(ShapeUtil.size(outputShape) / 64 /* workgroup size */)},\n      programUniforms\n    }),\n    getShaderSource,\n  };\n};\n\nconst createPadAttributesFromInputs = (inputs: readonly TensorView[], attributes: PadAttributes): PadAttributes => {\n  if (inputs.length > 1) {\n    const bigInt64Pads = inputs[1].getBigInt64Array();\n    const value = (inputs.length >= 3 && inputs[2].data) ? inputs[2].getFloat32Array()[0] : 0.0;\n\n    const inputRank = inputs[0].dims.length;\n    const updatePads = new Int32Array(2 * inputRank).fill(0);\n    if (inputs.length >= 4) {\n      const axes = inputs[3].getBigInt64Array();\n      for (let i = 0; i < axes.length; i++) {\n        updatePads[Number(axes[i])] = Number(bigInt64Pads[i]);\n        updatePads[Number(axes[i]) + inputRank] = Number(bigInt64Pads[i + axes.length]);\n      }\n    } else {\n      bigInt64Pads.forEach((v, i) => updatePads[Number(i)] = (Number(v)));\n    }\n\n    const pads: number[] = [];\n    updatePads.forEach(v => pads.push(v));\n\n    return {mode: attributes.mode, value, pads};\n  } else {\n    return attributes;\n  }\n};\n\nexport const pad = (context: ComputeContext, attributes: PadAttributes): void => {\n  validateInputs(context.inputs);\n  const updatedAttributes = createPadAttributesFromInputs(context.inputs, attributes);\n  context.compute(createPadProgramInfo(context.inputs, updatedAttributes), {inputs: [0]});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {env} from 'onnxruntime-common';\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {PoolConvUtil, ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, IndicesHelper, inputVariable, outputVariable, ShaderHelper, UniformsArrayType} from './common';\n\n// TODO: support:\n// - ceil_mode                 \"test_maxpool_2d_ceil\"\n// - storage_order             \"test_maxpool_with_argmax_2d_precomputed_strides\"\n// - [MaxPool] dilations       \"test_maxpool_2d_dilations\"\n// - [MaxPool] output[1]       \"test_maxpool_with_argmax_2d_precomputed_pads\"\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (env.webgpu.validateInputContent && (!inputs || inputs.length !== 1)) {\n    throw new Error('Pool ops requires 1 input.');\n  }\n};\n\nconst getAdjustedPoolAttributesAndOutputShape = <AttributeType extends AveragePoolAttributes|MaxPoolAttributes>(\n    input: TensorView, attributes: AttributeType, isGlobalOperator: boolean): [AttributeType, number[]] => {\n  const isChannelsLast = attributes.format === 'NHWC';\n  const inputShapeAsChannelFirst = input.dims.slice();\n  if (isChannelsLast) {\n    inputShapeAsChannelFirst.splice(1, 0, inputShapeAsChannelFirst.pop()!);  // Move channel to the second position.\n  }\n  const hasDilations = Object.hasOwnProperty.call(attributes, 'dilations');\n  const kernelShape = attributes.kernelShape.slice();\n  const strides = attributes.strides.slice();\n  const dilations: number[] = hasDilations ? (attributes as MaxPoolAttributes).dilations.slice() : [];\n  const pads = attributes.pads.slice();\n  PoolConvUtil.adjustPoolAttributes(isGlobalOperator, inputShapeAsChannelFirst, kernelShape, strides, dilations, pads);\n\n  const outputShapeAsChannelFirst = PoolConvUtil.computePoolOutputShape(\n      isGlobalOperator, inputShapeAsChannelFirst, strides, dilations, kernelShape, pads, attributes.autoPad);\n\n  const newAttributes = Object.assign({}, attributes);\n  if (hasDilations) {\n    Object.assign(newAttributes, {kernelShape, strides, pads, dilations, cacheKey: attributes.cacheKey});\n  } else {\n    Object.assign(newAttributes, {kernelShape, strides, pads, cacheKey: attributes.cacheKey});\n  }\n  const outputShapeAsChannelLast = outputShapeAsChannelFirst.slice();\n  outputShapeAsChannelLast.push(outputShapeAsChannelLast.splice(1, 1)[0]);\n  return [newAttributes, isChannelsLast ? outputShapeAsChannelLast : outputShapeAsChannelFirst];\n};\n\nconst getUniformAndPadInfo = <AttributeType extends AveragePoolAttributes|MaxPoolAttributes>(\n    outputShape: readonly number[],\n    attributes: AttributeType): [ProgramUniform[], UniformsArrayType, boolean, boolean, boolean] => {\n  const isChannelsLast = attributes.format === 'NHWC';\n  const outputSize = ShapeUtil.size(outputShape);\n  const kernelSize = ShapeUtil.size(attributes.kernelShape);\n  const programUniforms: ProgramUniform[] =\n      [{type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: kernelSize}];\n  const uniforms: UniformsArrayType = [{name: 'outputSize', type: 'u32'}, {name: 'kernelSize', type: 'u32'}];\n  if (attributes.kernelShape.length <= 2) {\n    const kw = attributes.kernelShape[attributes.kernelShape.length - 1];\n    const sw = attributes.strides[attributes.strides.length - 1];\n    const pwStart = attributes.pads[attributes.pads.length / 2 - 1];\n    const pwEnd = attributes.pads[attributes.pads.length - 1];\n    const pwStartEndNotZero = !!(pwStart + pwEnd);\n    programUniforms.push(\n        {type: DataType.uint32, data: kw},\n        {type: DataType.uint32, data: sw},\n        {type: DataType.uint32, data: pwStart},\n        {type: DataType.uint32, data: pwEnd},\n    );\n    uniforms.push(\n        {name: 'kw', type: 'u32'}, {name: 'sw', type: 'u32'}, {name: 'pwStart', type: 'u32'},\n        {name: 'pwEnd', type: 'u32'});\n\n    let phStartEndNotZero = false;\n    if (attributes.kernelShape.length === 2) {\n      const kh = attributes.kernelShape[attributes.kernelShape.length - 2];\n      const sh = attributes.strides[attributes.strides.length - 2];\n      const phStart = attributes.pads[attributes.pads.length / 2 - 2];\n      const phEnd = attributes.pads[attributes.pads.length - 2];\n      phStartEndNotZero = !!(phStart + phEnd);\n      programUniforms.push(\n          {type: DataType.uint32, data: kh}, {type: DataType.uint32, data: sh}, {type: DataType.uint32, data: phStart},\n          {type: DataType.uint32, data: phEnd});\n\n      uniforms.push(\n          {name: 'kh', type: 'u32'}, {name: 'sh', type: 'u32'}, {name: 'phStart', type: 'u32'},\n          {name: 'phEnd', type: 'u32'});\n    }\n    return [programUniforms, uniforms, true, pwStartEndNotZero, phStartEndNotZero];\n  } else {\n    if (isChannelsLast) {\n      throw new Error('Pooling with kernelShape.length > 2 is not supported for NHWC format.');\n    }\n    const kernelStrides = ShapeUtil.computeStrides(attributes.kernelShape);\n    programUniforms.push(\n        {type: DataType.uint32, data: kernelStrides}, {type: DataType.uint32, data: attributes.pads},\n        {type: DataType.uint32, data: attributes.strides});\n    uniforms.push(\n        {name: 'kernelStrides', type: 'u32', length: kernelStrides.length},\n        {name: 'pads', type: 'u32', length: attributes.pads.length},\n        {name: 'strides', type: 'u32', length: attributes.strides.length});\n\n    const hasPads = attributes.pads.reduce((sum, cur) => sum + cur);\n    return [programUniforms, uniforms, !!hasPads, false, false];\n  }\n};\n\nconst generatePoolingCode = <AttributeType extends AveragePoolAttributes|MaxPoolAttributes>(\n    shaderHelper: ShaderHelper, x: IndicesHelper, rank: number, outputShapeRank: number, attributes: AttributeType,\n    op1: string, op2: string, start: number, uniforms: UniformsArrayType, hasPads: boolean, pwStartEndNotZero: boolean,\n    phStartEndNotZero: boolean): string => {\n  const isChannelsLast = attributes.format === 'NHWC';\n  const dataType = x.type.value;\n  const output = outputVariable('output', x.type.tensor, outputShapeRank);\n\n  if (attributes.kernelShape.length <= 2) {\n    let codeW = '';\n    let codeH = '';\n    let codeHEnd = '';\n    const dimIdxW = rank - (isChannelsLast ? 2 : 1);\n    if (pwStartEndNotZero) {\n      codeW = `\n                for (var i: u32 = 0u; i < uniforms.kw; i++) {\n                  xIndices[${dimIdxW}] = indices[${dimIdxW}] * uniforms.sw - uniforms.pwStart + i;\n                  if (xIndices[${dimIdxW}] < 0 || xIndices[${dimIdxW}]\n                      >= uniforms.x_shape[${dimIdxW}]) {\n                    pad++;\n                    continue;\n                  }\n                  let x_val = x[${x.indicesToOffset('xIndices')}];\n                  ${op1}\n                }`;\n    } else {\n      codeW = `\n                for (var i: u32 = 0u; i < uniforms.kw; i++) {\n                  xIndices[${dimIdxW}] = indices[${dimIdxW}] * uniforms.sw - uniforms.pwStart + i;\n                  let x_val = x[${x.indicesToOffset('xIndices')}];\n                  ${op1}\n                }`;\n    }\n\n    if (attributes.kernelShape.length === 2) {\n      const dimIdxH = rank - (isChannelsLast ? 3 : 2);\n      if (phStartEndNotZero) {\n        codeH = `\n                for (var j: u32 = 0u; j < uniforms.kh; j++) {\n                  xIndices[${dimIdxH}] = indices[${dimIdxH}] * uniforms.sh - uniforms.phStart + j;\n                  if (xIndices[${dimIdxH}] < 0 || xIndices[${dimIdxH}] >= uniforms.x_shape[${dimIdxH}]) {\n                    pad += i32(uniforms.kw);\n                    continue;\n                  }\n              `;\n      } else {\n        codeH = `\n                for (var j: u32 = 0u; j < uniforms.kh; j++) {\n                  xIndices[${dimIdxH}] = indices[${dimIdxH}] * uniforms.sh - uniforms.phStart + j;\n                `;\n      }\n      codeHEnd = `\n              }\n            `;\n    }\n\n    const poolingCode = `\n            ${shaderHelper.registerUniforms(uniforms).declareVariables(x, output)}\n\n            ${shaderHelper.mainStart()}\n              ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n\n              let indices = ${output.offsetToIndices('global_idx')};\n              var xIndices = ${output.offsetToIndices('global_idx')};\n\n              var value = ${dataType}(${start});\n              var pad = 0;\n              ${codeH}\n              ${codeW}\n              ${codeHEnd}\n              ${op2}\n\n              output[global_idx] = value;\n            }`;\n    return poolingCode;\n  } else {\n    if (isChannelsLast) {\n      throw new Error('Pooling with kernelShape.length > 2 is not supported for NHWC format.');\n    }\n    const stridesRank = attributes.kernelShape.length;\n    const padsRank = attributes.pads.length;\n    let padCode = '';\n    if (hasPads) {\n      padCode = `\n                if (xIndices[j] >= uniforms.x_shape[j]) {\n                  pad++;\n                  isPad = true;\n                  break;\n                }\n              }\n              if (!isPad) {\n                let x_val = x[${x.indicesToOffset('xIndices')}];\n                ${op1}\n              }`;\n    } else {\n      padCode = `\n              }\n              let x_val = x[${x.indicesToOffset('xIndices')}];\n              ${op1}\n            `;\n    }\n    const poolingCode = `\n            ${shaderHelper.registerUniforms(uniforms).declareVariables(x, output)}\n\n            ${shaderHelper.mainStart()}\n              ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n              let indices = ${output.offsetToIndices('global_idx')};\n              var xIndices = ${output.offsetToIndices('global_idx')};\n\n              var offsets: array<u32, ${stridesRank}>;\n\n              var value = ${dataType}(${start});\n              var pad = 0;\n              var isPad = false;\n\n              for (var i: u32 = 0u; i < uniforms.kernelSize; i++) {\n                var offset = i;\n                for (var j = 0u; j < ${stridesRank - 1}u; j++) {\n                  offsets[j] = offset / ${getElementAt('uniforms.kernelStrides', 'j', stridesRank)};\n                  offset -= offsets[j] * ${getElementAt('uniforms.kernelStrides', 'j', stridesRank)};\n                }\n                offsets[${stridesRank - 1}] = offset;\n\n                isPad = false;\n                for (var j = ${rank - stridesRank}u; j < ${rank}u; j++) {\n                  xIndices[j] = indices[j] * ${\n        getElementAt('uniforms.strides', `j - ${rank - stridesRank}u`, stridesRank)}\n                    + offsets[j - ${rank - stridesRank}u] - ${getElementAt('uniforms.pads', 'j - 2u', padsRank)};\n                  ${padCode}\n              }\n              ${op2}\n\n              output[global_idx] = value;\n            }`;\n    return poolingCode;\n  }\n};\n\nexport interface FormatAttributes {\n  readonly format: 'NHWC'|'NCHW';\n}\n\nexport interface PoolCommonAttributes extends FormatAttributes {\n  readonly autoPad: string;\n  readonly ceilMode: number;\n  readonly kernelShape: readonly number[];\n  readonly strides: readonly number[];\n  readonly pads: readonly number[];\n}\n\nconst createShaderKeyFromAttributes = (attributes: PoolCommonAttributes): string =>\n    (`${attributes.format};${attributes.ceilMode};${attributes.autoPad};${attributes.kernelShape.length}`);\n\nconst createAveragePoolShaderKeyFromAttributes = (attributes: AveragePoolAttributes): string =>\n    (`${createShaderKeyFromAttributes(attributes)};${attributes.countIncludePad}`);\n\nconst createMaxPoolShaderKeyFromAttributes = (attributes: MaxPoolAttributes): string =>\n    (`${createShaderKeyFromAttributes(attributes)};${attributes.storageOrder};${attributes.dilations}`);\n\nconst parsePoolCommonAttributes = (attributes: Record<string, unknown>): PoolCommonAttributes => ({\n  format: attributes.format as FormatAttributes['format'],\n  autoPad: ['NOTSET', 'VALID', 'SAME_UPPER', 'SAME_LOWER'][attributes.auto_pad as number],\n  ceilMode: attributes.ceil_mode as number,\n  kernelShape: attributes.kernel_shape as [number, number],\n  strides: attributes.strides as [number, number],\n  pads: attributes.pads as [number, number, number, number]\n});\n\nexport interface AveragePoolAttributes extends PoolCommonAttributes, AttributeWithCacheKey {\n  readonly countIncludePad: boolean;\n}\n\nconst createAveragePoolProgramInfo =\n    (name: string, input: TensorView, isGlobalOperator: boolean, attributes: AveragePoolAttributes): ProgramInfo => {\n      const [adjustedAttributes, outputShape] =\n          getAdjustedPoolAttributesAndOutputShape(input, attributes, isGlobalOperator);\n      const x = inputVariable('x', input.dataType, input.dims.length);\n      const dataType = x.type.value;\n\n      const op1 = 'value += x_val;';\n      let op2 = '';\n      if (adjustedAttributes.countIncludePad) {\n        op2 += `value /= ${dataType}(uniforms.kernelSize);`;\n      } else {\n        op2 += `value /= ${dataType}(i32(uniforms.kernelSize) - pad);`;\n      }\n      const [programUniforms, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero] =\n          getUniformAndPadInfo(outputShape, adjustedAttributes);\n      programUniforms.push(...createTensorShapeVariables(input.dims, outputShape));\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank'];\n      return {\n        name,\n        shaderCache:\n            {hint: `${attributes.cacheKey};${hasPads};${pwStartEndNotZero};${phStartEndNotZero}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: input.dataType}],\n          dispatchGroup: {x: Math.ceil(ShapeUtil.size(outputShape) / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource: shaderHelper => generatePoolingCode(\n            shaderHelper, x, input.dims.length, outputShape.length, adjustedAttributes, op1, op2, 0.0, uniforms,\n            hasPads, pwStartEndNotZero, phStartEndNotZero),\n      };\n    };\n\nexport const parseAveragePoolAttributes = (attributes: Record<string, unknown>): AveragePoolAttributes => {\n  const countIncludePad = (attributes.count_include_pad as number) === 0 ? false : true;\n\n  const attr = parsePoolCommonAttributes(attributes);\n  // TODO: support attribute 'ceil_mode'\n  if (attr.ceilMode !== 0) {\n    throw new Error('using ceil() in shape computation is not yet supported for AveragePool');\n  }\n  const averagePoolAttributes = {countIncludePad, ...attr, cacheKey: ''};\n  return {...averagePoolAttributes, cacheKey: createAveragePoolShaderKeyFromAttributes(averagePoolAttributes)};\n};\n\nexport const averagePool = (context: ComputeContext, attributes: AveragePoolAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createAveragePoolProgramInfo('AveragePool', context.inputs[0], false, attributes));\n};\n\nconst globalPoolAttributes = {\n  autoPad: '',\n  ceilMode: 0,\n  countIncludePad: false,\n  kernelShape: [],\n  strides: [],\n  pads: [],\n  storageOrder: 0,\n  dilations: []\n};\n\nexport const parseGlobalAveragePoolAttributes = (attributes: Record<string, unknown>): AveragePoolAttributes => {\n  const format = attributes.format as FormatAttributes['format'];\n  return {format, ...globalPoolAttributes, cacheKey: format};\n};\n\nexport const globalAveragePool = (context: ComputeContext, attributes: AveragePoolAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createAveragePoolProgramInfo('GlobalAveragePool', context.inputs[0], true, attributes));\n};\n\nexport interface MaxPoolAttributes extends PoolCommonAttributes, AttributeWithCacheKey {\n  readonly storageOrder: number;\n  readonly dilations: number[];\n}\n\nconst createMaxPoolProgramInfo =\n    (name: string, input: TensorView, isGlobalOperator: boolean, attributes: MaxPoolAttributes): ProgramInfo => {\n      const [adjustedAttributes, outputShape] =\n          getAdjustedPoolAttributesAndOutputShape(input, attributes, isGlobalOperator);\n      const op1 = `\n      value = max(x_val, value);\n    `;\n      const op2 = '';\n      const x = inputVariable('x', input.dataType, input.dims.length);\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank'];\n      const [programUniforms, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero] =\n          getUniformAndPadInfo(outputShape, adjustedAttributes);\n      programUniforms.push(...createTensorShapeVariables(input.dims, outputShape));\n      return {\n        name,\n        shaderCache:\n            {hint: `${attributes.cacheKey};${hasPads};${pwStartEndNotZero};${phStartEndNotZero}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: input.dataType}],\n          dispatchGroup: {x: Math.ceil(ShapeUtil.size(outputShape) / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource: shaderHelper => generatePoolingCode(\n            shaderHelper, x, input.dims.length, outputShape.length, adjustedAttributes, op1, op2,\n            (input.dataType === DataType.float16) ? -65504 : -1e5, uniforms, hasPads, pwStartEndNotZero,\n            phStartEndNotZero),\n      };\n    };\n\nexport const maxPool = (context: ComputeContext, attributes: MaxPoolAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createMaxPoolProgramInfo('MaxPool', context.inputs[0], false, attributes));\n};\n\nexport const parseMaxPoolAttributes = (attributes: Record<string, unknown>): MaxPoolAttributes => {\n  const storageOrder = attributes.storage_order as number;\n  const dilations = attributes.dilations as [number, number];\n\n  const attr = parsePoolCommonAttributes(attributes);\n  // TODO: support attribute 'ceil_mode' and 'storage_order'\n  if (storageOrder !== 0) {\n    throw new Error('column major storage order is not yet supported for MaxPool');\n  }\n  if (attr.ceilMode !== 0) {\n    throw new Error('using ceil() in shape computation is not yet supported for MaxPool');\n  }\n  const maxPoolAttributes = {storageOrder, dilations, ...attr, cacheKey: ''};\n  return {...maxPoolAttributes, cacheKey: createMaxPoolShaderKeyFromAttributes(maxPoolAttributes)};\n};\n\nexport const parseGlobalMaxPoolAttributes = (attributes: Record<string, unknown>): MaxPoolAttributes => {\n  const format = attributes.format as FormatAttributes['format'];\n  return {format, ...globalPoolAttributes, cacheKey: format};\n};\n\nexport const globalMaxPool = (context: ComputeContext, attributes: MaxPoolAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createMaxPoolProgramInfo('GlobalMaxPool', context.inputs[0], true, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {env} from 'onnxruntime-common';\n\nimport {DataType} from '../../../wasm-common';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, outputVariable, ShaderHelper, UniformDataElementType, UniformsArrayType} from './common';\n\nconst validateInputsContent = (start: number, limit: number, delta: number): void => {\n  const sameStartLimit = start === limit;\n  const increasingRangeNegativeStep = start < limit && delta < 0;\n  const decreasingRangePositiveStep = start > limit && delta > 0;\n\n  if (sameStartLimit || increasingRangeNegativeStep || decreasingRangePositiveStep) {\n    throw new Error('Range these inputs\\' contents are invalid.');\n  }\n};\n\nconst createRangeProgramInfo = (start: number, limit: number, delta: number, dataType: DataType): ProgramInfo => {\n  const numElements = Math.abs(Math.ceil((limit - start) / delta));\n  const outputShape: number[] = [numElements];\n  const outputSize = numElements;\n  const programUniforms: ProgramUniform[] = [\n    {type: DataType.uint32, data: outputSize}, {type: dataType, data: start}, {type: dataType, data: delta},\n    ...createTensorShapeVariables(outputShape)\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const output = outputVariable('output', dataType, outputShape.length);\n    const wgslType = output.type.value;\n    const uniforms: UniformsArrayType = [\n      {name: 'outputSize', type: 'u32'}, {name: 'start', type: wgslType as UniformDataElementType},\n      {name: 'delta', type: wgslType as UniformDataElementType}\n    ];\n    return `\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(output)}\n        ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n        output[global_idx] = uniforms.start + ${wgslType}(global_idx) * uniforms.delta;\n      }`;\n  };\n\n  return {\n    name: 'Range',\n    shaderCache: {hint: `${dataType}`},\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n      programUniforms\n    })\n  };\n};\n\nexport const range = (context: ComputeContext): void => {\n  let start = 0;\n  let limit = 0;\n  let delta = 0;\n  if (context.inputs[0].dataType === DataType.int32) {\n    start = context.inputs[0].getInt32Array()[0];\n    limit = context.inputs[1].getInt32Array()[0];\n    delta = context.inputs[2].getInt32Array()[0];\n  } else if (context.inputs[0].dataType === DataType.float) {\n    start = context.inputs[0].getFloat32Array()[0];\n    limit = context.inputs[1].getFloat32Array()[0];\n    delta = context.inputs[2].getFloat32Array()[0];\n  }\n  if (env.webgpu.validateInputContent) {\n    validateInputsContent(start, limit, delta);\n  }\n\n  context.compute(createRangeProgramInfo(start, limit, delta, context.inputs[0].dataType), {inputs: []});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\n\ntype CoordinateTransformMode = 'half_pixel'|'asymmetric'|'pytorch_half_pixel'|'tf_half_pixel_for_nn'|'align_corners'|\n    'tf_crop_and_resize'|'half_pixel_symmetric';\n\ntype KeepAspectRatioPolicy = 'stretch'|'not_smaller'|'not_larger';\n\ntype Mode = 'nearest'|'linear'|'cubic';\n\ntype NearestMode = 'round_prefer_floor'|'round_prefer_ceil'|'floor'|'ceil'|'simple';\n\nexport interface ResizeAttributes extends AttributeWithCacheKey {\n  antialias: number;\n  axes: number[];\n  coordinateTransformMode: CoordinateTransformMode;\n  cubicCoeffA: number;\n  excludeOutside: boolean;\n  extrapolationValue: number;\n  keepAspectRatioPolicy: KeepAspectRatioPolicy;\n  mode: Mode;\n  nearestMode: NearestMode;\n}\n\nconst validateScales = (scales: number[], attributes: ResizeAttributes): void => {\n  scales.every((value) => value > 0 || (() => {\n                            throw new Error('Resize requires scales input values to be positive');\n                          }));\n  // Check scales dims based on mode: LINEAR, CUBIC\n  if (scales.length > 0) {\n    if (attributes.mode === 'linear') {\n      if (!(scales.length === 2 || scales.length === 3 || (scales.length === 4 && scales[0] === 1 && scales[1] === 1) ||\n            (scales.length === 4 && scales[0] === 1 && scales[3] === 1) ||\n            (scales.length === 5 && scales[0] === 1 && scales[1] === 1))) {\n        throw new Error(\n            `For linear mode, Resize requires scales to be 2D, 3D, 4D with either two outermost or one innermost and\n            one outermost scale values equal to 1, or 5D with two outermost scale values equal to 1`);\n      }\n    } else if (attributes.mode === 'cubic') {\n      if (!(scales.length === 2 || (scales.length === 4 && scales[0] === 1 && scales[1] === 1) ||\n            (scales.length === 4 && scales[0] === 1 && scales[3] === 1))) {\n        throw new Error('Resize requires scales input size to be 2 or 4 for cubic mode');\n      }\n    }\n  }\n};\n\nconst updateScales = (scales: readonly number[], axes: readonly number[], rank: number): number[] => {\n  axes.every((value) => value >= 0 && value < rank || (() => {\n                          throw new Error('Resize requires axes input values to be positive and less than rank');\n                        }));\n  const newScales = new Array(rank).fill(1.0);\n  axes.forEach((value, index) => newScales[value] = scales[index]);\n  return newScales;\n};\n\nconst validateInputs =\n    (inputs: readonly TensorView[], attributes: ResizeAttributes, opsetVersion: number, scales: number[],\n     sizes: number[], roi: number[]): void => {\n      const [roiInputIndex, scalesInputIndex, sizesInputIndex] =\n          (opsetVersion > 10) ? [1, 2, 3] : [-1, (inputs.length > 1) ? 1 : -1, -1];\n      const rank = inputs[0].dims.length;\n      if (roiInputIndex > 0 && inputs.length > roiInputIndex && inputs[roiInputIndex].dims.length > 0) {\n        inputs[roiInputIndex].getFloat32Array().forEach((value) => roi.push(value));\n      } else if (attributes.coordinateTransformMode === 'tf_crop_and_resize') {\n        throw new Error('Resize requires RoI input to be specified when coordinateTransformMode is tfCropAndResize');\n      }\n\n      if (scalesInputIndex > 0 && inputs.length > scalesInputIndex && inputs[scalesInputIndex].dims.length > 0) {\n        inputs[scalesInputIndex].getFloat32Array().forEach((value) => scales.push(value));\n        if (scales.length !== 0 &&\n            (scales.length !== rank && (opsetVersion >= 18 && scales.length !== attributes.axes.length))) {\n          throw new Error(\n              'Resize requires scales input size to be same as input rank or axes size for opset 18 and up');\n        }\n        validateScales(scales, attributes);\n        if (attributes.axes.length > 0) {\n          updateScales(scales, attributes.axes, rank).forEach((value, index) => scales[index] = value);\n        }\n      }\n      if (sizesInputIndex > 0 && inputs.length > sizesInputIndex) {\n        inputs[sizesInputIndex].getBigInt64Array().forEach((value) => sizes.push(Number(value)));\n        if (sizes.length !== rank || (opsetVersion >= 18 && sizes.length === attributes.axes.length)) {\n          throw new Error('Resize requires sizes input size to be same as input rank or axes size for opset 18 and up');\n        }\n      }\n\n      if (attributes.axes.length > 0) {\n        if (scales.length !== attributes.axes.length) {\n          throw new Error('Resize requires \"scales\" input size to be of axes rank when axes attributes is specified');\n        }\n        if (sizes.length !== attributes.axes.length) {\n          throw new Error(\n              'Resize requires \"sizes\" input size to be of rank axes rank when axes attributes is specified');\n        }\n      }\n      if (typeof scales !== 'undefined' && typeof sizes !== 'undefined' && scales.length > 0 && sizes.length > rank) {\n        throw new Error('Resize requires only of scales or sizes to be specified');\n      }\n    };\n\nconst getOriginalCoordinateFromResizedCoordinate =\n    (coordinateTransferMode: CoordinateTransformMode, dType: string): string =>\n        `fn getOriginalCoordinateFromResizedCoordinate(xResized: u32, xScale: f32, lengthResized: u32,\n     lengthOriginal: u32, roiStart: f32, roiEnd: f32) -> ${dType} { ` +\n    (() => {\n          switch (coordinateTransferMode) {\n            case 'asymmetric':\n              return `return ${dType}(xResized) / ${dType}(xScale);`;\n            case 'pytorch_half_pixel':\n              return `if (lengthResized > 1) {\n                    return (${dType}(xResized) + 0.5) / ${dType}(xScale) - 0.5;\n                  } else {\n                    return 0.0;\n                  }`;\n            case 'tf_half_pixel_for_nn':\n              return `return (${dType}(xResized) + 0.5) / ${dType}(xScale);`;\n            case 'align_corners':\n              return `if (lengthResized == 1) {\n                    return 0.0;\n                  } else {\n                    // The whole part and the fractional part are calculated separately due to inaccuracy of floating\n                    // point division. As an example, f32(21) / f32(7) may evaluate to 2.99... instead of 3, causing an\n                    // offset-by-one error later in floor().\n                    let whole = ${dType}(xResized * (lengthOriginal - 1) / (lengthResized - 1));\n                    let fract =\n                        ${dType}(xResized * (lengthOriginal - 1) % (lengthResized - 1)) / ${dType}(lengthResized - 1);\n                    return whole + fract;\n                  }`;\n            case 'tf_crop_and_resize':\n              return `if (lengthResized > 1) {\n                    return ${dType}(roiStart) * ${dType}(lengthOriginal - 1) +\n                        (${dType}(xResized) * ${dType}(roiEnd - roiStart) * ${dType}(lengthOriginal - 1)) /\n                        ${dType}(lengthResized - 1);\n                  } else {\n                    return 0.5 * ${dType}(roiStart + roiEnd) * ${dType}(lengthOriginal - 1);\n                  }`;\n            case 'half_pixel_symmetric':\n              return `const outputWidth = ${dType}xScale * ${dType}(lengthResized);\n                  const adjustment = ${dType}(lengthResized) / outputWidth;\n                  const center = ${dType}(lengthOriginal) / 2;\n                  const offset = center * (1 - adjustment);\n                  return offset + ((${dType}(xResized) + 0.5) / ${dType}(xScale)) - 0.5;`;\n            case 'half_pixel':\n              return `return ((${dType}(xResized) + 0.5) / ${dType}(xScale)) - 0.5;`;\n            default:\n              throw new Error(`Coordinate transform mode ${coordinateTransferMode} is not supported`);\n          }\n        })() +\n    '}';\n\nconst getNearestPixelFromOriginal = (nearestMode: NearestMode, opsetVersion: number, dType: string): string =>\n    `fn getNearestPixelFromOriginal(xOriginal: ${dType}, isDownSample: bool) -> ${dType} {` + (() => {\n      switch (nearestMode) {\n        case 'round_prefer_ceil':\n          return 'if (fract(xOriginal) == 0.5) { \\\n            return ceil(xOriginal); \\\n          } else { \\\n            return round(xOriginal); \\\n          }';\n        case 'floor':\n          return 'return floor(xOriginal);';\n        case 'ceil':\n          return 'return ceil(xOriginal);';\n        case 'round_prefer_floor':\n          return 'if (fract(xOriginal) == 0.5) { \\\n                    return floor(xOriginal); \\\n                  } else { \\\n                    return round(xOriginal); \\\n                  }';\n        case 'simple':\n        default:\n          if (opsetVersion < 11) {\n            return 'if (isDownSample) \\\n                    { \\\n                      return ceil(xOriginal); \\\n                    } else { \\\n                      return xOriginal; \\\n                    }';\n          }\n          throw new Error(`Nearest mode ${nearestMode} is not supported`);\n      }\n    })() +\n    '}';\n\nconst updateRoI = (roi: readonly number[], axes: readonly number[], rank: number): number[] => {\n  const roiTmp = new Array(rank).fill(0).concat(new Array(rank).fill(1));\n  const roiLocal = roi.length === 0 ? roiTmp : roi.slice();\n  if (axes.length > 0) {\n    axes.forEach((v, i) => {\n      roiTmp[v] = roiLocal[i];\n      roiTmp[i + rank] = roiLocal[axes.length + i];\n    });\n    return roiTmp;\n  }\n  return roiLocal;\n};\n\nconst initOutputShape =\n    (inputShape: readonly number[], scales: readonly number[], sizes: readonly number[], axes: readonly number[]):\n        number[] => {\n          let outputShape: number[] = [];\n          if (sizes.length > 0) {\n            if (axes.length > 0) {\n              inputShape.forEach((v) => outputShape.push(v));\n              if (Math.max(...axes) > inputShape.length) {\n                throw new Error('axes is out of bound');\n              }\n              axes.forEach((v, i) => outputShape[v] = sizes[i]);\n            } else {\n              sizes.forEach((v) => outputShape.push(v));\n            }\n          } else {\n            if (scales.length === 0) {\n              throw new Error('Resize requires either scales or sizes.');\n            } else {\n              outputShape = inputShape.map((value, index) => Math.round(value * scales[index]));\n            }\n          }\n          return outputShape;\n        };\n\nconst adjustOutputShape = (inputShape: readonly number[], scales: number[], attributes: ResizeAttributes) => {\n  const scaleInPolicy = (() => {\n    switch (attributes.keepAspectRatioPolicy) {\n      case 'not_larger':\n        return attributes.axes.length > 0 ? Math.min(...attributes.axes.map(i => scales[i]), Number.MAX_VALUE) :\n                                            Math.min(...scales, Number.MAX_VALUE);\n      case 'not_smaller':\n        return attributes.axes.length > 0 ? Math.max(...attributes.axes.map(i => scales[i]), Number.MIN_VALUE) :\n                                            Math.max(...scales, Number.MIN_VALUE);\n      default:\n        throw new Error(`Keep aspect ratio policy ${attributes.keepAspectRatioPolicy} is not supported`);\n    }\n  })();\n  scales.fill(1.0, 0, scales.length);\n  const adjustedOutputShape = inputShape.slice();\n  if (attributes.axes.length > 0) {\n    attributes.axes.forEach((v) => scales[v] = scaleInPolicy);\n    attributes.axes.forEach((v) => adjustedOutputShape[v] = Math.round(inputShape[v] * scales[v]));\n  } else {\n    scales.fill(scaleInPolicy, 0, scales.length);\n    adjustedOutputShape.forEach((v, i) => adjustedOutputShape[i] = Math.round(v * scales[i]));\n  }\n  return adjustedOutputShape;\n};\n\nconst calculateOriginalIndicesFromOutputIndices =\n    (output: IndicesHelper, inputShape: readonly number[], outputShape: readonly number[], scalesLength: number,\n     roiLength: number): string => `\n    fn calculateOriginalIndicesFromOutputIndices(output_indices: ${output.type.indices}) -> array<${\n        output.type.value}, ${outputShape.length}> {\n      var original_indices: array<${output.type.value}, ${outputShape.length}>;\n      for (var i:u32 = 0; i < ${outputShape.length}; i++) {\n        var output_index = ${output.indicesGet('output_indices', 'i')};\n        var scale = ${getElementAt('uniforms.scales', 'i', scalesLength)};\n        var roi_low = ${getElementAt('uniforms.roi', 'i', roiLength)};\n        var roi_hi = ${getElementAt('uniforms.roi', `i + ${inputShape.length}`, roiLength)};\n        if (scale == 1.0) {\n          original_indices[i] = ${output.type.value}(output_index);\n        } else {\n          var input_shape_i = ${getElementAt('uniforms.input_shape', 'i', inputShape.length)};\n          var output_shape_i = ${getElementAt('uniforms.output_shape', 'i', outputShape.length)};\n          original_indices[i] = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i,\n                                                                           input_shape_i, roi_low, roi_hi);\n        }\n      }\n      return original_indices;\n    }`;\n\nconst calculateInputIndicesFromOutputIndices =\n    (input: IndicesHelper, output: IndicesHelper, inputShape: readonly number[], outputShape: readonly number[],\n     scalesLength: number, roiLength: number, useExtrapolation: boolean): string => `\n    fn calculateInputIndicesFromOutputIndices(output_indices: ${output.type.indices}) -> ${input.type.indices} {\n      var input_indices: ${input.type.indices};\n      for (var i:u32 = 0; i < ${outputShape.length}; i++) {\n        var output_index = ${output.indicesGet('output_indices', 'i')};\n        var input_index: u32;\n        var scale = ${getElementAt('uniforms.scales', 'i', scalesLength)};\n        if (scale == 1.0) {\n          input_index = output_index;\n        } else {\n          var roi_low = ${getElementAt('uniforms.roi', 'i', roiLength)};\n          var roi_hi = ${getElementAt('uniforms.roi', `i + ${inputShape.length}`, roiLength)};\n          var input_shape_i = ${getElementAt('uniforms.input_shape', 'i', inputShape.length)};\n          var output_shape_i = ${getElementAt('uniforms.output_shape', 'i', outputShape.length)};\n          var original_idx = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i,\n                                                                        input_shape_i, roi_low, roi_hi);\n          if (!${useExtrapolation} || (original_idx >= 0 && original_idx < ${output.type.value}(input_shape_i))) {\n            if (original_idx < 0) {\n              input_index = 0;\n            } else if (original_idx > ${output.type.value}(input_shape_i - 1)) {\n              input_index = input_shape_i - 1;\n            } else {\n              input_index = u32(getNearestPixelFromOriginal(original_idx, scale < 1));\n            }\n          } else {\n            input_index = u32(original_idx);\n          }\n        }\n        ${input.indicesSet('input_indices', 'i', ' input_index')}\n      }\n      return input_indices;\n    }`;\nconst checkInputIndices = (input: IndicesHelper, inputShape: readonly number[]): string => `\n    fn checkInputIndices(input_indices: ${input.type.indices}) -> bool {\n      for (var i:u32 = 0; i < ${inputShape.length}; i++) {\n        var input_index = ${input.indicesGet('input_indices', 'i')};\n        if (input_index < 0 || input_index >= ${getElementAt('uniforms.input_shape', 'i', inputShape.length)}) {\n          return false;\n        }\n      }\n      return true;\n    }`;\n\nconst setChannelAndBatchIndices =\n    (input: IndicesHelper, channelIdx: number, batchIdx: number, spacialDims: number): string =>\n        input.rank > spacialDims ? `\n    ${input.indicesSet('input_indices', channelIdx, 'channel')};\n    ${input.indicesSet('input_indices', batchIdx, 'batch')};\n` :\n                                   '';\n\nconst bilinearInterpolation =\n    (input: IndicesHelper, output: IndicesHelper, inputShape: readonly number[], useExtrapolation: boolean,\n     extrapolationValue: number): string => {\n      const isNchw = true;\n      const [batchIdx, heightIdx, widthIdx, channelIdx] =\n          inputShape.length === 2 ? [-1, 0, 1, -1] : (isNchw ? [0, 2, 3, 1] : [0, 1, 2, 3]);\n      const dType = input.type.value;\n      return `\n    fn getInputValue(batch: u32, channel: u32, row: u32, col: u32) -> ${dType} {\n      var input_indices: ${input.type.indices};\n      ${input.indicesSet('input_indices', heightIdx, `max(0, min(row, ${inputShape[heightIdx]} - 1))`)};\n      ${input.indicesSet('input_indices', widthIdx, `max(0, min(col, ${inputShape[widthIdx]} - 1))`)};\n      ${setChannelAndBatchIndices(input, channelIdx, batchIdx, 2)}\n      return ${input.getByIndices('input_indices')};\n    }\n\n    fn bilinearInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n      var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices);\n      var row:${dType} = originalIndices[${heightIdx}];\n      var col:${dType} = originalIndices[${widthIdx}];\n      ${\n          useExtrapolation ?\n              `if (row < 0 || row > (${inputShape[heightIdx]} - 1) || col < 0 || col > (${inputShape[widthIdx]} - 1)) {\n        return ${extrapolationValue};\n      }` :\n              ''};\n      row = max(0, min(row, ${inputShape[heightIdx]} - 1));\n      col = max(0, min(col, ${inputShape[widthIdx]} - 1));\n      var row1: u32 = u32(row);\n      var col1: u32 = u32(col);\n      var row2: u32 = u32(row + 1);\n      var col2: u32 = u32(col + 1);\n      var channel: u32 = ${inputShape.length > 2 ? `u32(originalIndices[${channelIdx}])` : '0'};\n      var batch: u32 =  ${inputShape.length > 2 ? `u32(originalIndices[${batchIdx}])` : '0'};\n      var x11: ${dType} = getInputValue(batch, channel, row1, col1);\n      var x12: ${dType} = getInputValue(batch, channel, row1, col2);\n      var x21: ${dType} = getInputValue(batch, channel, row2, col1);\n      var x22: ${dType} = getInputValue(batch, channel, row2, col2);\n      var dx1: ${dType} = abs(row - ${dType}(row1));\n      var dx2: ${dType} = abs(${dType}(row2) - row);\n      var dy1: ${dType} = abs(col - ${dType}(col1));\n      var dy2: ${dType} = abs(${dType}(col2) - col);\n      if (row1 == row2) {\n        dx1 = 0.5;\n        dx2 = 0.5;\n      }\n      if (col1 == col2) {\n        dy1 = 0.5;\n        dy2 = 0.5;\n      }\n      return (x11 * dx2 * dy2 + x12 * dx2 * dy1 + x21 * dx1 * dy2 + x22 * dx1 * dy1);\n    }`;\n    };\n\nconst bicubicInterpolation =\n    (input: IndicesHelper, output: IndicesHelper, inputShape: readonly number[], outputShape: readonly number[],\n     scales: readonly number[], roi: readonly number[], cubicCoeffA: number, useExtrapolation: boolean,\n     extrapolationValue: number, excludeOutside: boolean): string => {\n      const is2D = inputShape.length === 2;\n      const isNchw = true;\n      const [heightIdx, widthIdx] = is2D ? [0, 1] : isNchw ? [2, 3] : [1, 2];\n      const dType = input.type.value;\n      const createCubicInterpolationFunction = (idx: number): string => {\n        const direction = idx === heightIdx ? 'row' : 'col';\n        return `\n      fn ${direction}CubicInterpolation(input_indices: ${input.type.indices}, output_indices: ${\n            output.type.indices}) -> ${dType} {\n        var output_index = ${output.indicesGet('output_indices', idx)};\n        var originalIdx: ${dType} = getOriginalCoordinateFromResizedCoordinate(output_index, ${scales[idx]},\n        ${outputShape[idx]}, ${inputShape[idx]}, ${roi[idx]}, ${roi[idx]} + ${inputShape.length});\n        var fractOriginalIdx: ${dType} = originalIdx - floor(originalIdx);\n        var coefs = getCubicInterpolationCoefs(fractOriginalIdx);\n\n        if (${useExtrapolation} && (originalIdx < 0 || originalIdx > (${inputShape[idx]} - 1))) {\n          return ${extrapolationValue};\n        }\n        var data: array<${dType}, 4> = array<${dType}, 4>(0.0, 0.0, 0.0, 0.0);\n        for (var i: i32 = -1; i < 3; i++) {\n          var ${direction}: ${dType} = originalIdx + ${dType}(i);\n          if (${direction} < 0 || ${direction} >= ${inputShape[idx]}) {\n            ${(() => {\n          if (excludeOutside) {\n            return `coefs[i + 1] = 0.0;\n                        continue;`;\n          } else if (useExtrapolation) {\n            return `return ${extrapolationValue};`;\n          } else {\n            return `${direction} = max(0, min(${direction}, ${inputShape[idx]} - 1));`;\n          }\n        })()};\n          }\n        var input_indices_copy: ${input.type.indices} = input_indices;\n          ${input.indicesSet('input_indices_copy', idx, `u32(${direction})`)};\n          data[i + 1] = ${\n            idx === heightIdx ? input.getByIndices('input_indices_copy') :\n                                'rowCubicInterpolation(input_indices_copy, output_indices)'};\n        }\n        return cubicInterpolation1D(data, coefs);\n      }`;\n      };\n\n      return `\n    ${createCubicInterpolationFunction(heightIdx)};\n    ${createCubicInterpolationFunction(widthIdx)};\n  fn getCubicInterpolationCoefs(s: ${dType}) -> array<${dType}, 4> {\n    var absS = abs(s);\n    var coeffs: array<${dType}, 4> = array<${dType}, 4>(0.0, 0.0, 0.0, 0.0);\n    var oneMinusAbsS: ${dType} = 1.0 - absS;\n    var twoMinusAbsS: ${dType} = 2.0 - absS;\n    var onePlusAbsS: ${dType} = 1.0 + absS;\n    coeffs[0] = ((${cubicCoeffA} * onePlusAbsS - 5 * ${cubicCoeffA}) * onePlusAbsS + 8 * ${\n          cubicCoeffA}) * onePlusAbsS - 4 * ${cubicCoeffA};\n    coeffs[1] = ((${cubicCoeffA} + 2) * absS - (${cubicCoeffA} + 3)) * absS * absS + 1;\n    coeffs[2] = ((${cubicCoeffA} + 2) * oneMinusAbsS - (${cubicCoeffA} + 3)) * oneMinusAbsS * oneMinusAbsS + 1;\n    coeffs[3] = ((${cubicCoeffA} * twoMinusAbsS - 5 * ${cubicCoeffA}) * twoMinusAbsS + 8 * ${\n          cubicCoeffA}) * twoMinusAbsS - 4 * ${cubicCoeffA};\n    return coeffs;\n  }\n\n  fn cubicInterpolation1D(x: array<${dType}, 4>, coefs: array<${dType}, 4>) -> ${dType} {\n    var coefsSum: ${dType} = coefs[0] + coefs[1] + coefs[2] + coefs[3];\n    return (x[0] * coefs[0] + x[1] * coefs[1]+ x[2] * coefs[2]+ x[3] * coefs[3]) / coefsSum;\n  }\n\n  fn bicubicInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n    var input_indices: ${input.type.indices} = output_indices;\n    return colCubicInterpolation(input_indices, output_indices);\n  }\n    `;\n    };\n\nconst trilinearInterpolation =\n    (input: IndicesHelper, output: IndicesHelper, inputShape: readonly number[], useExtrapolation: boolean,\n     extrapolationValue: number): string => {\n      const isNchw = true;\n      const [batchIdx, depthIdx, heightIdx, widthIdx, channelIdx] =\n          inputShape.length === 3 ? [-1, 0, 1, 2, -1] : (isNchw ? [0, 2, 3, 4, 1] : [0, 1, 2, 3, 4]);\n      const dType = input.type.value;\n      return `\n    fn getInputValue(batch: u32, channel: u32, depth:u32, height: u32, width: u32) -> ${dType} {\n      var input_indices: ${input.type.indices};\n      ${input.indicesSet('input_indices', depthIdx, `max(0, min(depth, ${inputShape[depthIdx]} - 1))`)};\n      ${input.indicesSet('input_indices', heightIdx, `max(0, min(height, ${inputShape[heightIdx]} - 1))`)};\n      ${input.indicesSet('input_indices', widthIdx, `max(0, min(width, ${inputShape[widthIdx]} - 1))`)};\n      ${setChannelAndBatchIndices(input, channelIdx, batchIdx, 3)}\n      return ${input.getByIndices('input_indices')};\n    }\n\n    fn trilinearInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n      var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices);\n      var depth:${dType} = originalIndices[${depthIdx}];\n      var height:${dType} = originalIndices[${heightIdx}];\n      var width:${dType} = originalIndices[${widthIdx}];\n      ${\n          useExtrapolation ? `if (depth < 0 || depth > (${inputShape[depthIdx]} - 1) || height < 0 || height > (${\n                                 inputShape[heightIdx]} - 1) || width < 0 || (width > ${inputShape[widthIdx]} - 1)) {\n      return ${extrapolationValue};\n        }` :\n                             ''};\n\n    depth = max(0, min(depth, ${inputShape[depthIdx]} - 1));\n      height = max(0, min(height, ${inputShape[heightIdx]} - 1));\n      width = max(0, min(width, ${inputShape[widthIdx]} - 1));\n      var depth1: u32 = u32(depth);\n      var height1: u32 = u32(height);\n      var width1: u32 = u32(width);\n      var depth2: u32 = u32(depth + 1);\n      var height2: u32 = u32(height + 1);\n      var width2: u32 = u32(width + 1);\n      var channel: u32 = ${inputShape.length > 3 ? `u32(originalIndices[${channelIdx}])` : '0'};\n      var batch: u32 =  ${inputShape.length > 3 ? `u32(originalIndices[${batchIdx}])` : '0'};\n\n      var x111: ${dType} = getInputValue(batch, channel, depth1, height1, width1);\n      var x112: ${dType} = getInputValue(batch, channel, depth1, height1, width2);\n      var x121: ${dType} = getInputValue(batch, channel, depth1, height2, width1);\n      var x122: ${dType} = getInputValue(batch, channel, depth1, height2, width2);\n      var x211: ${dType} = getInputValue(batch, channel, depth2, height1, width1);\n      var x212: ${dType} = getInputValue(batch, channel, depth2, height1, width2);\n      var x221: ${dType} = getInputValue(batch, channel, depth2, height2, width1);\n      var x222: ${dType} = getInputValue(batch, channel, depth2, height2, width2);\n      var dx1: ${dType} = abs(depth - ${dType}(depth1));\n      var dx2: ${dType} = abs(${dType}(depth2) - depth);\n      var dy1: ${dType} = abs(height - ${dType}(height1));\n      var dy2: ${dType} = abs(${dType}(height2) - height);\n      var dz1: ${dType} = abs(width - ${dType}(width1));\n      var dz2: ${dType} = abs(${dType}(width2) - width);\n      if (depth1 == depth2) {\n        dx1 = 0.5;\n        dx2 = 0.5;\n      }\n      if (height1 == height2) {\n        dy1 = 0.5;\n        dy2 = 0.5;\n      }\n      if (width1 == width2) {\n        dz1 = 0.5;\n        dz2 = 0.5;\n      }\n      return (x111 * dx2 * dy2 * dz2 + x112 * dx2 * dy2 * dz1 + x121 * dx2 * dy1 *dz2 + x122 * dx2 * dy1 * dz1 +\n              x211 * dx1 * dy2 * dz2 + x212 * dx1 * dy2 * dz1 + x221 * dx1 * dy1 *dz2 + x222 * dx1 * dy1 * dz1);\n    }`;\n    };\n\nconst createResizeProgramInfo =\n    (inputTensor: TensorView, attributes: ResizeAttributes, opsetVersion: number, scalesInput: readonly number[],\n     sizes: readonly number[], roiInput: readonly number[]): ProgramInfo => {\n      const inputShape = inputTensor.dims;\n      const roi = updateRoI(roiInput, attributes.axes, inputShape.length);\n\n      let outputShape = initOutputShape(inputShape, scalesInput, sizes, attributes.axes);\n      let scales = scalesInput.slice();\n      if (scalesInput.length === 0) {\n        scales = inputShape.map((value, index) => value === 0 ? 1.0 : outputShape[index] / value);\n        if (attributes.keepAspectRatioPolicy !== 'stretch') {\n          outputShape = adjustOutputShape(inputShape, scales, attributes);\n        }\n      }\n      const output = outputVariable('output', inputTensor.dataType, outputShape.length);\n      const input = inputVariable('input', inputTensor.dataType, inputShape.length);\n      const outputSize = ShapeUtil.size(outputShape);\n      const noScale = inputShape.length === outputShape.length && inputShape.every((d, i) => d === outputShape[i]);\n      const useExtrapolation = attributes.coordinateTransformMode === 'tf_crop_and_resize';\n      const extrapolationValue = attributes.extrapolationValue;\n      const dataType = input.type.value;\n      const getShaderSource = (shaderHelper: ShaderHelper) => `\n      ${noScale ? '' : `\n      ${getOriginalCoordinateFromResizedCoordinate(attributes.coordinateTransformMode, dataType)};\n      ${(() => {\n        switch (attributes.mode) {\n          case 'nearest':\n            return `\n              ${checkInputIndices(input, inputShape)};\n              ${getNearestPixelFromOriginal(attributes.nearestMode, opsetVersion, dataType)};\n              ${\n                calculateInputIndicesFromOutputIndices(\n                    input, output, inputShape, outputShape, scales.length, roi.length, useExtrapolation)};\n              `;\n          case 'linear':\n            return `\n              ${calculateOriginalIndicesFromOutputIndices(output, inputShape, outputShape, scales.length, roi.length)};\n              ${(() => {\n              if (inputShape.length === 2 || inputShape.length === 4) {\n                return `${bilinearInterpolation(input, output, inputShape, useExtrapolation, extrapolationValue)}`;\n              } else if (inputShape.length === 3 || inputShape.length === 5) {\n                return `${trilinearInterpolation(input, output, inputShape, useExtrapolation, extrapolationValue)}`;\n              } else {\n                throw Error('Linear mode only supports input dims 2, 3, 4 and 5 are supported in linear mode.');\n              }\n            })()};\n            `;\n          case 'cubic':\n            return `\n            ${(() => {\n              if (inputShape.length === 2 || inputShape.length === 4) {\n                return `${\n                    bicubicInterpolation(\n                        input, output, inputShape, outputShape, scales, roi, attributes.cubicCoeffA, useExtrapolation,\n                        attributes.extrapolationValue, attributes.excludeOutside)}`;\n              } else {\n                throw Error('Cubic mode only supports input dims 2 and 4 are supported in linear mode.');\n              }\n            })()};\n            `;\n          default:\n            throw Error('Invalid resize mode');\n        }\n      })()};\n      `}\n      ${\n          shaderHelper.registerUniform('output_size', 'u32')\n              .registerUniform('scales', 'f32', scales.length)\n              .registerUniform('roi', 'f32', roi.length)\n              .declareVariables(input, output)}\n      ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n        ${noScale ? 'output[global_idx] = input[global_idx];' : `\n        let output_indices = ${output.offsetToIndices('global_idx')};\n        var input_indices: ${input.type.indices};\n        ${(() => {\n        switch (attributes.mode) {\n          case 'nearest':\n            return `input_indices = calculateInputIndicesFromOutputIndices(output_indices);\n                if (checkInputIndices(input_indices)) {\n                  output[global_idx] = ${input.getByIndices('input_indices')};\n                } else {\n                  output[global_idx] = ${attributes.extrapolationValue};\n                }`;\n          case 'linear':\n            return `output[global_idx] = ${\n                (inputShape.length === 2 || inputShape.length === 4) ? 'bilinearInterpolation' :\n                                                                       'trilinearInterpolation'}(output_indices);`;\n          case 'cubic':\n            return 'output[global_idx] = bicubicInterpolation(output_indices);';\n          default:\n            throw Error(`Unsupported resize mode: ${attributes.mode}`);\n        }\n      })()};\n`}\n      }`;\n\n      return {\n        name: 'Resize',\n        shaderCache: {\n          hint: `${attributes.cacheKey}|${opsetVersion}|${scales.length > 0 ? scales : ''}|${\n              sizes.length > 0 ? sizes : ''}|${roi.length > 0 ? roi : ''}|${noScale}|${inputShape}`,\n          inputDependencies: ['rank']\n        },\n        getShaderSource,\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputTensor.dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms: [\n            {type: DataType.uint32, data: outputSize}, {type: DataType.float, data: scales},\n            {type: DataType.float, data: roi}, ...createTensorShapeVariables(inputShape, outputShape)\n          ]\n        })\n      };\n    };\n\nconst getOpsetVersionFromCustomDataBuffer = (context: ComputeContext): number => {\n  const customDataBuffer = context.customDataBuffer;\n  const customDataBuffer32 = new Uint32Array(customDataBuffer, customDataBuffer.byteOffset, 1);\n  const opsetVersion = customDataBuffer32[0];\n  return opsetVersion;\n};\n\nexport const resize = (context: ComputeContext, attributes: ResizeAttributes): void => {\n  const scales: number[] = [];\n  const sizes: number[] = [];\n  const roi: number[] = [];\n\n  // Note that scales in resize are always f32. roi can be f32 or f16.\n  // TODO: Currently this code does not support f16 for roi when passed as optional input.\n\n  const opsetVersion = getOpsetVersionFromCustomDataBuffer(context);\n  if (attributes.antialias !== 0) {\n    throw Error('Only default value (0) for Antialias attribute is supported');\n  }\n  validateInputs(context.inputs, attributes, opsetVersion, scales, sizes, roi);\n  context.compute(\n      createResizeProgramInfo(context.inputs[0], attributes, opsetVersion, scales, sizes, roi), {inputs: [0]});\n};\n\nexport const parseResizeAttributes = (attributes: Record<string, unknown>): ResizeAttributes => {\n  const antialias = attributes.antialias as number;\n  const axes = attributes.axes as number[];\n  const coordinateTransformMode: CoordinateTransformMode =\n      attributes.coordinateTransformMode as CoordinateTransformMode;\n  const cubicCoeffA = attributes.cubicCoeffA as number;\n  const excludeOutside = attributes.excludeOutside as number !== 0;\n  const extrapolationValue = attributes.extrapolationValue as number;\n  const keepAspectRatioPolicy: KeepAspectRatioPolicy = attributes.keepAspectRatioPolicy as KeepAspectRatioPolicy;\n  const mode: Mode = attributes.mode as Mode;\n  // If nearestMode is not specified, use simple mode.\n  const nearestMode: NearestMode = (attributes.nearestMode === '' ? 'simple' : attributes.nearestMode) as NearestMode;\n  return createAttributeWithCacheKey({\n    antialias,\n    axes,\n    coordinateTransformMode,\n    cubicCoeffA,\n    excludeOutside,\n    extrapolationValue,\n    keepAspectRatioPolicy,\n    mode,\n    nearestMode\n  });\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper, WORKGROUP_SIZE} from './common';\n\nexport interface RotaryEmbeddingAttributes {\n  readonly interleaved: boolean;\n  readonly numHeads: number;\n  readonly rotaryEmbeddingDim: number;\n  readonly scale: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: RotaryEmbeddingAttributes): void => {\n  const [input, positionIds, cosCache, sinCache] = inputs;\n  const {numHeads, rotaryEmbeddingDim} = attributes;\n\n  if (input.dims.length !== 3 && input.dims.length !== 4) {\n    throw new Error(`Input 'x' is expected to have 3 or 4 dimensions, got ${input.dims.length}`);\n  }\n  if (!ShapeUtil.areEqual(positionIds.dims, []) && !ShapeUtil.areEqual(positionIds.dims, [1]) &&\n      positionIds.dims.length !== 2) {\n    throw new Error(`Input 'position_ids' is expected to have 0, 1, or 2 dimensions, got ${positionIds.dims.length}`);\n  }\n  if (cosCache.dims.length !== 2) {\n    throw new Error(`Input 'cos_cache' is expected to have 2 dimensions, got ${cosCache.dims.length}`);\n  }\n  if (sinCache.dims.length !== 2) {\n    throw new Error(`Input 'sin_cache' is expected to have 2 dimensions, got ${sinCache.dims.length}`);\n  }\n  if (!ShapeUtil.areEqual(cosCache.dims, sinCache.dims)) {\n    throw new Error('Inputs \\'cos_cache\\' and \\'sin_cache\\' are expected to have the same shape');\n  }\n\n  if (rotaryEmbeddingDim > 0 && numHeads === 0) {\n    throw new Error('num_heads must be provided if rotary_embedding_dim is specified');\n  }\n\n  const batchSize = input.dims[0];\n  const sequenceLength = input.dims[input.dims.length - 2];\n  const maxSequenceLength = cosCache.dims[0];\n  const hiddenSize = ShapeUtil.sizeFromDimension(input.dims, 1) / sequenceLength;\n  const headSize = rotaryEmbeddingDim === 0 ? cosCache.dims[1] * 2 : hiddenSize / numHeads;\n  if (rotaryEmbeddingDim > headSize) {\n    throw new Error('rotary_embedding_dim must be less than or equal to head_size');\n  }\n\n  if (positionIds.dims.length === 2) {\n    if (batchSize !== positionIds.dims[0]) {\n      throw new Error(`Input 'position_ids' dimension 0 should be of size batch_size, got ${positionIds.dims[0]}`);\n    }\n    if (sequenceLength !== positionIds.dims[1]) {\n      throw new Error(`Input 'position_ids' dimension 1 should be of size sequence_length, got ${positionIds.dims[1]}`);\n    }\n  }\n\n  if (headSize / 2 !== cosCache.dims[1] && rotaryEmbeddingDim / 2 !== cosCache.dims[1]) {\n    throw new Error(`Input 'cos_cache' dimension 1 should be same as head_size / 2 or rotary_embedding_dim / 2, got ${\n        cosCache.dims[1]}`);\n  }\n\n  if (sequenceLength > maxSequenceLength) {\n    throw new Error('Updating cos_cache and sin_cache in RotaryEmbedding is not currently supported');\n  }\n};\n\nconst createRotaryEmbeddingProgramInfo =\n    (inputs: readonly TensorView[], attributes: RotaryEmbeddingAttributes): ProgramInfo => {\n      const {interleaved, numHeads, rotaryEmbeddingDim, scale} = attributes;\n      const batchSize = inputs[0].dims[0];\n      const batchStride = ShapeUtil.sizeFromDimension(inputs[0].dims, 1);\n      const sequenceLength = inputs[0].dims[inputs[0].dims.length - 2];\n      const hiddenSize = batchStride / sequenceLength;\n      const halfRotaryEmbeddingDim = inputs[2].dims[1];\n      const headSize = rotaryEmbeddingDim === 0 ? halfRotaryEmbeddingDim * 2 : hiddenSize / numHeads;\n\n      // Rotary embeddings will be calculated in a pair-wise fashion. In accordance, use the shape\n      // [batch size, sequence length, num of heads, num of pairs to rotate + num of dims to copy]\n      // to unfold the global index in shader.\n      const globalShape =\n          new Array<number>(batchSize, sequenceLength, hiddenSize / headSize, headSize - halfRotaryEmbeddingDim);\n      const globalStrides = ShapeUtil.computeStrides(globalShape);\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.float, data: scale},\n        {type: DataType.uint32, data: globalShape},\n        {type: DataType.uint32, data: globalStrides},\n\n        // strides for addressing the input/output tensor, in permutated order to align with the unfolded global index,\n        // i.e. BSNH\n        ...(inputs[0].dims.length === 3 ?\n                new Array<ProgramUniform>({type: DataType.uint32, data: [batchStride, hiddenSize, headSize, 1]}) :\n                []),\n        ...(inputs[0].dims.length === 4 ?\n                new Array<ProgramUniform>(\n                    {type: DataType.uint32, data: [batchStride, headSize, sequenceLength * headSize, 1]}) :\n                []),\n\n        ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims, inputs[2].dims, inputs[3].dims, inputs[0].dims),\n      ];\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const input = inputVariable('input', inputs[0].dataType, inputs[0].dims.length);\n        const positionIds = inputVariable('position_ids', inputs[1].dataType, inputs[1].dims.length);\n        const cosCache = inputVariable('cos_cache', inputs[2].dataType, inputs[2].dims.length);\n        const sinCache = inputVariable('sin_cache', inputs[3].dataType, inputs[3].dims.length);\n        const output = outputVariable('output', inputs[0].dataType, inputs[0].dims.length);\n\n        shaderHelper.registerUniforms([\n          {name: 'scale', type: 'f32'},\n          {name: 'global_shape', type: 'u32', length: globalShape.length},\n          {name: 'global_strides', type: 'u32', length: globalStrides.length},\n          {name: 'input_output_strides', type: 'u32', length: globalStrides.length},\n        ]);\n\n        return `\n        ${shaderHelper.declareVariables(input, positionIds, cosCache, sinCache, output)}\n\n        ${shaderHelper.mainStart(WORKGROUP_SIZE)}\n          let half_rotary_emb_dim = uniforms.${cosCache.name}_shape[1];\n          let bsnh = global_idx / uniforms.global_strides % uniforms.global_shape;\n          let size = uniforms.global_shape[0] * uniforms.global_strides[0];\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('size')}\n\n          if (bsnh[3] < half_rotary_emb_dim) {\n            let position_ids_idx =\n                ${positionIds.broadcastedIndicesToOffset('bsnh.xy', outputVariable('', positionIds.type.tensor, 2))};\n            let position_id =\n                u32(${positionIds.getByOffset('position_ids_idx')}) + select(0, bsnh[1], position_ids_idx == 0);\n            let i = dot(bsnh, uniforms.input_output_strides) + select(0, bsnh[3], ${interleaved});\n            let j = i + select(half_rotary_emb_dim, 1, ${interleaved});\n            let re = ${input.getByOffset('i')} * ${cosCache.get('position_id', 'bsnh[3]')} -\n                ${input.getByOffset('j')} * ${sinCache.get('position_id', 'bsnh[3]')};\n            ${output.setByOffset('i', 're')}\n            let im = ${input.getByOffset('i')} * ${sinCache.get('position_id', 'bsnh[3]')} +\n                ${input.getByOffset('j')} * ${cosCache.get('position_id', 'bsnh[3]')};\n            ${output.setByOffset('j', 'im')}\n          } else {\n            let k = dot(bsnh, uniforms.input_output_strides) + half_rotary_emb_dim;\n            ${output.setByOffset('k', input.getByOffset('k'))}\n          }\n        }`;\n      };\n\n      return {\n        name: 'RotaryEmbedding',\n        shaderCache: {\n          hint: createAttributeWithCacheKey({\n                  interleaved,\n                }).cacheKey,\n          inputDependencies: ['rank', 'rank', 'rank', 'rank'],\n        },\n        getShaderSource,\n        getRunData: () => ({\n          outputs: [{dims: inputs[0].dims, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: Math.ceil(ShapeUtil.size(globalShape) / WORKGROUP_SIZE)},\n          programUniforms,\n        }),\n      };\n    };\n\nexport const rotaryEmbedding = (context: ComputeContext, attributes: RotaryEmbeddingAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  context.compute(createRotaryEmbeddingProgramInfo(context.inputs, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {castToF32, fillVector, getMaxComponents, inputVariable, outputVariable, ShaderHelper, sumVector, tensorTypeToWsglStorageType, UniformsArrayType} from './common';\n\nexport interface SkipLayerNormAttributes {\n  simplified: boolean;\n  epsilon: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length < 3) {\n    throw new Error('layerNorm requires at least 3 inputs.');\n  }\n\n  const input: TensorView = inputs[0];\n  const skip: TensorView = inputs[1];\n  const gamma: TensorView = inputs[2];\n\n  if (input.dataType !== skip.dataType || input.dataType !== gamma.dataType) {\n    throw new Error('All inputs must have the same data type');\n  }\n\n  if (input.dims.length !== 3 && input.dims.length !== 2) {\n    throw new Error('Input must be 2D or 3D');\n  }\n\n  if (skip.dims.length !== 3 && skip.dims.length !== 2) {\n    throw new Error('Skip must be 2D or 3D');\n  }\n\n  const hiddenSize = input.dims[input.dims.length - 1];\n  const sequenceLength = input.dims[input.dims.length - 2];\n  if (skip.dims[skip.dims.length - 1] !== hiddenSize) {\n    throw new Error('Skip must have the same hidden size as input');\n  }\n  if (skip.dims[skip.dims.length - 2] !== sequenceLength) {\n    throw new Error('Skip must have the same sequence length as input');\n  }\n\n  if (gamma.dims.length !== 1) {\n    throw new Error('Gamma must be 1D');\n  }\n  if (gamma.dims[gamma.dims.length - 1] !== hiddenSize) {\n    throw new Error('Gamma must have the same hidden size as input');\n  }\n  if (inputs.length > 3) {\n    const beta: TensorView = inputs[3];\n    if (beta.dims.length !== 1) {\n      throw new Error('Beta must be 1D');\n    }\n    if (beta.dims[beta.dims.length - 1] !== hiddenSize) {\n      throw new Error('Beta must have the same hidden size as input');\n    }\n  }\n\n  if (inputs.length > 4) {\n    const bias: TensorView = inputs[4];\n    if (bias.dims.length !== 1) {\n      throw new Error('Bias must be 1D');\n    }\n    if (bias.dims[bias.dims.length - 1] !== hiddenSize) {\n      throw new Error('Bias must have the same hidden size as input');\n    }\n  }\n};\n\nconst createSkipLayerNormProgramInfo =\n    (inputs: readonly TensorView[], attributes: SkipLayerNormAttributes, outputCount: number, isTraining: boolean):\n        ProgramInfo => {\n          const simplified = attributes.simplified;\n\n          const inputShape = inputs[0].dims;\n          const inputSize = ShapeUtil.size(inputShape);\n          const outputShape = inputShape;\n          const outputSize = inputSize;\n          const hiddenSize = inputShape.slice(-1)[0];\n          const meanInvStdDevDim = isTraining ? inputShape.slice(0, -1).concat(1) : [];\n          const hasBetaInput = !simplified && inputs.length > 3;\n          const hasBiasInput = inputs.length > 4;\n          const hasMeanOutput = isTraining && outputCount > 1;\n          const hasInvStdDevOutput = isTraining && outputCount > 2;\n          const hasInputSkipBiasSumOutput = outputCount > 3;\n\n          const components = getMaxComponents(hiddenSize);\n\n          const programUniforms: ProgramUniform[] = [\n            {type: DataType.uint32, data: outputSize},\n            {type: DataType.uint32, data: components},\n            {type: DataType.uint32, data: hiddenSize},\n            {type: DataType.float, data: attributes.epsilon},\n          ];\n          const getShaderSource = (shaderHelper: ShaderHelper) => {\n            const uniformsArray: UniformsArrayType = [\n              {name: 'output_size', type: 'u32'},\n              {name: 'components', type: 'u32'},\n              {name: 'hidden_size', type: 'u32'},\n              {name: 'epsilon', type: 'f32'},\n            ];\n            const variables = [\n              inputVariable('x', inputs[0].dataType, inputs[0].dims, components),\n              inputVariable('skip', inputs[1].dataType, inputs[1].dims, components),\n              inputVariable('gamma', inputs[2].dataType, inputs[2].dims, components),\n            ];\n            if (hasBetaInput) {\n              variables.push(inputVariable('beta', inputs[3].dataType, inputs[3].dims, components));\n            }\n            if (hasBiasInput) {\n              variables.push(inputVariable('bias', inputs[4].dataType, inputs[4].dims, components));\n            }\n            variables.push(outputVariable('output', inputs[0].dataType, outputShape, components));\n            if (hasMeanOutput) {\n              variables.push(outputVariable('mean_output', DataType.float, meanInvStdDevDim));\n            }\n            if (hasInvStdDevOutput) {\n              variables.push(outputVariable('inv_std_output', DataType.float, meanInvStdDevDim));\n            }\n            if (hasInputSkipBiasSumOutput) {\n              variables.push(outputVariable('input_skip_bias_sum', inputs[0].dataType, outputShape, components));\n            }\n            const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n            return `\n\n      ${shaderHelper.registerUniforms(uniformsArray).declareVariables(...variables)}\n\n      ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size / uniforms.hidden_size')}\n        let hidden_size_vectorized: u32 = uniforms.hidden_size / uniforms.components;\n        let offset = global_idx * hidden_size_vectorized;\n        var sum = ${fillVector('f32', components)};\n        var squareSum = ${fillVector('f32', components)};\n        for (var i: u32 = 0; i < hidden_size_vectorized; i++) {\n          let skip_value = skip[offset + i];\n          let bias_value = ${hasBiasInput ? 'bias[i]' : dataType + '(0.0)'};\n          let input_value = x[offset + i];\n          let value = input_value + skip_value + bias_value;\n          ${hasInputSkipBiasSumOutput ? 'input_skip_bias_sum[offset + i] = value;' : ''}\n          output[offset + i] = value;\n          let f32_value = ${castToF32(dataType, components, 'value')};\n          sum += f32_value;\n          squareSum += f32_value * f32_value;\n        }\n        let mean = ${sumVector('sum', components)} / f32(uniforms.hidden_size);\n        let inv_std_dev = inverseSqrt(${sumVector('squareSum', components)} / f32(uniforms.hidden_size) ${\n                simplified ? '' : '- mean * mean'} + uniforms.epsilon);\n        ${hasMeanOutput ? 'mean_output[global_idx] = mean;' : ''}\n        ${hasInvStdDevOutput ? 'inv_std_output[global_idx] = inv_std_dev;' : ''}\n        for (var i: u32 = 0; i < hidden_size_vectorized; i++) {\n          output[offset + i] = (output[offset + i] ${simplified ? '' : `- ${dataType}(mean)`}) * ${\n                dataType}(inv_std_dev) * gamma[i] ${hasBetaInput ? '+ beta[i]' : ''};\n        }\n      }`;\n          };\n          const outputs = [{dims: outputShape, dataType: inputs[0].dataType}];\n          if (outputCount > 1) {\n            outputs.push({dims: meanInvStdDevDim, dataType: DataType.float});\n          }\n          if (outputCount > 2) {\n            outputs.push({dims: meanInvStdDevDim, dataType: DataType.float});\n          }\n          if (outputCount > 3) {\n            outputs.push({dims: inputShape, dataType: inputs[0].dataType});\n          }\n          return {\n            name: 'SkipLayerNormalization',\n            shaderCache: {\n              hint: `${components};${hasMeanOutput};${hasInvStdDevOutput};${hasInputSkipBiasSumOutput}`,\n              inputDependencies: inputs.map((_input, _index) => 'type')\n            },\n            getShaderSource,\n            getRunData: () => ({outputs, dispatchGroup: {x: Math.ceil(outputSize / hiddenSize / 64)}, programUniforms}),\n          };\n        };\n\nexport const skipLayerNorm = (context: ComputeContext, attributes: SkipLayerNormAttributes): void => {\n  // TODO: initialize isTraining from ComputeContext\n  const isTraining = false;\n  validateInputs(context.inputs);\n  // Mean and InvStdDev are only used in training mode and are not required for inference.\n  // They are added here for completeness only.\n  const outputs = [0];\n  if (context.outputCount > 1) {\n    outputs.push(isTraining ? 1 : -3);\n  }\n  if (context.outputCount > 2) {\n    outputs.push(isTraining ? 2 : -3);\n  }\n  if (context.outputCount > 3) {\n    outputs.push(3);\n  }\n  context.compute(\n      createSkipLayerNormProgramInfo(context.inputs, attributes, context.outputCount, isTraining), {outputs});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform, TensorInfo} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, IndicesHelper, inputVariable, outputVariable, ShaderHelper, UniformsArrayType} from './common';\n\nexport interface SliceAttributes extends AttributeWithCacheKey {\n  readonly starts: number[];\n  readonly ends: number[];\n  readonly axes: number[];\n}\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: SliceAttributes): void => {\n  if (!inputs || inputs.length < 1) {\n    throw new Error('too few inputs');\n  }\n  if (attributes.axes.length !== 0) {\n    if (attributes.axes.length !== attributes.starts.length || attributes.axes.length !== attributes.ends.length) {\n      throw new Error('axes, starts and ends must have the same length');\n    }\n  } else if (attributes.starts.length !== attributes.ends.length) {\n    throw new Error('starts and ends must have the same length');\n  }\n  inputs.slice(1).forEach((_, idx) => {\n    if (inputs[idx + 1].dataType !== DataType.int32 && inputs[idx + 1].dataType !== DataType.int64) {\n      throw new Error(`Input ${idx} must be an array of int32 or int64`);\n    }\n  });\n};\n\nconst readInput = (inputs: readonly TensorView[], idx: number): number[] => {\n  const input: number[] = [];\n  if (inputs.length > idx) {\n    if (inputs[idx].dataType === DataType.int64) {\n      inputs[idx].getBigInt64Array().forEach(v => input.push(Number(v)));\n    } else if (inputs[idx].dataType === DataType.int32) {\n      inputs[idx].getInt32Array().forEach(v => input.push(Number(v)));\n    } else {\n      throw new Error(`Input ${idx} must be an array of int32 or int64`);\n    }\n  }\n  return input;\n};\n\nconst createSliceAttributesFromInputs =\n    (inputs: readonly TensorView[], attributes: SliceAttributes): SliceAttributes => {\n      if (inputs.length > 1) {\n        const starts: number[] = readInput(inputs, 1);\n        const ends: number[] = readInput(inputs, 2);\n        let axes: number[] = readInput(inputs, 3);\n        if (axes.length === 0) {\n          axes = [...Array(inputs[0].dims.length).keys()];\n        }\n        return createAttributeWithCacheKey({starts, ends, axes});\n      } else {\n        return attributes;\n      }\n    };\n\nconst fixStartEndValues =\n    (value: number, index: number, inputShape: readonly number[], axes: readonly number[], steps: readonly number[]):\n        number => {\n          let newValue = value;\n          if (value < 0) {\n            newValue += inputShape[axes[index]];\n          }\n          if (steps[index] < 0) {\n            return Math.max(0, Math.min(newValue, inputShape[axes[index]] - 1));\n          } else {\n            return Math.max(0, Math.min(newValue, inputShape[axes[index]]));\n          }\n        };\n\nconst calculateInputIndicesImpl =\n    (input: IndicesHelper, output: IndicesHelper, inputShape: readonly number[]): string =>\n        `fn calculateInputIndices(output_indices: ${output.type.indices}) -> ${input.type.indices} {\n          var input_indices: ${input.type.indices};\n          var carry = 0u;\n          for (var i = ${inputShape.length}; i >= 0; i--) {\n            let input_shape_i = ${getElementAt('uniforms.input_shape', 'i', inputShape.length)};\n            let steps_i = ${getElementAt('uniforms.steps', 'i', inputShape.length)};\n            let signs_i = ${getElementAt('uniforms.signs', 'i', inputShape.length)};\n            let starts_i = ${getElementAt('uniforms.starts', 'i', inputShape.length)};\n            var output_index = ${output.indicesGet('output_indices', 'i')};\n            var input_index = output_index * steps_i + starts_i + carry;\n            carry = input_index / input_shape_i;\n            input_index = input_index % input_shape_i;\n            if (signs_i < 0) {\n              input_index = input_shape_i - input_index - 1u + starts_i;\n            }\n            ${input.indicesSet('input_indices', 'i', 'input_index')};\n          }\n          return input_indices;\n      }`;\n\nconst createSliceProgramInfo = (inputs: readonly TensorView[], attributes: SliceAttributes): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const inputSize = ShapeUtil.size(inputShape);\n  const axes = (attributes.axes.length > 0) ? ShapeUtil.normalizeAxes(attributes.axes, inputShape.length) :\n                                              [...Array(inputShape.length).keys()];\n  let steps = readInput(inputs, 4);\n  steps.forEach((step) => step !== 0 || (() => {\n                            throw new Error('step cannot be 0');\n                          }));\n  if (steps.length === 0) {\n    steps = Array(axes.length).fill(1);\n  }\n  const starts = attributes.starts.map((start, i) => fixStartEndValues(start, i, inputShape, axes, steps));\n\n  const ends = attributes.ends.map((end, i) => fixStartEndValues(end, i, inputShape, axes, steps));\n\n  if (axes.length !== starts.length || axes.length !== ends.length) {\n    throw new Error('start, ends and axes should have the same number of elements');\n  }\n\n  if (axes.length !== inputShape.length) {\n    for (let i = 0; i < inputShape.length; ++i) {\n      if (!axes.includes(i)) {\n        starts.splice(i, 0, 0);\n        ends.splice(i, 0, inputShape[i]);\n        steps.splice(i, 0, 1);\n      }\n    }\n  }\n  const signs = steps.map(step => Math.sign(step));\n  // Convert negative steps to positive steps and reverse starts and ends\n  steps.forEach((step, i, array) => {\n    if (step < 0) {\n      const numSteps = (ends[i] - starts[i]) / step;\n      const newEnd = starts[i];\n      const newStart = newEnd + numSteps * steps[i];\n      starts[i] = newStart;\n      ends[i] = newEnd;\n      array[i] = -step;\n    }\n  });\n  // Output rank is expected to be less than or equal to the input rank.\n  const outputShape = inputShape.slice(0);\n  axes.forEach((axis, _) => {\n    outputShape[axis] = Math.ceil((ends[axis] - starts[axis]) / steps[axis]);\n  });\n  const outputTensorInfo: TensorInfo = {dims: outputShape, dataType: inputs[0].dataType};\n\n  const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n  const input = inputVariable('input', inputs[0].dataType, inputs[0].dims.length);\n  const outputSize = ShapeUtil.size(outputShape);\n  const uniforms: UniformsArrayType = [\n    {name: 'outputSize', type: 'u32'}, {name: 'starts', type: 'u32', length: starts.length},\n    {name: 'signs', type: 'i32', length: signs.length}, {name: 'steps', type: 'u32', length: steps.length}\n  ];\n\n  const programUniforms: ProgramUniform[] = [\n    {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: starts},\n    {type: DataType.int32, data: signs}, {type: DataType.uint32, data: steps},\n    ...createTensorShapeVariables(inputs[0].dims, outputShape)\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n      ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)}\n        ${calculateInputIndicesImpl(input, output, inputShape)}\n        ${shaderHelper.mainStart()}\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n          let output_indices = ${output.offsetToIndices('global_idx')};\n          let input_indices = calculateInputIndices(output_indices);\n          ${output.setByOffset('global_idx', input.getByIndices('input_indices'))}\n      }`;\n  return {\n    name: 'Slice',\n    shaderCache: {hint: `${signs.length}_${starts.length}_${steps.length}`, inputDependencies: ['rank']},\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [outputTensorInfo],\n      dispatchGroup: {x: Math.ceil(inputSize / 64 /* workgroup size */)},\n      programUniforms\n    })\n  };\n};\n\nexport const slice = (context: ComputeContext, attributes: SliceAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  const updatedAttributes = createSliceAttributesFromInputs(context.inputs, attributes);\n  context.compute(createSliceProgramInfo(context.inputs, updatedAttributes), {inputs: [0]});\n  // if (ShapeUtil.size(program.outputs[0].dims) > 0) {\n  //   context.compute(programInfoLoader, {inputs: [0]});\n  // } else {\n  //   // TODO: support empty output\n  //   throw new Error('slice: output size is 0');\n  // }\n};\n\nexport const parseSliceAttributes = (attributes: Record<string, unknown>): SliceAttributes => {\n  const starts = attributes.starts as number[];\n  const ends = attributes.ends as number[];\n  const axes = attributes.axes as number[];\n  return createAttributeWithCacheKey({starts, ends, axes});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// TODO: this is the same naive implementation we use for reduce that has\n// performance limitations when the reduced axis is long. Need to add\n// a optimized codepath for this.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {getMaxComponents, inputVariable, outputVariable, ShaderHelper, sumVector, tensorTypeToWsglStorageType} from './common';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Softmax op requires 1 input.');\n  }\n};\n\nexport interface SoftmaxAttributes extends AttributeWithCacheKey {\n  readonly axis: number;\n}\n\nconst createSoftmaxProgramInfo = (input: TensorView, attributes: SoftmaxAttributes): ProgramInfo => {\n  const shape = input.dims;\n  const outputSize = ShapeUtil.size(shape);\n  const WG = 64;\n  let axis = attributes.axis;\n  if (axis < 0) {\n    axis = shape.length + axis;\n  }\n  if (axis < shape.length - 1) {\n    throw new Error('softmax only supports last axis for now.');\n  }\n\n  const cols = shape[axis];\n  const rows = outputSize / cols;\n  const components = getMaxComponents(cols);\n  const packedCols = cols / components;\n\n  const maxVector = (name: string, components: number) => {\n    if (components === 4) {\n      return `max(max(${name}.x, ${name}.y), max(${name}.z, ${name}.w))`;\n    } else if (components === 2) {\n      return `max(${name}.x, ${name}.y)`;\n    } else if (components === 3) {\n      return `max(max(${name}.x, ${name}.y), ${name}.z)`;\n    }\n\n    return name;\n  };\n  const x = inputVariable('x', input.dataType, input.dims, components);\n  const output = outputVariable('result', input.dataType, input.dims, components);\n  const valueType = x.type.value;\n  // 6.2.4 in wgsl spec\n  const threadMaxDecl = tensorTypeToWsglStorageType(input.dataType) === 'f32' ?\n      `var threadMax = ${valueType}(-3.402823e+38f);` :\n      `var threadMax = ${valueType}(-65504.0h);`;\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n      var<workgroup> rowMaxShared : ${valueType};\n      var<workgroup> rowSumShared : ${valueType};\n      var<workgroup> threadShared : array<${valueType}, ${WG}>;\n\n      fn getValue(row: i32, col: i32, row_stride: i32) -> ${valueType} {\n        let index = row * row_stride + col;\n        return x[index];\n      }\n\n      fn setValue(row: i32, col: i32, row_stride: i32, value: ${valueType}) {\n        let index = row * row_stride + col;\n        result[index] = value;\n      }\n      ${shaderHelper.registerUniform('packedCols', 'i32').declareVariables(x, output)}\n      ${shaderHelper.mainStart()}\n        let gindex = i32(global_idx);\n        let lindex = i32(local_idx);\n        const wg = ${WG};\n        let row = gindex / wg;\n        let cols = uniforms.packedCols;\n        let row_stride : i32 = uniforms.packedCols;\n\n        // find the rows max\n        ${threadMaxDecl}\n        for (var col = lindex; col < cols; col += wg) {\n          let value = getValue(row, col, row_stride);\n          threadMax = max(threadMax, value);\n        }\n        if (lindex < cols) {\n          threadShared[lindex] = threadMax;\n        }\n        workgroupBarrier();\n\n        var reduceSize = min(cols, wg);\n        for (var currSize = reduceSize >> 1;  currSize > 0; currSize = reduceSize >> 1) {\n          reduceSize = currSize + (reduceSize & 1);\n          if (lindex < currSize) {\n            threadShared[lindex] = max(threadShared[lindex], threadShared[lindex + reduceSize]);\n          }\n          workgroupBarrier();\n        }\n        if (lindex == 0) {\n          rowMaxShared = ${valueType}(${maxVector('threadShared[0]', components)});\n        }\n        workgroupBarrier();\n\n        // find the rows sum\n        var threadSum = ${valueType}(0.0);\n        for (var col = lindex; col < cols; col += wg) {\n          let subExp = exp(getValue(row, col, row_stride) - rowMaxShared);\n          threadSum += subExp;\n        }\n        threadShared[lindex] = threadSum;\n        workgroupBarrier();\n\n        for (var currSize = wg >> 1;  currSize > 0; currSize = currSize >> 1) {\n          if (lindex < currSize) {\n            threadShared[lindex] = threadShared[lindex] + threadShared[lindex + currSize];\n          }\n          workgroupBarrier();\n        }\n        if (lindex == 0) {\n          rowSumShared = ${valueType}(${sumVector('threadShared[0]', components)});\n        }\n        workgroupBarrier();\n\n        // calculate final value for each element in the row\n        for (var col = lindex; col < cols; col += wg) {\n          let value = exp(getValue(row, col, row_stride) - rowMaxShared) / rowSumShared;\n          setValue(row, col, row_stride, value);\n        }\n      }`;\n  return {\n    name: 'Softmax',\n    shaderCache: {hint: `${components}`, inputDependencies: ['type']},\n    getRunData: () => ({\n      outputs: [{dims: shape, dataType: input.dataType}],\n      dispatchGroup: {x: rows},\n      programUniforms: [{type: DataType.int32, data: packedCols}]\n    }),\n    getShaderSource,\n  };\n};\n\nexport const softmax = (context: ComputeContext, attributes: SoftmaxAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createSoftmaxProgramInfo(context.inputs[0], attributes));\n};\n\nexport const parseSoftmaxAttributes = (attributes: Record<string, unknown>): SoftmaxAttributes =>\n    createAttributeWithCacheKey({axis: attributes.axis as number});\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform, TensorInfo} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface SplitAttributes extends AttributeWithCacheKey {\n  readonly axis: number;\n  readonly numOutputs: number;\n  readonly splitSizes: number[];\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length < 1) {\n    throw new Error('too few inputs');\n  }\n};\n\nconst createSplitAttributesFromInputs =\n    (inputs: readonly TensorView[], attributes: SplitAttributes): SplitAttributes => {\n      const splitSizes: number[] = [];\n      let numOutputs: number = attributes.numOutputs;\n      if (inputs[1].dims[0] > 0) {\n        inputs[1].getBigInt64Array().forEach(v => splitSizes.push(Number(v)));\n        numOutputs = splitSizes.length;\n      }\n      return createAttributeWithCacheKey({numOutputs, axis: attributes.axis, splitSizes});\n    };\n\nconst calculateOutputIndexImpl = (numberOfTensors: number): string => `\nfn calculateOutputIndex(index: u32) -> u32 {\n    for (var i: u32 = 0u; i < ${numberOfTensors}u; i += 1u ) {\n    if (index < ${getElementAt('uniforms.size_in_split_axis', 'i', numberOfTensors)}) {\n        return i;\n    }\n    }\n    return ${numberOfTensors}u;\n}`;\nconst writeBufferDataImpl = (outputs: readonly IndicesHelper[]) => {\n  const numberOfTensors = outputs.length;\n  const codeLines: string[] = [];\n  for (let i = 0; i < numberOfTensors; ++i) {\n    const returnSnippet = outputs[i].setByIndices('indices', 'input[global_idx]');\n    if (numberOfTensors === 1) {\n      codeLines.push(returnSnippet);\n    } else if (i === 0) {\n      codeLines.push(`if (output_number == ${i}u) { ${returnSnippet} }`);\n    } else if (i === numberOfTensors - 1) {\n      codeLines.push(`else { ${returnSnippet} }`);\n    } else {\n      codeLines.push(`else if (output_number == ${i}) { ${returnSnippet} }`);\n    }\n  }\n  return `\n      fn writeBufferData(output_number: u32, indices: ${outputs[0].type.indices}, global_idx: u32) {\n        ${codeLines.join('\\n')}\n      }`;\n};\n\nconst createSplitProgramInfo = (inputs: readonly TensorView[], attributes: SplitAttributes): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const inputSize = ShapeUtil.size(inputShape);\n  const dataType = inputs[0].dataType;\n  const axis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);\n  const outputs = new Array<IndicesHelper>(attributes.numOutputs);\n  const input = inputVariable('input', dataType, inputShape.length);\n  const sizeInSplitAxis = new Array<number>(attributes.numOutputs);\n  const outputsTensorInfo: TensorInfo[] = [];\n  const outputShapes: number[][] = [];\n  let previousSum = 0;\n  const programUniforms: ProgramUniform[] = [{type: DataType.uint32, data: inputSize}];\n  for (let i = 0; i < attributes.numOutputs; i++) {\n    previousSum += attributes.splitSizes[i];\n    sizeInSplitAxis[i] = previousSum;\n    const outputShape = inputShape.slice();\n    outputShape[attributes.axis] = attributes.splitSizes[i];\n    outputShapes.push(outputShape);\n    outputs[i] = outputVariable(`output${i}`, dataType, outputShape.length);\n    outputsTensorInfo.push({dims: outputShapes[i], dataType: inputs[0].dataType});\n  }\n  programUniforms.push(\n      {type: DataType.uint32, data: sizeInSplitAxis}, ...createTensorShapeVariables(inputShape, ...outputShapes));\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  ${\n      shaderHelper.registerUniform('input_size', 'u32')\n          .registerUniform('size_in_split_axis', 'u32', sizeInSplitAxis.length)\n          .declareVariables(input, ...outputs)}\n  ${calculateOutputIndexImpl(sizeInSplitAxis.length)}\n  ${writeBufferDataImpl(outputs)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.input_size')}\n\n    var indices = ${input.offsetToIndices('global_idx')};\n    var index = ${input.indicesGet('indices', axis)};\n    let output_number = calculateOutputIndex(index);\n    if (output_number != 0) {\n      index -= ${getElementAt('uniforms.size_in_split_axis', 'output_number - 1u', sizeInSplitAxis.length)};\n      ${input.indicesSet('indices', axis, 'index')};\n    }\n    writeBufferData(output_number, indices, global_idx);\n  }`;\n  return {\n    name: 'Split',\n    shaderCache: {hint: attributes.cacheKey, inputDependencies: ['rank']},\n    getShaderSource,\n    getRunData: () => ({\n      outputs: outputsTensorInfo,\n      dispatchGroup: {x: Math.ceil(inputSize / 64 /* workgroup size */)},\n      programUniforms\n    })\n  };\n};\n\nexport const split = (context: ComputeContext, attributes: SplitAttributes): void => {\n  validateInputs(context.inputs);\n  const updatedAttributes =\n      context.inputs.length === 1 ? attributes : createSplitAttributesFromInputs(context.inputs, attributes);\n  context.compute(createSplitProgramInfo(context.inputs, updatedAttributes), {inputs: [0]});\n};\n\nexport const parseSplitAttributes = (attributes: Record<string, unknown>): SplitAttributes => {\n  const axis = attributes.axis as number;\n  const splitSizes: number[] = attributes.splitSizes as number[];\n  const numOutputs = attributes.numOutputs as number < 0 ? splitSizes.length : attributes.numOutputs as number;\n  if (numOutputs !== splitSizes.length) {\n    throw new Error('numOutputs and splitSizes lengh must be equal');\n  }\n  return createAttributeWithCacheKey({axis, numOutputs, splitSizes});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nconst getRepeats = (repeatsTensorView: TensorView): readonly number[] =>\n    Array.from(repeatsTensorView.getBigInt64Array(), Number);\n\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('Tile requires 2 inputs.');\n  }\n\n  if (inputs[0].dataType !== DataType.float && inputs[0].dataType !== DataType.int32 &&\n      inputs[0].dataType !== DataType.uint32) {\n    throw new Error('Tile only support float, int32, and uint32 data types');\n  }\n\n  if (inputs[1].dataType !== DataType.int64) {\n    throw new Error('Tile `repeats` input should be of int64 data type');\n  }\n\n  if (inputs[1].dims.length !== 1) {\n    throw new Error('Tile `repeats` input should be 1-D');\n  }\n\n  const repeats: readonly number[] = getRepeats(inputs[1]);\n\n  if (repeats.length !== inputs[0].dims.length) {\n    throw new Error('Tile `repeats` input should have same number of elements as rank of input data tensor');\n  }\n};\n\nconst getOutputShape = (inputShape: readonly number[], repeats: readonly number[]): readonly number[] => {\n  const outputShape: number[] = [];\n\n  for (let i = 0; i < inputShape.length; ++i) {\n    outputShape.push(inputShape[i] * repeats[i]);\n  }\n\n  return outputShape;\n};\n\nexport const createTileProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const repeats: readonly number[] = getRepeats(inputs[1]);\n  const outputShape = getOutputShape(inputShape, repeats);\n  const outputSize = ShapeUtil.size(outputShape);\n\n  const dataType = inputs[0].dataType;\n  const input = inputVariable('input', dataType, inputShape.length);\n  const output = outputVariable('output', dataType, outputShape.length);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n      const inputShape = ${input.indices(...inputShape)};\n      ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(input, output)}\n      ${shaderHelper.mainStart()}\n      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n      let output_indices = ${output.offsetToIndices('global_idx')};\n      var input_indices: ${input.type.indices};\n      for (var i = 0; i < ${inputShape.length}; i++) {\n        let input_dim_i = ${input.indicesGet('uniforms.input_shape', 'i')};\n        let input_dim_value = ${output.indicesGet('output_indices', 'i')}  % input_dim_i;\n\n        ${input.indicesSet('input_indices', 'i', 'input_dim_value')}\n      }\n      ${output.setByOffset('global_idx', input.getByIndices('input_indices'))}\n    }`;\n\n  return {\n    name: 'Tile',\n    shaderCache: {hint: `${repeats}`, inputDependencies: ['rank']},\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n      programUniforms:\n          [{type: DataType.uint32, data: outputSize}, ...createTensorShapeVariables(inputs[0].dims, outputShape)],\n    }),\n    getShaderSource,\n  };\n};\n\nexport const tile = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  context.compute(createTileProgramInfo(context.inputs), {inputs: [0]});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {BroadcastUtil, ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nconst createWhereOpProgramShader =\n    (shaderHelper: ShaderHelper, inputs: readonly TensorView[], dimsOutput: readonly number[], isBroadcast: boolean,\n     typeOutput: number) => {\n      const output = outputVariable('output_data', typeOutput, dimsOutput.length, 4);\n      const a = inputVariable('a_data', inputs[1].dataType, inputs[1].dims.length, 4);\n      const b = inputVariable('b_data', inputs[2].dataType, inputs[2].dims.length, 4);\n      const c = inputVariable('c_data', inputs[0].dataType, inputs[0].dims.length, 4);\n\n      let assignment: string;\n      const expression = (a: string, b: string, c: string) => `select(${b}, ${a}, ${c})`;\n      if (!isBroadcast) {\n        assignment = output.setByOffset(\n            'global_idx',\n            expression(a.getByOffset('global_idx'), b.getByOffset('global_idx'), c.getByOffset('global_idx')));\n      } else {\n        const singleAssignment = (resStr: string, x: number, typeCast = '') => {\n          const expressionA = `a_data[index_a${x}][component_a${x}]`;\n          const expressionB = `b_data[index_b${x}][component_b${x}]`;\n          // eslint-disable-next-line no-bitwise\n          const expressionC = `bool(c_data[index_c${x}] & (0xffu << (component_c${x} * 8)))`;\n          return `\n            let output_indices${x} = ${output.offsetToIndices(`global_idx * 4u + ${x}u`)};\n            let offset_a${x} = ${a.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n            let offset_b${x} = ${b.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n            let offset_c${x} = ${c.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n            let index_a${x} = offset_a${x} / 4u;\n            let index_b${x} = offset_b${x} / 4u;\n            let index_c${x} = offset_c${x} / 4u;\n            let component_a${x} = offset_a${x} % 4u;\n            let component_b${x} = offset_b${x} % 4u;\n            let component_c${x} = offset_c${x} % 4u;\n            ${resStr}[${x}] = ${typeCast}(${expression(expressionA, expressionB, expressionC)});\n          `;\n        };\n        if (typeOutput === DataType.bool) {\n          assignment = `\n            var data = vec4<u32>(0);\n            ${singleAssignment('data', 0, 'u32')}\n            ${singleAssignment('data', 1, 'u32')}\n            ${singleAssignment('data', 2, 'u32')}\n            ${singleAssignment('data', 3, 'u32')}\n            output_data[global_idx] = dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(data));`;\n        } else {\n          assignment = `\n            ${singleAssignment('output_data[global_idx]', 0)}\n            ${singleAssignment('output_data[global_idx]', 1)}\n            ${singleAssignment('output_data[global_idx]', 2)}\n            ${singleAssignment('output_data[global_idx]', 3)}\n          `;\n        }\n      }\n\n      return `\n        ${shaderHelper.registerUniform('vec_size', 'u32').declareVariables(c, a, b, output)}\n        ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.vec_size')}\n        ${assignment}\n      }`;\n    };\n\nconst createWhereOpProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const dimsA = inputs[1].dims;\n  const dimsB = inputs[2].dims;\n  const dimsC = inputs[0].dims;\n  const outputDataType = inputs[1].dataType;\n\n  const isBroadcast = !(ShapeUtil.areEqual(dimsA, dimsB) && ShapeUtil.areEqual(dimsB, dimsC));\n  let outputShape = dimsA;\n  let outputSize = ShapeUtil.size(dimsA);\n  // TODO: deal with zero-sized tensors (eg. dims=[1,0])\n\n  if (isBroadcast) {\n    const calculatedShape = BroadcastUtil.calcShape(BroadcastUtil.calcShape(dimsA, dimsB, false)!, dimsC, false);\n    if (!calculatedShape) {\n      throw new Error('Can\\'t perform where op on the given tensors');\n    }\n    outputShape = calculatedShape;\n    outputSize = ShapeUtil.size(outputShape);\n  }\n\n  const vecSize = Math.ceil(outputSize / 4);\n\n  return {\n    name: 'Where',\n    shaderCache: {inputDependencies: ['rank', 'rank', 'rank']},\n    getShaderSource: (shaderHelper) =>\n        createWhereOpProgramShader(shaderHelper, inputs, outputShape, isBroadcast, outputDataType),\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: outputDataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */ / 4 /* vec size */)},\n      programUniforms:\n          [{type: DataType.uint32, data: vecSize}, ...createTensorShapeVariables(dimsC, dimsA, dimsB, outputShape)],\n    }),\n  };\n};\n\nexport const where = (context: ComputeContext): void => {\n  context.compute(createWhereOpProgramInfo(context.inputs));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {argMax, argMin, parseArgMinMaxAttributes} from './ops/argminmax';\nimport {attention} from './ops/attention';\nimport {batchNorm} from './ops/batch-norm';\nimport {biasAdd} from './ops/bias-add';\nimport {biasSplitGelu} from './ops/bias-split-gelu';\nimport * as binaryOps from './ops/binary-op';\nimport {concat, parseConcatAttributes} from './ops/concat';\nimport {conv, parseConvAttributes} from './ops/conv';\nimport {convTranspose, parseConvTransposeAttributes} from './ops/conv-transpose';\nimport {cumsum, parseCumSumAttributes} from './ops/cumsum';\nimport {depthToSpace, parseDepthToSpaceAttributes} from './ops/depth-to-space';\nimport {einsum, parseEinsumAttributes} from './ops/einsum';\nimport {expand} from './ops/expand';\nimport {fastGelu} from './ops/fast-gelu';\nimport {gather, parseGatherAttributes} from './ops/gather';\nimport {gatherElements, parseGatherElementsAttributes} from './ops/gather-elements';\nimport {gemm, parseGemmAttributes} from './ops/gemm';\nimport {instanceNorm} from './ops/instance-norm';\nimport {layerNorm} from './ops/layer-norm';\nimport {matMul} from './ops/matmul';\nimport {matMulNBits, parseMatMulNBitsAttributes} from './ops/matmulnbits';\nimport {multiHeadAttention, parseMultiHeadAttentionAttributes} from './ops/multihead-attentiion';\nimport {pad} from './ops/pad';\nimport * as pool from './ops/pool';\nimport {range} from './ops/range';\nimport {reduceL1, reduceL2, reduceLogSum, reduceLogSumExp, reduceMax, reduceMean, reduceMin, reduceProd, reduceSum, reduceSumSquare} from './ops/reduce';\nimport {parseResizeAttributes, resize} from './ops/resize';\nimport {rotaryEmbedding} from './ops/rotary-embedding';\nimport {skipLayerNorm} from './ops/skip-layer-norm';\nimport {parseSliceAttributes, slice} from './ops/slice';\nimport {parseSoftmaxAttributes, softmax} from './ops/softmax';\nimport {parseSplitAttributes, split} from './ops/split';\nimport {tile} from './ops/tile';\nimport {parseTransposeAttributes, transpose} from './ops/transpose';\nimport * as unaryOps from './ops/unary-op';\nimport {where} from './ops/where';\nimport {ComputeContext} from './types';\n\nexport type RunFunction = (context: ComputeContext, attribute?: unknown) => void;\nexport type ParseAttributeFunction = (attributeRaw: unknown) => unknown;\nexport type OperatorImplementation = [RunFunction]|[RunFunction, ParseAttributeFunction];\n\nexport const WEBGPU_OP_RESOLVE_RULES: Map<string, OperatorImplementation> = new Map([\n  ['Abs', [unaryOps.abs]],\n  ['Acos', [unaryOps.acos]],\n  ['Acosh', [unaryOps.acosh]],\n  ['Add', [binaryOps.add]],\n  ['ArgMax', [argMax, parseArgMinMaxAttributes]],\n  ['ArgMin', [argMin, parseArgMinMaxAttributes]],\n  ['Asin', [unaryOps.asin]],\n  ['Asinh', [unaryOps.asinh]],\n  ['Atan', [unaryOps.atan]],\n  ['Atanh', [unaryOps.atanh]],\n  ['Attention', [attention]],\n  // TODO: support new attributes for AveragePool-10\n  ['AveragePool', [pool.averagePool, pool.parseAveragePoolAttributes]],\n  ['BatchNormalization', [batchNorm]],\n  ['BiasAdd', [biasAdd]],\n  ['BiasSplitGelu', [biasSplitGelu]],\n  ['Cast', [unaryOps.cast, unaryOps.parseCastAttributes]],\n  ['Ceil', [unaryOps.ceil]],\n  ['Clip', [unaryOps.clip]],\n  ['Concat', [concat, parseConcatAttributes]],\n  ['Conv', [conv, parseConvAttributes]],\n  ['ConvTranspose', [convTranspose, parseConvTransposeAttributes]],\n  ['Cos', [unaryOps.cos]],\n  ['Cosh', [unaryOps.cosh]],\n  ['CumSum', [cumsum, parseCumSumAttributes]],\n  ['DepthToSpace', [depthToSpace, parseDepthToSpaceAttributes]],\n  ['Div', [binaryOps.div]],\n  ['Einsum', [einsum, parseEinsumAttributes]],\n  ['Elu', [unaryOps.elu, unaryOps.parseAlphaAttributes]],\n  ['Equal', [binaryOps.equal]],\n  ['Erf', [unaryOps.erf]],\n  ['Exp', [unaryOps.exp]],\n  ['Expand', [expand]],\n  ['FastGelu', [fastGelu]],\n  ['Floor', [unaryOps.floor]],\n  ['FusedConv', [conv, parseConvAttributes]],\n  ['Gather', [gather, parseGatherAttributes]],\n  ['GatherElements', [gatherElements, parseGatherElementsAttributes]],\n  ['Gelu', [unaryOps.gelu]],\n  ['Gemm', [gemm, parseGemmAttributes]],\n  ['GlobalAveragePool', [pool.globalAveragePool, pool.parseGlobalAveragePoolAttributes]],\n  ['GlobalMaxPool', [pool.globalMaxPool, pool.parseGlobalMaxPoolAttributes]],\n  ['Greater', [binaryOps.greater]],\n  ['GreaterOrEqual', [binaryOps.greaterOrEqual]],\n  ['HardSigmoid', [unaryOps.hardSigmoid, unaryOps.parseHardSigmoidAttributes]],\n  ['InstanceNormalization', [instanceNorm]],\n  ['LayerNormalization', [layerNorm]],\n  ['LeakyRelu', [unaryOps.leakyRelu, unaryOps.parseAlphaAttributes]],\n  ['Less', [binaryOps.less]],\n  ['LessOrEqual', [binaryOps.lessOrEqual]],\n  ['Log', [unaryOps.log]],\n  ['MatMul', [matMul]],\n  ['MatMulNBits', [matMulNBits, parseMatMulNBitsAttributes]],\n  // TODO: support new attributes for MaxPool-8 and MaxPool-10\n  ['MaxPool', [pool.maxPool, pool.parseMaxPoolAttributes]],\n  ['Mul', [binaryOps.mul]],\n  ['MultiHeadAttention', [multiHeadAttention, parseMultiHeadAttentionAttributes]],\n  ['Neg', [unaryOps.neg]],\n  ['Not', [unaryOps.not]],\n  ['Pad', [pad]],\n  ['Pow', [binaryOps.pow]],\n  ['Range', [range]],\n  ['Reciprocal', [unaryOps.reciprocal]],\n  ['ReduceMin', [reduceMin]],\n  ['ReduceMean', [reduceMean]],\n  ['ReduceMax', [reduceMax]],\n  ['ReduceSum', [reduceSum]],\n  ['ReduceProd', [reduceProd]],\n  ['ReduceL1', [reduceL1]],\n  ['ReduceL2', [reduceL2]],\n  ['ReduceLogSum', [reduceLogSum]],\n  ['ReduceLogSumExp', [reduceLogSumExp]],\n  ['ReduceSumSquare', [reduceSumSquare]],\n  ['Relu', [unaryOps.relu]],\n  ['Resize', [resize, parseResizeAttributes]],\n  ['RotaryEmbedding', [rotaryEmbedding]],\n  ['Sigmoid', [unaryOps.sigmoid]],\n  ['Sin', [unaryOps.sin]],\n  ['Sinh', [unaryOps.sinh]],\n  ['Slice', [slice, parseSliceAttributes]],\n  ['SkipLayerNormalization', [skipLayerNorm]],\n  ['Split', [split, parseSplitAttributes]],\n  ['Sqrt', [unaryOps.sqrt]],\n  ['Softmax', [softmax, parseSoftmaxAttributes]],\n  ['Sub', [binaryOps.sub]],\n  ['Tan', [unaryOps.tan]],\n  ['Tanh', [unaryOps.tanh]],\n  ['ThresholdedRelu', [unaryOps.thresholdedRelu, unaryOps.parseAlphaAttributes]],\n  ['Tile', [tile]],\n  ['Transpose', [transpose, parseTransposeAttributes]],\n  ['Where', [where]],\n]);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TRACE_FUNC_BEGIN, TRACE_FUNC_END} from 'onnxruntime-common';\n\nimport {WebGpuBackend} from '../backend-webgpu';\nimport {LOG_DEBUG} from '../log';\n\nimport {createShaderHelper} from './ops/common';\nimport {Artifact, GpuData, ProgramInfo} from './types';\n\n/**\n * ProgramManager is the main class behind running computations\n * It builds ProgramInfo's into Artifacts\n * It compiles given ProgramInfo's into WebGL Prorams (cached as Artifacts)\n * Uses the artifact to run the computation by calling Draw on\n * the WebGL drawing buffer\n * ProgramManager automatically maps (binds) input variables to their\n * corresponding Location's in the binary program\n */\nexport class ProgramManager {\n  repo: Map<unknown, Artifact>;  // this should be per-session object\n  attributesBound: boolean;\n\n  constructor(private backend: WebGpuBackend) {\n    this.repo = new Map();\n    this.attributesBound = false;\n  }\n  getArtifact(key: unknown): Artifact|undefined {\n    return this.repo.get(key);\n  }\n  setArtifact(key: unknown, artifact: Artifact): void {\n    this.repo.set(key, artifact);\n  }\n  run(buildArtifact: Artifact, inputs: GpuData[], outputs: GpuData[], dispatchGroup: [number, number, number],\n      uniformBufferBinding: GPUBindingResource|undefined): void {\n    TRACE_FUNC_BEGIN(buildArtifact.programInfo.name);\n    const device = this.backend.device;\n    const computePassEncoder = this.backend.getComputePassEncoder();\n    this.backend.writeTimestamp(this.backend.pendingDispatchNumber * 2);\n    const entries = [];\n    for (const input of inputs) {\n      entries.push({binding: entries.length, resource: {buffer: input.buffer}});\n    }\n    for (const output of outputs) {\n      entries.push({binding: entries.length, resource: {buffer: output.buffer}});\n    }\n    if (uniformBufferBinding) {\n      entries.push({binding: entries.length, resource: uniformBufferBinding});\n    }\n    const bindGroup = device.createBindGroup(\n        {layout: buildArtifact.computePipeline.getBindGroupLayout(0), entries, label: buildArtifact.programInfo.name});\n\n    if (this.backend.sessionStatus === 'capturing') {\n      const commandInfo = {\n        kernelId: this.backend.currentKernelId!,\n        computePipeline: buildArtifact.computePipeline,\n        bindGroup,\n        dispatchGroup\n      };\n      const sessionCommandList = this.backend.capturedCommandList.get(this.backend.currentSessionId!);\n      sessionCommandList!.push(commandInfo);\n    }\n\n    computePassEncoder.setPipeline(buildArtifact.computePipeline);\n    computePassEncoder.setBindGroup(0, bindGroup);\n    computePassEncoder.dispatchWorkgroups(...dispatchGroup);\n    this.backend.writeTimestamp(this.backend.pendingDispatchNumber * 2 + 1);\n    this.backend.pendingDispatchNumber++;\n\n    if (this.backend.pendingDispatchNumber >= this.backend.maxDispatchNumber ||\n        this.backend.queryType === 'at-passes') {\n      this.backend.endComputePass();\n    }\n    if (this.backend.pendingDispatchNumber >= this.backend.maxDispatchNumber) {\n      this.backend.flush();\n    }\n    TRACE_FUNC_END(buildArtifact.programInfo.name);\n  }\n  dispose(): void {\n    // this.repo.forEach(a => this.glContext.deleteProgram(a.program));\n  }\n  build(programInfo: ProgramInfo, normalizedDispatchGroupSize: [number, number, number]): Artifact {\n    TRACE_FUNC_BEGIN(programInfo.name);\n    const device = this.backend.device;\n    const extensions: string[] = [];\n    if (device.features.has('shader-f16')) {\n      extensions.push('enable f16;');\n    }\n    const shaderHelper = createShaderHelper(normalizedDispatchGroupSize, this.backend.device.limits);\n    const userCode = programInfo.getShaderSource(shaderHelper);\n    const code = `${extensions.join('\\n')}\\n${shaderHelper.additionalImplementations}\\n${userCode}`;\n    const shaderModule = device.createShaderModule({code, label: programInfo.name});\n    LOG_DEBUG('verbose', () => `[WebGPU] ${programInfo.name} shader code: ${code}`);\n\n    const computePipeline = device.createComputePipeline(\n        {compute: {module: shaderModule, entryPoint: 'main'}, layout: 'auto', label: programInfo.name});\n\n    TRACE_FUNC_END(programInfo.name);\n    return {programInfo, computePipeline, uniformVariablesInfo: shaderHelper.variablesInfo};\n  }\n\n  normalizeDispatchGroupSize(dispatchGroup: ReturnType<ProgramInfo['getRunData']>['dispatchGroup']):\n      [number, number, number] {\n    const x = typeof dispatchGroup === 'number' ? dispatchGroup : dispatchGroup.x;\n    const y = typeof dispatchGroup === 'number' ? 1 : (dispatchGroup.y || 1);\n    const z = typeof dispatchGroup === 'number' ? 1 : (dispatchGroup.z || 1);\n    const limitPerDimension = this.backend.device.limits.maxComputeWorkgroupsPerDimension;\n    if (x <= limitPerDimension && y <= limitPerDimension && z <= limitPerDimension) {\n      return [x, y, z];\n    }\n    const size = x * y * z;\n    let dispatchAverage = Math.ceil(Math.sqrt(size));\n    if (dispatchAverage > limitPerDimension) {\n      dispatchAverage = Math.ceil(Math.cbrt(size));\n      if (dispatchAverage > limitPerDimension) {\n        throw new Error('Total dispatch size exceeds WebGPU maximum.');\n      }\n      return [dispatchAverage, dispatchAverage, dispatchAverage];\n    } else {\n      return [dispatchAverage, dispatchAverage, 1];\n    }\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Env, Tensor, TRACE, TRACE_FUNC_BEGIN, TRACE_FUNC_END} from 'onnxruntime-common';\n\nimport {DataType, tensorDataTypeEnumToString} from '../wasm-common';\n\nimport {configureLogger, LOG_DEBUG} from './log';\nimport {createView, TensorView} from './tensor-view';\nimport {createGpuDataManager, downloadGpuData, GpuDataManager} from './webgpu/gpu-data-manager';\nimport {RunFunction, WEBGPU_OP_RESOLVE_RULES} from './webgpu/op-resolve-rules';\nimport {ProgramManager} from './webgpu/program-manager';\nimport {AdapterInfo, ComputeContext, GpuArchitecture, GpuData, GpuVendor, ProgramInfo, ProgramInputTensorInfoDependency, SessionState, TimestampQuery} from './webgpu/types';\n\ninterface CommandInfo {\n  readonly kernelId: number;\n  readonly computePipeline: GPUComputePipeline;\n  readonly bindGroup: GPUBindGroup;\n  readonly dispatchGroup: [number, number, number];\n}\n\ninterface KernelInfo {\n  readonly kernelType: string;\n  readonly kernelName: string;\n  readonly kernelEntry: RunFunction;\n  readonly attributes: [((attribute: unknown) => unknown)|undefined, unknown];\n}\n\ninterface PendingKernelInfo {\n  readonly kernelId: number;\n  readonly programName: string;\n  readonly inputTensorViews: readonly TensorView[];\n  readonly outputTensorViews: readonly TensorView[];\n}\n\nconst getProgramInputTensorInfoDependencyKey =\n    (inputTensors: readonly TensorView[], inputDependencies: readonly ProgramInputTensorInfoDependency[]): string => {\n      if (inputDependencies.length !== inputTensors.length) {\n        throw new Error(`inputDependencies length ${inputDependencies.length} is not equal to inputTensors length ${\n            inputTensors.length}.`);\n      }\n\n      const inputInfos: string[] = [];\n      for (let i = 0; i < inputTensors.length; ++i) {\n        const type = inputTensors[i].dataType;\n        switch (inputDependencies[i]) {\n          case 'none': {\n            inputInfos.push('');\n            break;\n          }\n          case 'type': {\n            inputInfos.push(`${type}`);\n            break;\n          }\n          case 'rank': {\n            const rank = inputTensors[i].dims.length;\n            inputInfos.push(`${type};${rank}`);\n            break;\n          }\n          case 'dims': {\n            const dims = inputTensors[i].dims.join(',');\n            inputInfos.push(`${type};${dims}`);\n            break;\n          }\n          default:\n            throw new Error(`unsupported input dependency: ${inputDependencies[i]}`);\n        }\n      }\n\n      return inputInfos.join('|');\n    };\n\n/**\n * get a unique key representing the program from the program info, input shapes and types.\n *\n * @returns a unique key is a shorter string than the shader source, which contains all the information to identify a\n * program. if the key is the same, the program shader source should be the same, so we can reuse the program.\n *\n */\nconst getProgramInfoUniqueKey =\n    (programInfo: ProgramInfo, inputTensors: readonly TensorView[], is1DimensionDispatch: boolean): string => {\n      // final key format:\n      // <PROGRAM_NAME>[<PROGRAM_CUSTOM_CACHE_HINT>]:is1DimensionDispatch:<INPUTS_INFO_0>|<INPUTS_INFO_1>|...\n      let key = programInfo.name;\n      if (programInfo.shaderCache?.hint) {\n        key += '[' + programInfo.shaderCache.hint + ']';\n      }\n      key += ':' + is1DimensionDispatch +\n          `:${\n                 getProgramInputTensorInfoDependencyKey(\n                     inputTensors,\n                     programInfo.shaderCache?.inputDependencies ??\n                         new Array<ProgramInputTensorInfoDependency>(inputTensors.length).fill('dims'))}`;\n      return key;\n    };\n\nclass AdapterInfoImpl implements AdapterInfo {\n  readonly architecture?: string;\n  readonly vendor?: string;\n\n  constructor(adapterInfo: GPUAdapterInfo) {\n    if (adapterInfo) {\n      this.architecture = adapterInfo.architecture;\n      this.vendor = adapterInfo.vendor;\n    }\n  }\n\n  isArchitecture(architecture: GpuArchitecture): boolean {\n    return this.architecture === architecture;\n  }\n\n  isVendor(vendor: GpuVendor): boolean {\n    return this.vendor === vendor;\n  }\n}\n\n/**\n * this class is designed to store status and being used as a singleton for JSEP. It will be passed to jsepInit() as\n * the first parameter so that it is stored for future use.\n */\nexport class WebGpuBackend {\n  adapterInfo: AdapterInfoImpl;\n  device: GPUDevice;\n  /**\n   * an instance of GpuDataManager to manage a GpuDataId -> GpuBuffer mapping\n   */\n  gpuDataManager: GpuDataManager;\n  /**\n   * an instance of ProgramManager to build and run WebGPU compute shader program, and manage a ProgramKey -> Program\n   * artifacts mapping\n   */\n  programManager: ProgramManager;\n\n  /**\n   * representing the session ID of which is currently being run.\n   * `null` means no session is being run.\n   * only valid when session.run is executed.\n   */\n  currentSessionId: number|null = null;\n\n  /**\n   * representing the kernel ID of which is currently being computed (CPU code perspective).\n   * `null` means no kernel is being computed.\n   * only one kernel can be computed at a moment.\n   */\n  currentKernelId: number|null = null;\n  /**\n   * a list of temporary GPU data for the current kernel. should release when the kernel done computation.\n   */\n  private temporaryData: GpuData[];\n  /**\n   * a KernelID -> a GPU data list, which stores persistent GPU data owned by the specific kernel.\n   */\n  private kernelPersistentData: Map<number, GpuData[]>;\n  /**\n   * a KernelID -> a custom data, which stores custom data owned by the specific kernel.\n   */\n  private kernelCustomData: Map<number, {[key: string]: unknown}>;\n  /**\n   * get the custom data of the current kernel\n   */\n  get currentKernelCustomData(): {[key: string]: unknown} {\n    if (this.currentKernelId === null) {\n      throw new Error('currentKernelCustomData(): currentKernelId is null. (should not happen)');\n    }\n\n    let data = this.kernelCustomData.get(this.currentKernelId);\n    if (!data) {\n      data = {};\n      this.kernelCustomData.set(this.currentKernelId, data);\n    }\n\n    return data;\n  }\n\n  // KernelID -> kernelInfo mapping\n  kernels: Map<number, KernelInfo>;\n  private commandEncoder: GPUCommandEncoder|null = null;\n  private computePassEncoder: GPUComputePassEncoder|null = null;\n  maxDispatchNumber = 16;\n  pendingDispatchNumber = 0;\n\n  // info of kernels pending submission for a single batch\n  private pendingKernels: PendingKernelInfo[] = [];\n  // queryReadBuffer -> pendingKernels mapping for all the batches\n  private pendingQueries: Map<GPUBuffer, PendingKernelInfo[]> = new Map();\n  private queryResolveBuffer?: GPUBuffer;\n  private querySet?: GPUQuerySet;\n  private queryTimeBase?: bigint;\n  queryType: TimestampQuery;\n\n  env: Env;\n  sessionStatus: SessionState = 'default';\n  /**\n   * a SessionID -> CommandInfo[] mapping. It's used to record all GPU commands for corresponding session.\n   */\n  capturedCommandList: Map<number, CommandInfo[]> = new Map();\n\n  /**\n   * a SessionID -> PendingKernelInfo[] mapping for profiling.\n   */\n  private capturedPendingKernels: Map<number, PendingKernelInfo[]> = new Map();\n\n  /**\n   * a SessionID -> a Map of (InputOutputIndex -> [ID, GPUBuffer]) mapping.\n   */\n  sessionExternalDataMapping: Map<number, Map<number, [number, GPUBuffer]>> = new Map();\n\n  async initialize(env: Env, adapter: GPUAdapter): Promise<void> {\n    this.env = env;\n    const requiredFeatures: GPUFeatureName[] = [];\n    const deviceDescriptor: GPUDeviceDescriptor = {\n      requiredLimits: {\n        maxComputeWorkgroupStorageSize: adapter.limits.maxComputeWorkgroupStorageSize,\n        maxComputeWorkgroupsPerDimension: adapter.limits.maxComputeWorkgroupsPerDimension,\n        maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,\n        maxBufferSize: adapter.limits.maxBufferSize,\n        maxComputeInvocationsPerWorkgroup: adapter.limits.maxComputeInvocationsPerWorkgroup,\n        maxComputeWorkgroupSizeX: adapter.limits.maxComputeWorkgroupSizeX,\n        maxComputeWorkgroupSizeY: adapter.limits.maxComputeWorkgroupSizeY,\n        maxComputeWorkgroupSizeZ: adapter.limits.maxComputeWorkgroupSizeZ,\n      },\n      requiredFeatures,\n    };\n\n    if (adapter.features.has('chromium-experimental-timestamp-query-inside-passes')) {\n      requiredFeatures.push('chromium-experimental-timestamp-query-inside-passes' as GPUFeatureName);\n    } else if (adapter.features.has('timestamp-query')) {\n      requiredFeatures.push('timestamp-query');\n    }\n    if (adapter.features.has('shader-f16')) {\n      requiredFeatures.push('shader-f16');\n    }\n\n    this.device = await adapter.requestDevice(deviceDescriptor);\n    this.adapterInfo = new AdapterInfoImpl(await adapter.requestAdapterInfo());\n    this.gpuDataManager = createGpuDataManager(this);\n    this.programManager = new ProgramManager(this);\n    this.kernels = new Map();\n    this.kernelPersistentData = new Map();\n    this.kernelCustomData = new Map();\n\n    // set up flags for logger\n    configureLogger(env.logLevel!, !!env.debug);\n\n    // TODO: set up flags\n\n    this.device.onuncapturederror = ev => {\n      if (ev.error instanceof GPUValidationError) {\n        // eslint-disable-next-line no-console\n        console.error(`An uncaught WebGPU validation error was raised: ${ev.error.message}`);\n      }\n    };\n\n    Object.defineProperty(\n        this.env.webgpu, 'device', {value: this.device, writable: false, enumerable: true, configurable: false});\n    Object.defineProperty(\n        this.env.webgpu, 'adapter', {value: adapter, writable: false, enumerable: true, configurable: false});\n\n    // init queryType, which is necessary for InferenceSession.create\n    this.setQueryType();\n  }\n\n  dispose(): void {\n    if (typeof this.querySet !== 'undefined') {\n      this.querySet.destroy();\n    }\n    this.gpuDataManager.dispose();\n  }\n\n  getCommandEncoder(): GPUCommandEncoder {\n    if (!this.commandEncoder) {\n      this.commandEncoder = this.device.createCommandEncoder();\n    }\n    return this.commandEncoder;\n  }\n\n  getComputePassEncoder(): GPUComputePassEncoder {\n    if (!this.computePassEncoder) {\n      const commandEncoder = this.getCommandEncoder();\n      const computePassDescriptor: GPUComputePassDescriptor = {};\n\n      if (this.queryType === 'at-passes') {\n        computePassDescriptor.timestampWrites = {\n          querySet: this.querySet!,\n          beginningOfPassWriteIndex: this.pendingDispatchNumber * 2,\n          endOfPassWriteIndex: this.pendingDispatchNumber * 2 + 1,\n        };\n      }\n\n      this.computePassEncoder = commandEncoder.beginComputePass(computePassDescriptor);\n    }\n    return this.computePassEncoder;\n  }\n\n  endComputePass(): void {\n    if (this.computePassEncoder) {\n      this.computePassEncoder.end();\n      this.computePassEncoder = null;\n    }\n  }\n\n  flush(): void {\n    if (!this.commandEncoder) {\n      return;\n    }\n\n    TRACE_FUNC_BEGIN();\n\n    this.endComputePass();\n    let queryReadBuffer: GPUBuffer;\n    if (this.queryType !== 'none') {\n      this.commandEncoder.resolveQuerySet(\n          this.querySet!, 0, this.pendingDispatchNumber * 2, this.queryResolveBuffer!, 0);\n\n      queryReadBuffer = this.device.createBuffer(\n          // eslint-disable-next-line no-bitwise\n          {size: this.pendingDispatchNumber * 2 * 8, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST});\n\n      this.pendingQueries.set(queryReadBuffer, this.pendingKernels);\n      this.pendingKernels = [];\n      this.commandEncoder.copyBufferToBuffer(\n          this.queryResolveBuffer!, 0, queryReadBuffer, 0, this.pendingDispatchNumber * 2 * 8);\n    }\n\n    this.device.queue.submit([this.commandEncoder.finish()]);\n    this.gpuDataManager.refreshPendingBuffers();\n    this.commandEncoder = null;\n    this.pendingDispatchNumber = 0;\n\n    if (this.queryType !== 'none') {\n      void queryReadBuffer!.mapAsync(GPUMapMode.READ).then(() => {\n        const mappedData = new BigUint64Array(queryReadBuffer.getMappedRange());\n        const pendingKernels = this.pendingQueries.get(queryReadBuffer)!;\n        for (let i = 0; i < mappedData.length / 2; i++) {\n          const pendingKernelInfo = pendingKernels[i];\n          const kernelId = pendingKernelInfo.kernelId;\n          const kernelInfo = this.kernels.get(kernelId)!;\n          const kernelType = kernelInfo.kernelType;\n          const kernelName = kernelInfo.kernelName;\n          const programName = pendingKernelInfo.programName;\n          const inputTensorViews = pendingKernelInfo.inputTensorViews;\n          const outputTensorViews = pendingKernelInfo.outputTensorViews;\n          const startTimeU64 = mappedData[i * 2];\n          const endTimeU64 = mappedData[i * 2 + 1];\n\n          if (typeof this.queryTimeBase === 'undefined') {\n            this.queryTimeBase = startTimeU64;\n          }\n\n          const startTime = Number(startTimeU64 - this.queryTimeBase);\n          const endTime = Number(endTimeU64 - this.queryTimeBase);\n\n          if (!Number.isSafeInteger(startTime) || !Number.isSafeInteger(endTime)) {\n            throw new RangeError('incorrect timestamp range');\n          }\n\n          if (this.env.webgpu.profiling?.ondata) {\n            this.env.webgpu.profiling.ondata({\n              version: 1,\n              inputsMetadata: inputTensorViews.map(\n                  value => ({dims: value.dims, dataType: tensorDataTypeEnumToString(value.dataType)})),\n              outputsMetadata: outputTensorViews.map(\n                  value => ({dims: value.dims, dataType: tensorDataTypeEnumToString(value.dataType)})),\n              kernelId,\n              kernelType,\n              kernelName,\n              programName,\n              startTime,\n              endTime,\n            });\n          } else {\n            // if no callback is provided, print the profiling message to console\n            let inputShapes = '';\n            inputTensorViews.forEach((value, i) => {\n              inputShapes += `input[${i}]: [${value.dims}] | ${tensorDataTypeEnumToString(value.dataType)}, `;\n            });\n            let outputShapes = '';\n            outputTensorViews.forEach((value, i) => {\n              outputShapes += `output[${i}]: [${value.dims}] | ${tensorDataTypeEnumToString(value.dataType)}, `;\n            });\n            // eslint-disable-next-line no-console\n            console.log(`[profiling] kernel \"${kernelId}|${kernelType}|${kernelName}|${programName}\" ${inputShapes}${\n                outputShapes}execution time: ${endTime - startTime} ns`);\n          }\n          TRACE('GPU', `${programName}::${startTimeU64}::${endTimeU64}`);\n        }\n        queryReadBuffer.unmap();\n        this.pendingQueries.delete(queryReadBuffer);\n      });\n    }\n    TRACE_FUNC_END();\n  }\n\n  /**\n   * run a WebGPU program.\n   * @param program a ProgramInfo instance\n   * @param inputTensorViews a TensorView array. each element represents a value already exists in GPU.\n   * @param outputIndices an indices array. each element can be either -1 (temporary data), -2 (persistent data) or an\n   * index to the kernel's output.\n   * @param createKernelOutput a callback function that create a value to kernel's output with the given index\n   * @param createIntermediateOutput a callback function that create a value as a intermediate value, either temporary\n   * or persistent (owned by the current kernel)\n   * @returns a TensorView array representing the result.\n   */\n  run(program: ProgramInfo, inputTensorViews: readonly TensorView[], outputIndices: readonly number[],\n      createKernelOutput: (index: number, dataType: number, dims: readonly number[]) => TensorView,\n      createIntermediateOutput: (dataType: number, dims: readonly number[]) => TensorView,\n      outputCount: number): TensorView[] {\n    TRACE_FUNC_BEGIN(program.name);\n    // create info for inputs\n    const inputDatas: GpuData[] = [];\n    for (let i = 0; i < inputTensorViews.length; ++i) {\n      const data = inputTensorViews[i].data;\n      // if tensor view data is 0, it means the output is zero-sized tensor, and there is no GPU data for it.\n      if (data === 0) {\n        continue;\n      }\n      const gpuData = this.gpuDataManager.get(data);\n      if (!gpuData) {\n        throw new Error(`no GPU data for input: ${data}`);\n      }\n      inputDatas.push(gpuData);\n    }\n\n    const {outputs, dispatchGroup, programUniforms} = program.getRunData(inputTensorViews);\n\n    // check output indices\n    const validatedOutputIndices = outputIndices.length === 0 ? outputs.map((_, i) => i) : outputIndices;\n    if (validatedOutputIndices.length !== outputs.length) {\n      throw new Error(`Output size ${validatedOutputIndices.length} must be equal to ${outputs.length}.`);\n    }\n\n    // create info for outputs\n    const outputTensorViews: TensorView[] = [];\n    const outputDatas: GpuData[] = [];\n    for (let i = 0; i < outputs.length; ++i) {\n      // value -1 and -2 are used for creating temporary and persistent outputs.\n      // value -3 is used for placeholder output. So -3, -2, -1 and 0, 1, 2, ... are valid\n      // output indices. see type definition of ComputeContextInputsOutputsMapping for more details.\n      if (!Number.isInteger(validatedOutputIndices[i]) || validatedOutputIndices[i] < -3 ||\n          validatedOutputIndices[i] >= outputCount) {\n        throw new Error(`Invalid output index: ${validatedOutputIndices[i]}`);\n      }\n      if (validatedOutputIndices[i] === -3) {\n        continue;\n      }\n      const isTemporary = validatedOutputIndices[i] === -1;\n      const isPersistent = validatedOutputIndices[i] === -2;\n      const tensorView = (isTemporary || isPersistent) ?\n          createIntermediateOutput(outputs[i].dataType, outputs[i].dims) :\n          createKernelOutput(validatedOutputIndices[i], outputs[i].dataType, outputs[i].dims);\n      outputTensorViews.push(tensorView);\n      // if tensor view data is 0, it means the output is zero-sized tensor, and there is no GPU data for it.\n      if (tensorView.data === 0) {\n        continue;\n      }\n      const gpuData = this.gpuDataManager.get(tensorView.data);\n      if (!gpuData) {\n        throw new Error(`no GPU data for output: ${tensorView.data}`);\n      }\n      if (isTemporary) {\n        this.temporaryData.push(gpuData);\n      }\n      if (isPersistent) {\n        let persistentData = this.kernelPersistentData.get(this.currentKernelId!);\n        if (!persistentData) {\n          persistentData = [];\n          this.kernelPersistentData.set(this.currentKernelId!, persistentData);\n        }\n        persistentData.push(gpuData);\n      }\n      outputDatas.push(gpuData);\n    }\n\n    // when there are any zero-sized tensor in the inputs or outputs, we should report error unless all outputs are\n    // zero-sized tensors.\n    if (inputDatas.length !== inputTensorViews.length || outputDatas.length !== outputTensorViews.length) {\n      // if all outputs are zero-sized tensors, there is no need to run the program.\n      if (outputDatas.length === 0) {\n        TRACE_FUNC_END(program.name);\n        return outputTensorViews;\n      }\n      // if some outputs are zero-sized tensors, report an error.\n      //\n      // TODO: so far we don't see any use case that outputs include both zero-sized tensors and non-zero-sized tensors.\n      // If we see such use case, we need to make a change here to support it.\n      throw new Error(\n          `Program ${program.name} has zero-sized tensor(s) in inputs or outputs. This is not supported now.`);\n    }\n\n    // load uniforms\n    // TODO: add cache for uniform (is it necessary?)\n    //\n    let uniformBufferBinding: GPUBindingResource|undefined;\n    if (programUniforms) {\n      let currentOffset = 0;\n      const offsets: number[] = [];\n\n      programUniforms.forEach(v => {\n        const data = typeof v.data === 'number' ? [v.data] : v.data;\n        if (data.length === 0) {\n          return;\n        }\n        // https://www.w3.org/TR/WGSL/#alignof\n        const sizeOfElement = v.type === DataType.float16 ? 2 : 4;\n        let sizeOfVecOrMat;\n        let baseAlignment;\n        if (v.type === DataType.float16) {\n          baseAlignment = data.length > 4 ? 16 : (data.length > 2 ? 8 : data.length * sizeOfElement);\n          sizeOfVecOrMat = data.length > 4 ? 16 : sizeOfElement * data.length;\n        } else {\n          baseAlignment = data.length <= 2 ? data.length * sizeOfElement : 16;\n          sizeOfVecOrMat = 16;\n        }\n        currentOffset = Math.ceil(currentOffset / baseAlignment) * baseAlignment;\n        offsets.push(currentOffset);\n        // For non-float16 type, when data.length > 4, the uniform variable is of type array<vec4<i32|u32|f32>,N>, where\n        // N = Math.ceil(data.length / 4) and SizeOf(vec4<i32|u32|f32>) = 16. The total byte length is N *\n        // SizeOf(vec4<i32|u32|f32>). For float16 type, when data.length > 4, the uniform variable is of type\n        // array<mat2x4<f16>,N>, where N = Math.ceil(data.length / 8) and SizeOf(mat2x4<f16>) = 16. The total byte\n        // length is N * SizeOf(mat2x4<f16>).\n        const elementPerVecOrMat = v.type === DataType.float16 ? 8 : 4;\n        currentOffset += data.length > 4 ? Math.ceil(data.length / elementPerVecOrMat) * sizeOfVecOrMat :\n                                           data.length * sizeOfElement;\n      });\n\n      // Meet alignment of struct here: https://www.w3.org/TR/WGSL/#alignment-and-size. For simplicity, set\n      // maxAlignmentOfField to 16 since the underlying buffer has been rounded up to 16.\n      const maxAlignmentOfField = 16;\n      currentOffset = Math.ceil(currentOffset / maxAlignmentOfField) * maxAlignmentOfField;\n      const arrayBuffer = new ArrayBuffer(currentOffset);\n      programUniforms.forEach((v, i) => {\n        const offset = offsets[i];\n        const data = typeof v.data === 'number' ? [v.data] : v.data;\n        if (v.type === DataType.int32) {\n          new Int32Array(arrayBuffer, offset, data.length).set(data);\n        } else if (v.type === DataType.uint32) {\n          new Uint32Array(arrayBuffer, offset, data.length).set(data);\n        } else if (v.type === DataType.float16) {\n          // TODO: use Float16Array.\n          new Uint16Array(arrayBuffer, offset, data.length).set(data);\n        } else if (v.type === DataType.float) {\n          new Float32Array(arrayBuffer, offset, data.length).set(data);\n        } else {\n          throw new Error(`Unsupported uniform type: ${tensorDataTypeEnumToString(v.type)}`);\n        }\n      });\n\n      const uniformBufferData =\n          // eslint-disable-next-line no-bitwise\n          this.gpuDataManager.create(currentOffset, GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM);\n      this.device.queue.writeBuffer(uniformBufferData.buffer, 0, arrayBuffer, 0, currentOffset);\n      this.gpuDataManager.release(uniformBufferData.id);\n      uniformBufferBinding = {offset: 0, size: currentOffset, buffer: uniformBufferData.buffer};\n    }\n\n    const normalizedDispatchGroup = this.programManager.normalizeDispatchGroupSize(dispatchGroup);\n    const is1DimensionDispatch = normalizedDispatchGroup[1] === 1 && normalizedDispatchGroup[2] === 1;\n    // get program info\n    const key = getProgramInfoUniqueKey(program, inputTensorViews, is1DimensionDispatch);\n    let artifact = this.programManager.getArtifact(key);\n    if (!artifact) {\n      artifact = this.programManager.build(program, normalizedDispatchGroup);\n      this.programManager.setArtifact(key, artifact);\n      LOG_DEBUG('info', () => `[artifact] key: ${key}, programName: ${program.name}`);\n    }\n\n    // validate uniform variables\n    if (programUniforms && artifact.uniformVariablesInfo) {\n      if (programUniforms.length !== artifact.uniformVariablesInfo.length) {\n        throw new Error(`Uniform variables count mismatch: expect ${artifact.uniformVariablesInfo.length}, got ${\n            programUniforms.length} in program \"${artifact.programInfo.name}\".`);\n      }\n      for (let i = 0; i < programUniforms.length; i++) {\n        const uniform = programUniforms[i];\n        const actualType = uniform.type;\n        const actualLength = typeof uniform.data === 'number' ? 1 : uniform.data.length;\n        const [type, length] = artifact.uniformVariablesInfo[i];\n        if (actualType !== type || actualLength !== length) {\n          throw new Error(`Uniform variable ${i} mismatch: expect type ${type} with size ${length}, got type ${\n              actualType} with size ${actualLength} in program \"${artifact.programInfo.name}\".`);\n        }\n      }\n    }\n\n    LOG_DEBUG(\n        'info',\n        () => `[ProgramManager] run \"${program.name}\" (key=${key}) with ${normalizedDispatchGroup[0]}x${\n            normalizedDispatchGroup[1]}x${normalizedDispatchGroup[2]}`);\n\n    if (this.queryType !== 'none' || this.sessionStatus === 'capturing') {\n      const pendingKernelInfo: PendingKernelInfo = {\n        kernelId: this.currentKernelId!,\n        programName: artifact.programInfo.name,\n        inputTensorViews,\n        outputTensorViews,\n      };\n      this.pendingKernels.push(pendingKernelInfo);\n\n      if (this.sessionStatus === 'capturing') {\n        const sessionPendingKernels = this.capturedPendingKernels.get(this.currentSessionId!);\n        sessionPendingKernels!.push(pendingKernelInfo);\n      }\n    }\n\n    this.programManager.run(artifact, inputDatas, outputDatas, normalizedDispatchGroup, uniformBufferBinding);\n\n    TRACE_FUNC_END(program.name);\n    return outputTensorViews;\n  }\n\n  upload(gpuDataId: number, data: Uint8Array): void {\n    this.gpuDataManager.upload(gpuDataId, data);\n  }\n\n  memcpy(src: number, dst: number): void {\n    this.gpuDataManager.memcpy(src, dst);\n  }\n\n  async download(gpuDataId: number, getTargetBuffer: () => Uint8Array): Promise<void> {\n    // the underlying buffer may be changed after the async function is called. so we use a getter function to make sure\n    // the buffer is up-to-date.\n    await this.gpuDataManager.download(gpuDataId, getTargetBuffer);\n  }\n\n  alloc(size: number): number {\n    return this.gpuDataManager.create(size).id;\n  }\n\n  free(ptr: number): number {\n    return this.gpuDataManager.release(ptr);\n  }\n\n  createKernel(kernelType: string, kernelId: number, attribute: unknown, kernelName: string): void {\n    const op = WEBGPU_OP_RESOLVE_RULES.get(kernelType);\n    if (!op) {\n      throw new Error(`kernel not implemented: ${kernelType}`);\n    }\n\n    const kernelInfo: KernelInfo = {\n      kernelType,\n      kernelName,\n      kernelEntry: op[0],\n      attributes: [op[1], attribute],\n    };\n    this.kernels.set(kernelId, kernelInfo);\n  }\n\n  releaseKernel(kernelId: number): void {\n    const persistentData = this.kernelPersistentData.get(kernelId);\n    if (persistentData) {\n      for (const data of persistentData) {\n        this.gpuDataManager.release(data.id);\n      }\n      this.kernelPersistentData.delete(kernelId);\n    }\n\n    this.kernelCustomData.delete(kernelId);\n    this.kernels.delete(kernelId);\n  }\n\n  computeKernel(kernelId: number, context: ComputeContext, errors: Array<Promise<string|null>>): number {\n    const kernel = this.kernels.get(kernelId);\n    if (!kernel) {\n      throw new Error(`kernel not created: ${kernelId}`);\n    }\n    const kernelType = kernel.kernelType;\n    const kernelName = kernel.kernelName;\n    const kernelEntry = kernel.kernelEntry;\n    const attributes = kernel.attributes;\n    if (this.currentKernelId !== null) {\n      throw new Error(`kernel \"[${kernelType}] ${kernelName}\" is not allowed to be called recursively`);\n    }\n    this.currentKernelId = kernelId;\n\n    // parse attributes if necessary\n    if (attributes[0]) {\n      attributes[1] = attributes[0](attributes[1]);\n      attributes[0] = undefined;\n    }\n\n    LOG_DEBUG('info', () => `[WebGPU] Start to run kernel \"[${kernelType}] ${kernelName}\"...`);\n\n    const useErrorScope = this.env.debug;\n\n    this.temporaryData = [];\n    try {\n      if (useErrorScope) {\n        this.device.pushErrorScope('validation');\n      }\n\n      kernelEntry(context, attributes[1]);\n      return 0;  // ORT_OK\n    } catch (e) {\n      errors.push(Promise.resolve(`[WebGPU] Kernel \"[${kernelType}] ${kernelName}\" failed. ${e}`));\n      return 1;  // ORT_FAIL\n    } finally {\n      if (useErrorScope) {\n        errors.push(this.device.popErrorScope().then(\n            err => err ? `GPU validation error for kernel \"[${kernelType}] ${kernelName}\": ${err.message}` : null));\n      }\n\n      for (const data of this.temporaryData) {\n        this.gpuDataManager.release(data.id);\n      }\n      this.temporaryData = [];\n      this.currentKernelId = null;\n    }\n  }\n\n  // #region external buffer\n  registerBuffer(sessionId: number, index: number, buffer: GPUBuffer, size: number): number {\n    let sessionInputOutputMapping = this.sessionExternalDataMapping.get(sessionId);\n    if (!sessionInputOutputMapping) {\n      sessionInputOutputMapping = new Map();\n      this.sessionExternalDataMapping.set(sessionId, sessionInputOutputMapping);\n    }\n\n    const previousBuffer = sessionInputOutputMapping.get(index);\n    const id = this.gpuDataManager.registerExternalBuffer(buffer, size, previousBuffer?.[1]);\n    sessionInputOutputMapping.set(index, [id, buffer]);\n    return id;\n  }\n  unregisterBuffers(sessionId: number): void {\n    const sessionInputOutputMapping = this.sessionExternalDataMapping.get(sessionId);\n    if (sessionInputOutputMapping) {\n      sessionInputOutputMapping.forEach(bufferInfo => this.gpuDataManager.unregisterExternalBuffer(bufferInfo[1]));\n      this.sessionExternalDataMapping.delete(sessionId);\n    }\n  }\n  getBuffer(gpuDataId: number): GPUBuffer {\n    const gpuData = this.gpuDataManager.get(gpuDataId);\n    if (!gpuData) {\n      throw new Error(`no GPU data for buffer: ${gpuDataId}`);\n    }\n    return gpuData.buffer;\n  }\n  createDownloader(gpuBuffer: GPUBuffer, size: number, type: Tensor.GpuBufferDataTypes):\n      () => Promise<Tensor.DataType> {\n    return async () => {\n      const data = await downloadGpuData(this, gpuBuffer, size);\n      return createView(data.buffer, type);\n    };\n  }\n  // #endregion\n  writeTimestamp(index: number): void {\n    if (this.queryType !== 'inside-passes') {\n      return;\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (this.computePassEncoder as any).writeTimestamp(this.querySet, index);\n  }\n  setQueryType(): void {\n    this.queryType = 'none';\n    if (this.env.webgpu.profiling?.mode === 'default' ||\n        (typeof this.env.trace === 'undefined' ? this.env.wasm.trace : this.env.trace)) {\n      if (this.device.features.has('chromium-experimental-timestamp-query-inside-passes')) {\n        this.queryType = 'inside-passes';\n      } else if (this.device.features.has('timestamp-query')) {\n        this.queryType = 'at-passes';\n      }\n\n      if (this.queryType !== 'none' && typeof this.querySet === 'undefined') {\n        this.querySet = this.device.createQuerySet({\n          type: 'timestamp',\n          count: this.maxDispatchNumber * 2,\n        });\n        this.queryResolveBuffer = this.device.createBuffer(\n            // eslint-disable-next-line no-bitwise\n            {size: this.maxDispatchNumber * 2 * 8, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});\n      }\n    }\n  }\n\n  captureBegin(): void {\n    LOG_DEBUG('info', 'captureBegin');\n    if (!this.capturedCommandList.get(this.currentSessionId!)) {\n      this.capturedCommandList.set(this.currentSessionId!, []);\n    }\n    if (!this.capturedPendingKernels.get(this.currentSessionId!)) {\n      this.capturedPendingKernels.set(this.currentSessionId!, []);\n    }\n    // flush the left commands before we change the status.\n    this.flush();\n    this.sessionStatus = 'capturing';\n  }\n  captureEnd(): void {\n    LOG_DEBUG('info', 'captureEnd');\n    // flush the left commands before we change the status.\n    this.flush();\n    this.sessionStatus = 'default';\n  }\n  replay(): void {\n    LOG_DEBUG('info', 'replay');\n    this.sessionStatus = 'replaying';\n    const sessionCommandList = this.capturedCommandList.get(this.currentSessionId!);\n    const sessionPendingKernels = this.capturedPendingKernels.get(this.currentSessionId!);\n    const length = sessionCommandList!.length;\n    this.pendingKernels = [];\n    for (let i = 0; i < length; i++) {\n      const computePassEncoder = this.getComputePassEncoder();\n      const command = sessionCommandList![i];\n      this.writeTimestamp(this.pendingDispatchNumber * 2);\n      computePassEncoder.setPipeline(command.computePipeline);\n      computePassEncoder.setBindGroup(0, command.bindGroup);\n      computePassEncoder.dispatchWorkgroups(...command.dispatchGroup);\n      this.writeTimestamp(this.pendingDispatchNumber * 2 + 1);\n      this.pendingDispatchNumber++;\n      if (this.queryType !== 'none') {\n        this.pendingKernels.push(sessionPendingKernels![i]);\n      }\n      if (this.pendingDispatchNumber >= this.maxDispatchNumber || this.queryType === 'at-passes') {\n        this.endComputePass();\n      }\n      if (this.pendingDispatchNumber >= this.maxDispatchNumber) {\n        this.flush();\n      }\n    }\n    // flush the left commands before we change the status.\n    this.flush();\n    this.sessionStatus = 'default';\n  }\n\n  onReleaseSession(sessionId: number): void {\n    this.unregisterBuffers(sessionId);\n    if (this.capturedCommandList.has(sessionId)) {\n      this.capturedCommandList.delete(sessionId);\n    }\n    if (this.capturedPendingKernels.has(sessionId)) {\n      this.capturedPendingKernels.delete(sessionId);\n    }\n    this.gpuDataManager.onReleaseSession(sessionId);\n  }\n\n  onRunStart(sessionId: number): void {\n    this.currentSessionId = sessionId;\n    this.setQueryType();\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Env} from 'onnxruntime-common';\n\nimport {OrtWasmModule} from '../binding/ort-wasm';\nimport {DataType, getTensorElementSize} from '../wasm-common';\n\nimport {WebGpuBackend} from './backend-webgpu';\nimport {LOG_DEBUG} from './log';\nimport {TensorView} from './tensor-view';\nimport {ShapeUtil} from './util';\nimport {AdapterInfo, ComputeContext, ComputeContextInputsOutputsMapping, ProgramInfo} from './webgpu/types';\n\n/* eslint-disable no-bitwise */\n\nclass TensorViewImpl implements TensorView {\n  constructor(\n      private module: OrtWasmModule, public readonly dataType: number, public readonly data: number,\n      public readonly dims: readonly number[]) {}\n\n  getFloat32Array(): Float32Array {\n    if (this.dataType !== DataType.float) {\n      throw new Error('Invalid data type');\n    }\n    const elementCount = ShapeUtil.size(this.dims);\n    return elementCount === 0 ? new Float32Array() :\n                                new Float32Array(this.module.HEAP8.buffer, this.data, elementCount);\n  }\n\n  getBigInt64Array(): BigInt64Array {\n    if (this.dataType !== DataType.int64) {\n      throw new Error('Invalid data type');\n    }\n    const elementCount = ShapeUtil.size(this.dims);\n    return elementCount === 0 ? new BigInt64Array() :\n                                new BigInt64Array(this.module.HEAP8.buffer, this.data, elementCount);\n  }\n\n  getInt32Array(): Int32Array {\n    if (this.dataType !== DataType.int32) {\n      throw new Error('Invalid data type');\n    }\n    const elementCount = ShapeUtil.size(this.dims);\n    return elementCount === 0 ? new Int32Array() : new Int32Array(this.module.HEAP8.buffer, this.data, elementCount);\n  }\n\n  reshape(newDims: readonly number[]): TensorView {\n    if (ShapeUtil.size(newDims) !== ShapeUtil.size(this.dims)) {\n      throw new Error('Invalid new shape');\n    }\n    return new TensorViewImpl(this.module, this.dataType, this.data, newDims);\n  }\n}\n\nclass ComputeContextImpl implements ComputeContext {\n  readonly adapterInfo: AdapterInfo;\n  readonly opKernelContext: number;\n  readonly inputs: readonly TensorView[];\n  readonly outputCount: number;\n  get kernelCustomData(): {[key: string]: unknown} {\n    return this.backend.currentKernelCustomData;\n  }\n  get customDataBuffer(): Uint8Array {\n    return this.module.HEAPU8.subarray(this.customDataOffset, this.customDataOffset + this.customDataSize);\n  }\n  private customDataOffset = 0;\n  private customDataSize = 0;\n  constructor(private module: OrtWasmModule, private backend: WebGpuBackend, contextDataOffset: number) {\n    this.adapterInfo = backend.adapterInfo;\n    const heapU32 = module.HEAPU32;\n\n    // extract context data\n    let dataIndex = (contextDataOffset >>> 2);\n    this.opKernelContext = heapU32[dataIndex++];\n    const inputCount = heapU32[dataIndex++];\n    this.outputCount = heapU32[dataIndex++];\n    this.customDataOffset = heapU32[dataIndex++];\n    this.customDataSize = heapU32[dataIndex++];\n\n    const inputs: TensorView[] = [];\n    for (let i = 0; i < inputCount; i++) {\n      const dataType = heapU32[dataIndex++];\n      const data = heapU32[dataIndex++];\n      const dim = heapU32[dataIndex++];\n      const dims: number[] = [];\n      for (let d = 0; d < dim; d++) {\n        dims.push(heapU32[dataIndex++]);\n      }\n      inputs.push(new TensorViewImpl(module, dataType, data, dims));\n    }\n    this.inputs = inputs;\n  }\n\n  getMaxComputeWorkgroupSizes(): [number, number, number] {\n    return [\n      this.backend.device.limits.maxComputeWorkgroupSizeX, this.backend.device.limits.maxComputeWorkgroupSizeY,\n      this.backend.device.limits.maxComputeWorkgroupSizeZ\n    ];\n  }\n\n  getMaxComputeWorkgroupStoragesize(): number {\n    return this.backend.device.limits.maxComputeWorkgroupStorageSize;\n  }\n\n  compute(program: ProgramInfo, inputsOutputsMapping?: ComputeContextInputsOutputsMapping): TensorView[] {\n    // prepare inputs. inputs should always be valid data.\n    const mappedInputs =\n        inputsOutputsMapping?.inputs?.map(i => typeof i === 'number' ? this.inputs[i] : i) ?? this.inputs;\n    // prepare outputs.\n    const outputIndices = inputsOutputsMapping?.outputs ?? [];\n    const createKernelOutput = (index: number, dataType: number, dims: readonly number[]): TensorView =>\n        new TensorViewImpl(this.module, dataType, this.output(index, dims), dims);\n    const createTemporaryOutput = (dataType: number, dims: readonly number[]): TensorView => {\n      const elementSize = getTensorElementSize(dataType);\n      if (!elementSize) {\n        throw new Error(`Unsupported data type: ${dataType}`);\n      }\n      const bufferSize = elementSize * ShapeUtil.size(dims);\n      const gpuDataId = bufferSize > 0 ? this.backend.gpuDataManager.create(bufferSize).id : 0;\n      return new TensorViewImpl(this.module, dataType, gpuDataId, dims);\n    };\n    return this.backend.run(\n        program, mappedInputs, outputIndices, createKernelOutput, createTemporaryOutput, this.outputCount);\n  }\n\n  output(index: number, dims: readonly number[]): number {\n    const stack = this.module.stackSave();\n    try {\n      const data = this.module.stackAlloc((1 + dims.length) * 4 /* sizeof(size_t) */);\n      let offset = data >> 2;\n      this.module.HEAPU32[offset++] = dims.length;\n      for (let i = 0; i < dims.length; i++) {\n        this.module.HEAPU32[offset++] = dims[i];\n      }\n      return this.module._JsepOutput!(this.opKernelContext, index, data);\n    } catch (e) {\n      throw new Error(\n          `Failed to generate kernel's output[${index}] with dims [${dims}]. ` +\n          'If you are running with pre-allocated output, please make sure the output type/dims are correct. ' +\n          `Error: ${e}`);\n    } finally {\n      this.module.stackRestore(stack);\n    }\n  }\n}\n\n/**\n * Initialize JSEP with WebGPU backend.\n *\n * This function will be called after the WebAssembly module is loaded and initialized (\"_OrtInit\" is called), once for\n * each of the following EPs if they are specified:\n * - \"webgpu\"\n * - \"webnn\"\n *\n * For WebGPU, this function expects:\n *  - WebGPU is enabled in build (BUILD_DEFS.DISABLE_WEBGPU === false).\n *  - WebGPU is available in current environment. (a valid GPUAdapter is passed in)\n *\n * For WebNN, this function expects:\n * - WebNN is enabled in build (BUILD_DEFS.DISABLE_WEBGPU === false).\n * - WebNN is available in current environment. (navigator.ml is not undefined)\n *\n * If the WebAssembly module is not built with JSEP support, this function will throw an error. This will invalidate\n * 'webgpu'/'webnn' backend.\n *\n * @param name - the name of the EP, either \"webgpu\" or \"webnn\"\n * @param module - the ORT WebAssembly module\n * @param env - the ORT environment variable (ort.env)\n * @param gpuAdapter - the pre-created GPU adapter\n */\nexport const init =\n    async(name: 'webgpu'|'webnn', module: OrtWasmModule, env: Env, gpuAdapter?: GPUAdapter): Promise<void> => {\n  const jsepInit = module.jsepInit;\n  if (!jsepInit) {\n    throw new Error('Failed to initialize JSEP. The WebAssembly module is not built with JSEP support.');\n  }\n\n  if (name === 'webgpu') {\n    const backend = new WebGpuBackend();\n    await backend.initialize(env, gpuAdapter!);\n\n    jsepInit('webgpu', [\n      // backend\n      backend,\n\n      // jsepAlloc()\n      (size: number) => backend.alloc(size),\n\n      // jsepFree()\n      (ptr: number) => backend.free(ptr),\n\n      // jsepCopy(src, dst, size, isSourceGpu)\n      (src: number, dst: number, size: number, isSourceGpu = false) => {\n        if (isSourceGpu) {\n          LOG_DEBUG('verbose', () => `[WebGPU] jsepCopyGpuToGpu: src=${src}, dst=${dst}, size=${size}`);\n          backend.memcpy(src, dst);\n        } else {\n          LOG_DEBUG('verbose', () => `[WebGPU] jsepCopyCpuToGpu: dataOffset=${src}, gpuDataId=${dst}, size=${size}`);\n          const data = module.HEAPU8.subarray(src >>> 0, (src >>> 0) + size);\n          backend.upload(dst, data);\n        }\n      },\n\n      // jsepCopyAsync(src, dst, size)\n      async(gpuDataId: number, dataOffset: number, size: number):\n          Promise<void> => {\n            LOG_DEBUG(\n                'verbose',\n                () => `[WebGPU] jsepCopyGpuToCpu: gpuDataId=${gpuDataId}, dataOffset=${dataOffset}, size=${size}`);\n\n            await backend.download(\n                gpuDataId, () => module.HEAPU8.subarray(dataOffset >>> 0, (dataOffset >>> 0) + size));\n          },\n\n      // jsepCreateKernel\n      (kernelType: string, kernelId: number, attribute: unknown) => backend.createKernel(\n          kernelType, kernelId, attribute, module.UTF8ToString(module._JsepGetNodeName!(kernelId))),\n\n      // jsepReleaseKernel\n      (kernel: number) => backend.releaseKernel(kernel),\n\n      // jsepRun\n      (kernel: number, contextDataOffset: number, sessionHandle: number, errors: Array<Promise<string|null>>) => {\n        LOG_DEBUG(\n            'verbose',\n            () => `[WebGPU] jsepRun: sessionHandle=${sessionHandle}, kernel=${kernel}, contextDataOffset=${\n                contextDataOffset}`);\n        const context = new ComputeContextImpl(module, backend, contextDataOffset);\n        return backend.computeKernel(kernel, context, errors);\n      },\n      // jsepCaptureBegin\n      () => backend.captureBegin(),\n      // jsepCaptureEnd\n      () => backend.captureEnd(),\n      // jsepReplay\n      () => backend.replay()\n    ]);\n  } else {\n    jsepInit('webnn');\n  }\n};\n", "export const join = undefined;", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport * as path from 'node:path';\nimport {Env} from 'onnxruntime-common';\n\nimport {OrtWasmModule} from './binding/ort-wasm';\nimport {OrtWasmThreadedModule} from './binding/ort-wasm-threaded';\n\n/* eslint-disable @typescript-eslint/no-require-imports */\nlet ortWasmFactory: EmscriptenModuleFactory<OrtWasmModule>;\n\nif (!BUILD_DEFS.DISABLE_TRAINING) {\n  ortWasmFactory = require('./binding/ort-training-wasm-simd.js');\n} else {\n  ortWasmFactory =\n      BUILD_DEFS.DISABLE_WEBGPU ? require('./binding/ort-wasm.js') : require('./binding/ort-wasm-simd.jsep.js');\n}\n\nconst ortWasmFactoryThreaded: EmscriptenModuleFactory<OrtWasmModule> = !BUILD_DEFS.DISABLE_WASM_THREAD ?\n    (BUILD_DEFS.DISABLE_WEBGPU ? require('./binding/ort-wasm-threaded.js') :\n                                 require('./binding/ort-wasm-simd-threaded.jsep.js')) :\n    ortWasmFactory;\n/* eslint-enable @typescript-eslint/no-require-imports */\n\nlet wasm: OrtWasmModule|undefined;\nlet initialized = false;\nlet initializing = false;\nlet aborted = false;\n\nconst isMultiThreadSupported = (numThreads: number): boolean => {\n  // WebAssembly threads are set to 1 (single thread).\n  if (numThreads === 1) {\n    return false;\n  }\n\n  // If 'SharedArrayBuffer' is not available, WebAssembly threads will not work.\n  if (typeof SharedArrayBuffer === 'undefined') {\n    if (typeof self !== 'undefined' && !self.crossOriginIsolated) {\n      // eslint-disable-next-line no-console\n      console.warn(\n          'env.wasm.numThreads is set to ' + numThreads +\n          ', but this will not work unless you enable crossOriginIsolated mode. ' +\n          'See https://web.dev/cross-origin-isolation-guide/ for more info.');\n    }\n    return false;\n  }\n\n  // onnxruntime-web does not support multi-threads in Node.js.\n  if (typeof process !== 'undefined' && process.versions && process.versions.node) {\n    // eslint-disable-next-line no-console\n    console.warn(\n        'env.wasm.numThreads is set to ' + numThreads +\n        ', however, currently onnxruntime-web does not support multi-threads in Node.js. ' +\n        'Please consider using onnxruntime-node for performance critical scenarios.');\n  }\n\n  try {\n    // Test for transferability of SABs (for browsers. needed for Firefox)\n    // https://groups.google.com/forum/#!msg/mozilla.dev.platform/IHkBZlHETpA/dwsMNchWEQAJ\n    if (typeof MessageChannel !== 'undefined') {\n      new MessageChannel().port1.postMessage(new SharedArrayBuffer(1));\n    }\n\n    // Test for WebAssembly threads capability (for both browsers and Node.js)\n    // This typed array is a WebAssembly program containing threaded instructions.\n    return WebAssembly.validate(new Uint8Array([\n      0, 97, 115, 109, 1, 0,  0,  0, 1, 4, 1,  96, 0,   0,  3, 2, 1,  0, 5,\n      4, 1,  3,   1,   1, 10, 11, 1, 9, 0, 65, 0,  254, 16, 2, 0, 26, 11\n    ]));\n  } catch (e) {\n    return false;\n  }\n};\n\nconst isSimdSupported = (): boolean => {\n  try {\n    // Test for WebAssembly SIMD capability (for both browsers and Node.js)\n    // This typed array is a WebAssembly program containing SIMD instructions.\n\n    // The binary data is generated from the following code by wat2wasm:\n    //\n    // (module\n    //   (type $t0 (func))\n    //   (func $f0 (type $t0)\n    //     (drop\n    //       (i32x4.dot_i16x8_s\n    //         (i8x16.splat\n    //           (i32.const 0))\n    //         (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)))))\n\n    return WebAssembly.validate(new Uint8Array([\n      0,   97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 30, 1,   28,  0, 65, 0,\n      253, 15, 253, 12,  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0,  0,  253, 186, 1, 26, 11\n    ]));\n  } catch (e) {\n    return false;\n  }\n};\n\nconst getWasmFileName = (useSimd: boolean, useThreads: boolean) => {\n  if (useSimd) {\n    if (!BUILD_DEFS.DISABLE_TRAINING) {\n      return 'ort-training-wasm-simd.wasm';\n    }\n    return useThreads ? 'ort-wasm-simd-threaded.wasm' : 'ort-wasm-simd.wasm';\n  } else {\n    return useThreads ? 'ort-wasm-threaded.wasm' : 'ort-wasm.wasm';\n  }\n};\n\nexport const initializeWebAssembly = async(flags: Env.WebAssemblyFlags): Promise<void> => {\n  if (initialized) {\n    return Promise.resolve();\n  }\n  if (initializing) {\n    throw new Error('multiple calls to \\'initializeWebAssembly()\\' detected.');\n  }\n  if (aborted) {\n    throw new Error('previous call to \\'initializeWebAssembly()\\' failed.');\n  }\n\n  initializing = true;\n\n  // wasm flags are already initialized\n  const timeout = flags.initTimeout!;\n  const numThreads = flags.numThreads!;\n  const simd = flags.simd!;\n\n  const useThreads = isMultiThreadSupported(numThreads);\n  const useSimd = simd && isSimdSupported();\n\n  const wasmPaths = flags.wasmPaths;\n  const wasmPrefixOverride = typeof wasmPaths === 'string' ? wasmPaths : undefined;\n  const wasmFileName = getWasmFileName(useSimd, useThreads);\n  const wasmPathOverride = typeof wasmPaths === 'object' ? wasmPaths[wasmFileName] : undefined;\n\n  let isTimeout = false;\n\n  const tasks: Array<Promise<void>> = [];\n\n  // promise for timeout\n  if (timeout > 0) {\n    tasks.push(new Promise((resolve) => {\n      setTimeout(() => {\n        isTimeout = true;\n        resolve();\n      }, timeout);\n    }));\n  }\n\n  // promise for module initialization\n  tasks.push(new Promise((resolve, reject) => {\n    const factory = useThreads ? ortWasmFactoryThreaded : ortWasmFactory;\n    const config: Partial<OrtWasmModule> = {\n      locateFile: (fileName: string, scriptDirectory: string) => {\n        if (!BUILD_DEFS.DISABLE_WASM_THREAD && useThreads && fileName.endsWith('.worker.js') &&\n            typeof Blob !== 'undefined') {\n          return URL.createObjectURL(new Blob(\n              [\n                // This require() function is handled by esbuild plugin to load file content as string.\n                // eslint-disable-next-line @typescript-eslint/no-require-imports\n                require('./binding/ort-wasm-threaded.worker.js')\n              ],\n              {type: 'text/javascript'}));\n        }\n\n        if (fileName.endsWith('.wasm')) {\n          if (wasmPathOverride) {\n            return wasmPathOverride;\n          }\n\n          const prefix = wasmPrefixOverride ?? scriptDirectory;\n\n          if (!BUILD_DEFS.DISABLE_WEBGPU) {\n            if (wasmFileName === 'ort-wasm-simd.wasm') {\n              return prefix + 'ort-wasm-simd.jsep.wasm';\n            } else if (wasmFileName === 'ort-wasm-simd-threaded.wasm') {\n              return prefix + 'ort-wasm-simd-threaded.jsep.wasm';\n            }\n          }\n\n          return prefix + wasmFileName;\n        }\n\n        return scriptDirectory + fileName;\n      }\n    };\n\n    if (!BUILD_DEFS.DISABLE_WASM_THREAD && useThreads) {\n      config.numThreads = numThreads;\n      if (typeof Blob === 'undefined') {\n        config.mainScriptUrlOrBlob = path.join(__dirname, 'ort-wasm-threaded.js');\n      } else {\n        const scriptSourceCode = `var ortWasmThreaded=${factory.toString()};`;\n        config.mainScriptUrlOrBlob = new Blob([scriptSourceCode], {type: 'text/javascript'});\n      }\n    }\n\n    factory(config).then(\n        // wasm module initialized successfully\n        module => {\n          initializing = false;\n          initialized = true;\n          wasm = module;\n          resolve();\n        },\n        // wasm module failed to initialize\n        (what) => {\n          initializing = false;\n          aborted = true;\n          reject(what);\n        });\n  }));\n\n  await Promise.race(tasks);\n\n  if (isTimeout) {\n    throw new Error(`WebAssembly backend initializing failed due to timeout: ${timeout}ms`);\n  }\n};\n\nexport const getInstance = (): OrtWasmModule => {\n  if (initialized && wasm) {\n    return wasm;\n  }\n\n  throw new Error('WebAssembly is not initialized yet.');\n};\n\nexport const dispose = (): void => {\n  if (initialized && !initializing && !aborted) {\n    initializing = true;\n\n    (wasm as OrtWasmThreadedModule).PThread?.terminateAllThreads();\n    wasm = undefined;\n\n    initializing = false;\n    initialized = false;\n    aborted = true;\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {getInstance} from './wasm-factory';\n\nexport const allocWasmString = (data: string, allocs: number[]): number => {\n  const wasm = getInstance();\n\n  const dataLength = wasm.lengthBytesUTF8(data) + 1;\n  const dataOffset = wasm._malloc(dataLength);\n  wasm.stringToUTF8(data, dataOffset, dataLength);\n  allocs.push(dataOffset);\n\n  return dataOffset;\n};\n\ninterface ExtraOptionsHandler {\n  (name: string, value: string): void;\n}\n\nexport const iterateExtraOptions =\n    (options: Record<string, unknown>, prefix: string, seen: WeakSet<Record<string, unknown>>,\n     handler: ExtraOptionsHandler): void => {\n      if (typeof options == 'object' && options !== null) {\n        if (seen.has(options)) {\n          throw new Error('Circular reference in options');\n        } else {\n          seen.add(options);\n        }\n      }\n\n      Object.entries(options).forEach(([key, value]) => {\n        const name = (prefix) ? prefix + key : key;\n        if (typeof value === 'object') {\n          iterateExtraOptions(value as Record<string, unknown>, name + '.', seen, handler);\n        } else if (typeof value === 'string' || typeof value === 'number') {\n          handler(name, value.toString());\n        } else if (typeof value === 'boolean') {\n          handler(name, (value) ? '1' : '0');\n        } else {\n          throw new Error(`Can't handle extra config type: ${typeof value}`);\n        }\n      });\n    };\n\n/**\n * check web assembly API's last error and throw error if any error occurred.\n * @param message a message used when an error occurred.\n */\nexport const checkLastError = (message: string): void => {\n  const wasm = getInstance();\n\n  const stack = wasm.stackSave();\n  try {\n    const paramsOffset = wasm.stackAlloc(8);\n    wasm._OrtGetLastError(paramsOffset, paramsOffset + 4);\n    const errorCode = wasm.HEAP32[paramsOffset / 4];\n    const errorMessagePointer = wasm.HEAPU32[paramsOffset / 4 + 1];\n    const errorMessage = errorMessagePointer ? wasm.UTF8ToString(errorMessagePointer) : '';\n    throw new Error(`${message} ERROR_CODE: ${errorCode}, ERROR_MESSAGE: ${errorMessage}`);\n  } finally {\n    wasm.stackRestore(stack);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {InferenceSession} from 'onnxruntime-common';\n\nimport {getInstance} from './wasm-factory';\nimport {allocWasmString, checkLastError, iterateExtraOptions} from './wasm-utils';\n\nexport const setRunOptions = (options: InferenceSession.RunOptions): [number, number[]] => {\n  const wasm = getInstance();\n  let runOptionsHandle = 0;\n  const allocs: number[] = [];\n\n  const runOptions: InferenceSession.RunOptions = options || {};\n\n  try {\n    if (options?.logSeverityLevel === undefined) {\n      runOptions.logSeverityLevel = 2;  // Default to warning\n    } else if (\n        typeof options.logSeverityLevel !== 'number' || !Number.isInteger(options.logSeverityLevel) ||\n        options.logSeverityLevel < 0 || options.logSeverityLevel > 4) {\n      throw new Error(`log serverity level is not valid: ${options.logSeverityLevel}`);\n    }\n\n    if (options?.logVerbosityLevel === undefined) {\n      runOptions.logVerbosityLevel = 0;  // Default to 0\n    } else if (typeof options.logVerbosityLevel !== 'number' || !Number.isInteger(options.logVerbosityLevel)) {\n      throw new Error(`log verbosity level is not valid: ${options.logVerbosityLevel}`);\n    }\n\n    if (options?.terminate === undefined) {\n      runOptions.terminate = false;\n    }\n\n    let tagDataOffset = 0;\n    if (options?.tag !== undefined) {\n      tagDataOffset = allocWasmString(options.tag, allocs);\n    }\n\n    runOptionsHandle = wasm._OrtCreateRunOptions(\n        runOptions.logSeverityLevel!, runOptions.logVerbosityLevel!, !!runOptions.terminate!, tagDataOffset);\n    if (runOptionsHandle === 0) {\n      checkLastError('Can\\'t create run options.');\n    }\n\n    if (options?.extra !== undefined) {\n      iterateExtraOptions(options.extra, '', new WeakSet<Record<string, unknown>>(), (key, value) => {\n        const keyDataOffset = allocWasmString(key, allocs);\n        const valueDataOffset = allocWasmString(value, allocs);\n\n        if (wasm._OrtAddRunConfigEntry(runOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n          checkLastError(`Can't set a run config entry: ${key} - ${value}.`);\n        }\n      });\n    }\n\n    return [runOptionsHandle, allocs];\n  } catch (e) {\n    if (runOptionsHandle !== 0) {\n      wasm._OrtReleaseRunOptions(runOptionsHandle);\n    }\n    allocs.forEach(alloc => wasm._free(alloc));\n    throw e;\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {InferenceSession} from 'onnxruntime-common';\n\nimport {getInstance} from './wasm-factory';\nimport {allocWasmString, checkLastError, iterateExtraOptions} from './wasm-utils';\n\nconst getGraphOptimzationLevel = (graphOptimizationLevel: string|unknown): number => {\n  switch (graphOptimizationLevel) {\n    case 'disabled':\n      return 0;\n    case 'basic':\n      return 1;\n    case 'extended':\n      return 2;\n    case 'all':\n      return 99;\n    default:\n      throw new Error(`unsupported graph optimization level: ${graphOptimizationLevel}`);\n  }\n};\n\nconst getExecutionMode = (executionMode: 'sequential'|'parallel'): number => {\n  switch (executionMode) {\n    case 'sequential':\n      return 0;\n    case 'parallel':\n      return 1;\n    default:\n      throw new Error(`unsupported execution mode: ${executionMode}`);\n  }\n};\n\nconst appendDefaultOptions = (options: InferenceSession.SessionOptions): void => {\n  if (!options.extra) {\n    options.extra = {};\n  }\n  if (!options.extra.session) {\n    options.extra.session = {};\n  }\n  const session = options.extra.session as Record<string, string>;\n  if (!session.use_ort_model_bytes_directly) {\n    // eslint-disable-next-line camelcase\n    session.use_ort_model_bytes_directly = '1';\n  }\n\n  // if using JSEP with WebGPU, always disable memory pattern\n  if (options.executionProviders &&\n      options.executionProviders.some(ep => (typeof ep === 'string' ? ep : ep.name) === 'webgpu')) {\n    options.enableMemPattern = false;\n  }\n};\n\nconst setExecutionProviders =\n    (sessionOptionsHandle: number, executionProviders: readonly InferenceSession.ExecutionProviderConfig[],\n     allocs: number[]): void => {\n      for (const ep of executionProviders) {\n        let epName = typeof ep === 'string' ? ep : ep.name;\n\n        // check EP name\n        switch (epName) {\n          case 'webnn':\n            epName = 'WEBNN';\n            if (typeof ep !== 'string') {\n              const webnnOptions = ep as InferenceSession.WebNNExecutionProviderOption;\n              if (webnnOptions?.deviceType) {\n                const keyDataOffset = allocWasmString('deviceType', allocs);\n                const valueDataOffset = allocWasmString(webnnOptions.deviceType, allocs);\n                if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !==\n                    0) {\n                  checkLastError(`Can't set a session config entry: 'deviceType' - ${webnnOptions.deviceType}.`);\n                }\n              }\n              if (webnnOptions?.numThreads) {\n                let numThreads = webnnOptions.numThreads;\n                // Just ignore invalid webnnOptions.numThreads.\n                if (typeof numThreads != 'number' || !Number.isInteger(numThreads) || numThreads < 0) {\n                  numThreads = 0;\n                }\n                const keyDataOffset = allocWasmString('numThreads', allocs);\n                const valueDataOffset = allocWasmString(numThreads.toString(), allocs);\n                if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !==\n                    0) {\n                  checkLastError(`Can't set a session config entry: 'numThreads' - ${webnnOptions.numThreads}.`);\n                }\n              }\n              if (webnnOptions?.powerPreference) {\n                const keyDataOffset = allocWasmString('powerPreference', allocs);\n                const valueDataOffset = allocWasmString(webnnOptions.powerPreference, allocs);\n                if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !==\n                    0) {\n                  checkLastError(\n                      `Can't set a session config entry: 'powerPreference' - ${webnnOptions.powerPreference}.`);\n                }\n              }\n            }\n            break;\n          case 'webgpu':\n            epName = 'JS';\n            if (typeof ep !== 'string') {\n              const webgpuOptions = ep as InferenceSession.WebGpuExecutionProviderOption;\n              if (webgpuOptions?.preferredLayout) {\n                if (webgpuOptions.preferredLayout !== 'NCHW' && webgpuOptions.preferredLayout !== 'NHWC') {\n                  throw new Error(`preferredLayout must be either 'NCHW' or 'NHWC': ${webgpuOptions.preferredLayout}`);\n                }\n                const keyDataOffset = allocWasmString('preferredLayout', allocs);\n                const valueDataOffset = allocWasmString(webgpuOptions.preferredLayout, allocs);\n                if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !==\n                    0) {\n                  checkLastError(\n                      `Can't set a session config entry: 'preferredLayout' - ${webgpuOptions.preferredLayout}.`);\n                }\n              }\n            }\n            break;\n          case 'wasm':\n          case 'cpu':\n            continue;\n          default:\n            throw new Error(`not supported execution provider: ${epName}`);\n        }\n\n        const epNameDataOffset = allocWasmString(epName, allocs);\n        if (getInstance()._OrtAppendExecutionProvider(sessionOptionsHandle, epNameDataOffset) !== 0) {\n          checkLastError(`Can't append execution provider: ${epName}.`);\n        }\n      }\n    };\n\nexport const setSessionOptions = (options?: InferenceSession.SessionOptions): [number, number[]] => {\n  const wasm = getInstance();\n  let sessionOptionsHandle = 0;\n  const allocs: number[] = [];\n\n  const sessionOptions: InferenceSession.SessionOptions = options || {};\n  appendDefaultOptions(sessionOptions);\n\n  try {\n    const graphOptimizationLevel = getGraphOptimzationLevel(sessionOptions.graphOptimizationLevel ?? 'all');\n    const executionMode = getExecutionMode(sessionOptions.executionMode ?? 'sequential');\n    const logIdDataOffset =\n        typeof sessionOptions.logId === 'string' ? allocWasmString(sessionOptions.logId, allocs) : 0;\n\n    const logSeverityLevel = sessionOptions.logSeverityLevel ?? 2;  // Default to 2 - warning\n    if (!Number.isInteger(logSeverityLevel) || logSeverityLevel < 0 || logSeverityLevel > 4) {\n      throw new Error(`log serverity level is not valid: ${logSeverityLevel}`);\n    }\n\n    const logVerbosityLevel = sessionOptions.logVerbosityLevel ?? 0;  // Default to 0 - verbose\n    if (!Number.isInteger(logVerbosityLevel) || logVerbosityLevel < 0 || logVerbosityLevel > 4) {\n      throw new Error(`log verbosity level is not valid: ${logVerbosityLevel}`);\n    }\n\n    const optimizedModelFilePathOffset = typeof sessionOptions.optimizedModelFilePath === 'string' ?\n        allocWasmString(sessionOptions.optimizedModelFilePath, allocs) :\n        0;\n\n    sessionOptionsHandle = wasm._OrtCreateSessionOptions(\n        graphOptimizationLevel, !!sessionOptions.enableCpuMemArena, !!sessionOptions.enableMemPattern, executionMode,\n        !!sessionOptions.enableProfiling, 0, logIdDataOffset, logSeverityLevel, logVerbosityLevel,\n        optimizedModelFilePathOffset);\n    if (sessionOptionsHandle === 0) {\n      checkLastError('Can\\'t create session options.');\n    }\n\n    if (sessionOptions.executionProviders) {\n      setExecutionProviders(sessionOptionsHandle, sessionOptions.executionProviders, allocs);\n    }\n\n    if (sessionOptions.enableGraphCapture !== undefined) {\n      if (typeof sessionOptions.enableGraphCapture !== 'boolean') {\n        throw new Error(`enableGraphCapture must be a boolean value: ${sessionOptions.enableGraphCapture}`);\n      }\n      const keyDataOffset = allocWasmString('enableGraphCapture', allocs);\n      const valueDataOffset = allocWasmString(sessionOptions.enableGraphCapture.toString(), allocs);\n      if (wasm._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n        checkLastError(\n            `Can't set a session config entry: 'enableGraphCapture' - ${sessionOptions.enableGraphCapture}.`);\n      }\n    }\n\n    if (sessionOptions.freeDimensionOverrides) {\n      for (const [name, value] of Object.entries(sessionOptions.freeDimensionOverrides)) {\n        if (typeof name !== 'string') {\n          throw new Error(`free dimension override name must be a string: ${name}`);\n        }\n        if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {\n          throw new Error(`free dimension override value must be a non-negative integer: ${value}`);\n        }\n        const nameOffset = allocWasmString(name, allocs);\n        if (wasm._OrtAddFreeDimensionOverride(sessionOptionsHandle, nameOffset, value) !== 0) {\n          checkLastError(`Can't set a free dimension override: ${name} - ${value}.`);\n        }\n      }\n    }\n\n    if (sessionOptions.extra !== undefined) {\n      iterateExtraOptions(sessionOptions.extra, '', new WeakSet<Record<string, unknown>>(), (key, value) => {\n        const keyDataOffset = allocWasmString(key, allocs);\n        const valueDataOffset = allocWasmString(value, allocs);\n\n        if (wasm._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n          checkLastError(`Can't set a session config entry: ${key} - ${value}.`);\n        }\n      });\n    }\n\n    return [sessionOptionsHandle, allocs];\n  } catch (e) {\n    if (sessionOptionsHandle !== 0) {\n      wasm._OrtReleaseSessionOptions(sessionOptionsHandle);\n    }\n    allocs.forEach(alloc => wasm._free(alloc));\n    throw e;\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Env, InferenceSession, Tensor} from 'onnxruntime-common';\n\nimport {SerializableInternalBuffer, SerializableSessionMetadata, SerializableTensorMetadata, TensorMetadata} from './proxy-messages';\nimport {setRunOptions} from './run-options';\nimport {setSessionOptions} from './session-options';\nimport {dataLocationStringToEnum, getTensorElementSize, isGpuBufferSupportedType, logLevelStringToEnum, tensorDataTypeEnumToString, tensorDataTypeStringToEnum, tensorTypeToTypedArrayConstructor} from './wasm-common';\nimport {getInstance} from './wasm-factory';\nimport {allocWasmString, checkLastError} from './wasm-utils';\nimport {loadFile} from './wasm-utils-load-file';\n\n// #region Initializations\n\n/**\n * There are 4 different \"initialization\" steps for ORT. They happen in different places and different time.\n *\n * 1. JavaScript initialization for onnxruntime-common and onnxruntime-web.\n *    This is the first initialization step. In this step, onnxruntime-web calls onnxruntime-common's registerBackend()\n * function multiple times to register all the available backends. The backend registration is very fast. It only\n * registers the backend name with the uninitialized backend object. No heavy initialization is done in this step.\n *    Refer to web/lib/index.ts for the backend registration.\n *\n * 2. WebAssembly artifact initialization.\n *    This happens when any registered wasm backend is used for the first time (ie. `ort.InferenceSession.create()` or\n * `ort.TrainingSession.create()` is called). In this step, onnxruntime-web does the followings:\n *     - create a proxy worker and make sure the proxy worker is ready to receive messages, if proxy is enabled.\n *     - perform feature detection, locate correct WebAssembly artifact path and call the Emscripten generated\n * JavaScript code to initialize the WebAssembly runtime.\n *         - if proxy is enabled, this step happens in the proxy worker using message 'init-wasm'.\n *         - downloading the 'ort-wasm{...}.wasm' file is done in this step.\n *         - if multi-thread is enabled, one or more webworker will be created to initialize the PThread threadpool.\n *\n * 3. ORT environment initialization.\n *    This happens after step 2. In this step, onnxruntime-web performs ONNX Runtime environment initialization.\n * Function `_OrtInit()` is called in this step.\n *     - if proxy is enabled, this step happens in the proxy worker using message 'init-ort'.\n *     - logging level (ort.env.logLevel) and thread number (ort.env.wasm.numThreads) are set in this step.\n *\n * 4. Session initialization.\n *    This happens when `ort.InferenceSession.create()` or `ort.TrainingSession.create()` is called. Unlike the first 3\n * steps (they only called once), this step will be done for each session. In this step, onnxruntime-web does the\n * followings:\n *    If the parameter is a URL:\n *    - download the model data from the URL.\n *    - copy the model data to the WASM heap. (proxy: 'copy-from')\n *    - dereference the model buffer. This step allows the original ArrayBuffer to be garbage collected.\n *    - call `_OrtCreateSession()` to create the session. (proxy: 'create')\n *\n *    If the parameter is a Uint8Array object:\n *    - copy the model data to the WASM heap. (proxy: 'copy-from')\n *    - call `_OrtCreateSession()` to create the session. (proxy: 'create')\n *\n *\n */\n\n/**\n * initialize ORT environment.\n *\n * @param numThreads SetGlobalIntraOpNumThreads(numThreads)\n * @param loggingLevel CreateEnv(static_cast<OrtLoggingLevel>(logging_level))\n */\nconst initOrt = (numThreads: number, loggingLevel: number): void => {\n  const errorCode = getInstance()._OrtInit(numThreads, loggingLevel);\n  if (errorCode !== 0) {\n    checkLastError('Can\\'t initialize onnxruntime.');\n  }\n};\n\n/**\n * intialize runtime environment.\n * @param env passed in the environment config object.\n */\nexport const initRuntime = async(env: Env): Promise<void> => {\n  // init ORT\n  initOrt(env.wasm.numThreads!, logLevelStringToEnum(env.logLevel));\n};\n\n/**\n * perform EP specific initialization.\n *\n * @param env\n * @param epName\n */\nexport const initEp = async(env: Env, epName: string): Promise<void> => {\n  if (!BUILD_DEFS.DISABLE_WEBGPU) {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires\n    const initJsep = require('./jsep/init').init;\n\n    if (epName === 'webgpu') {\n      // perform WebGPU availability check\n      if (typeof navigator === 'undefined' || !navigator.gpu) {\n        throw new Error('WebGPU is not supported in current environment');\n      }\n\n      let adapter = env.webgpu.adapter as GPUAdapter | null;\n      if (!adapter) {\n        // if adapter is not set, request a new adapter.\n        const powerPreference = env.webgpu.powerPreference;\n        if (powerPreference !== undefined && powerPreference !== 'low-power' &&\n            powerPreference !== 'high-performance') {\n          throw new Error(`Invalid powerPreference setting: \"${powerPreference}\"`);\n        }\n        const forceFallbackAdapter = env.webgpu.forceFallbackAdapter;\n        if (forceFallbackAdapter !== undefined && typeof forceFallbackAdapter !== 'boolean') {\n          throw new Error(`Invalid forceFallbackAdapter setting: \"${forceFallbackAdapter}\"`);\n        }\n        adapter = await navigator.gpu.requestAdapter({powerPreference, forceFallbackAdapter});\n        if (!adapter) {\n          throw new Error(\n              'Failed to get GPU adapter. ' +\n              'You may need to enable flag \"--enable-unsafe-webgpu\" if you are using Chrome.');\n        }\n      } else {\n        // if adapter is set, validate it.\n        if (typeof adapter.limits !== 'object' || typeof adapter.features !== 'object' ||\n            typeof adapter.requestDevice !== 'function') {\n          throw new Error('Invalid GPU adapter set in `env.webgpu.adapter`. It must be a GPUAdapter object.');\n        }\n      }\n\n      if (!env.wasm.simd) {\n        throw new Error(\n            'Not supported for WebGPU=ON and SIMD=OFF. Please set `env.wasm.simd` to true when using `webgpu` EP');\n      }\n\n      await initJsep('webgpu', getInstance(), env, adapter);\n    }\n    if (epName === 'webnn') {\n      // perform WebNN availability check\n      if (typeof navigator === 'undefined' || !(navigator as unknown as {ml: unknown}).ml) {\n        throw new Error('WebNN is not supported in current environment');\n      }\n\n      await initJsep('webnn', getInstance(), env);\n    }\n  }\n};\n\n// #endregion Initializations\n\n/**\n * valid data locations for input/output tensors.\n */\ntype SupportedTensorDataLocationForInputOutput = 'cpu'|'cpu-pinned'|'gpu-buffer';\n\ntype IOBindingState = {\n  /**\n   * the handle of IO binding.\n   */\n  readonly handle: number;\n\n  /**\n   * the preferred location for each output tensor.\n   *\n   * value is one of 'cpu', 'cpu-pinned', 'gpu-buffer'.\n   */\n  readonly outputPreferredLocations: readonly SupportedTensorDataLocationForInputOutput[];\n\n  /**\n   * enum value of the preferred location for each output tensor.\n   */\n  readonly outputPreferredLocationsEncoded: readonly number[];\n};\n\n/**\n *  tuple elements are: InferenceSession ID; inputNamesUTF8Encoded; outputNamesUTF8Encoded; bindingState\n */\ntype SessionMetadata = [\n  inferenceSessionId: number, inputNamesUTF8Encoded: number[], outputNamesUTF8Encoded: number[],\n  bindingState: IOBindingState|null, enableGraphCapture: boolean, inputOutputBound: boolean\n];\n\nconst activeSessions = new Map<number, SessionMetadata>();\n\n/**\n * get the input/output count of the session.\n * @param sessionHandle the handle representing the session. should be non-zero.\n * @returns a tuple including 2 numbers, representing the input count and output count.\n */\nconst getSessionInputOutputCount = (sessionHandle: number): [number, number] => {\n  const wasm = getInstance();\n  const stack = wasm.stackSave();\n  try {\n    const dataOffset = wasm.stackAlloc(8);\n    const errorCode = wasm._OrtGetInputOutputCount(sessionHandle, dataOffset, dataOffset + 4);\n    if (errorCode !== 0) {\n      checkLastError('Can\\'t get session input/output count.');\n    }\n    return [wasm.HEAP32[dataOffset / 4], wasm.HEAP32[dataOffset / 4 + 1]];\n  } finally {\n    wasm.stackRestore(stack);\n  }\n};\n\n/**\n * allocate the memory and memcpy the external buffer.\n *\n * @param model - the external buffer containing the model data. Must not be the same buffer as the WASM heap.\n * @returns a 2-elements tuple - the pointer and size of the allocated buffer\n */\nexport const copyFromExternalBuffer = (model: Uint8Array): [number, number] => {\n  const wasm = getInstance();\n  const modelDataOffset = wasm._malloc(model.byteLength);\n  if (modelDataOffset === 0) {\n    throw new Error(`Can't create a session. failed to allocate a buffer of size ${model.byteLength}.`);\n  }\n  wasm.HEAPU8.set(model, modelDataOffset);\n  return [modelDataOffset, model.byteLength];\n};\n\n/**\n * create an inference session from a model data buffer.\n *\n * @param modelData - either a Uint8Array object representing the model data, or a 2-elements tuple containing the\n *     pointer and size of the model data buffer.\n * @param options an optional session options object.\n * @returns a 3-elements tuple containing [session handle, input names, output names]\n */\nexport const createSession = async(\n    modelData: Uint8Array|SerializableInternalBuffer,\n    options?: InferenceSession.SessionOptions): Promise<SerializableSessionMetadata> => {\n  let modelDataOffset: number, modelDataLength: number;\n  const wasm = getInstance();\n\n  if (Array.isArray(modelData)) {\n    // if model data is an array, it must be a 2-elements tuple containing the pointer and size of the model data\n    [modelDataOffset, modelDataLength] = modelData;\n  } else if (modelData.buffer === wasm.HEAPU8.buffer) {\n    // if model data uses the same buffer as the WASM heap, we don't need to copy it.\n    [modelDataOffset, modelDataLength] = [modelData.byteOffset, modelData.byteLength];\n  } else {\n    // otherwise, copy the model data to the WASM heap.\n    [modelDataOffset, modelDataLength] = copyFromExternalBuffer(modelData);\n  }\n\n  let sessionHandle = 0;\n  let sessionOptionsHandle = 0;\n  let ioBindingHandle = 0;\n  let allocs: number[] = [];\n  const inputNamesUTF8Encoded = [];\n  const outputNamesUTF8Encoded = [];\n\n  try {\n    [sessionOptionsHandle, allocs] = setSessionOptions(options);\n\n    if (options?.externalData && wasm.mountExternalData) {\n      const loadingPromises = [];\n      for (const file of options.externalData) {\n        const path = typeof file === 'string' ? file : file.path;\n        loadingPromises.push(loadFile(typeof file === 'string' ? file : file.data).then(data => {\n          wasm.mountExternalData!(path, data);\n        }));\n      }\n\n      // wait for all external data files to be loaded\n      await Promise.all(loadingPromises);\n    }\n\n    sessionHandle = await wasm._OrtCreateSession(modelDataOffset, modelDataLength, sessionOptionsHandle);\n    if (sessionHandle === 0) {\n      checkLastError('Can\\'t create a session.');\n    }\n\n    const [inputCount, outputCount] = getSessionInputOutputCount(sessionHandle);\n\n    const enableGraphCapture = !!options?.enableGraphCapture;\n\n    const inputNames = [];\n    const outputNames = [];\n    const outputPreferredLocations: SupportedTensorDataLocationForInputOutput[] = [];\n    for (let i = 0; i < inputCount; i++) {\n      const name = wasm._OrtGetInputName(sessionHandle, i);\n      if (name === 0) {\n        checkLastError('Can\\'t get an input name.');\n      }\n      inputNamesUTF8Encoded.push(name);\n      inputNames.push(wasm.UTF8ToString(name));\n    }\n    for (let i = 0; i < outputCount; i++) {\n      const name = wasm._OrtGetOutputName(sessionHandle, i);\n      if (name === 0) {\n        checkLastError('Can\\'t get an output name.');\n      }\n      outputNamesUTF8Encoded.push(name);\n      const nameString = wasm.UTF8ToString(name);\n      outputNames.push(nameString);\n\n      if (!BUILD_DEFS.DISABLE_WEBGPU) {\n        if (enableGraphCapture && options?.preferredOutputLocation === undefined) {\n          outputPreferredLocations.push('gpu-buffer');\n          continue;\n        }\n        const location = typeof options?.preferredOutputLocation === 'string' ?\n            options.preferredOutputLocation :\n            options?.preferredOutputLocation?.[nameString] ?? 'cpu';\n        if (location !== 'cpu' && location !== 'cpu-pinned' && location !== 'gpu-buffer') {\n          throw new Error(`Not supported preferred output location: ${location}.`);\n        }\n        if (enableGraphCapture && location !== 'gpu-buffer') {\n          throw new Error(`Not supported preferred output location: ${\n              location}. Only 'gpu-buffer' location is supported when enableGraphCapture is true.`);\n        }\n        outputPreferredLocations.push(location);\n      }\n    }\n\n    // use IO binding only when at least one output is preffered to be on GPU.\n    let bindingState: IOBindingState|null = null;\n    if (!BUILD_DEFS.DISABLE_WEBGPU && outputPreferredLocations.some(l => l === 'gpu-buffer')) {\n      ioBindingHandle = wasm._OrtCreateBinding(sessionHandle);\n      if (ioBindingHandle === 0) {\n        checkLastError('Can\\'t create IO binding.');\n      }\n\n      bindingState = {\n        handle: ioBindingHandle,\n        outputPreferredLocations,\n        outputPreferredLocationsEncoded: outputPreferredLocations.map(l => dataLocationStringToEnum(l)),\n      };\n    }\n\n    activeSessions.set(\n        sessionHandle,\n        [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, bindingState, enableGraphCapture, false]);\n    return [sessionHandle, inputNames, outputNames];\n  } catch (e) {\n    inputNamesUTF8Encoded.forEach(buf => wasm._OrtFree(buf));\n    outputNamesUTF8Encoded.forEach(buf => wasm._OrtFree(buf));\n\n    if (ioBindingHandle !== 0) {\n      wasm._OrtReleaseBinding(ioBindingHandle);\n    }\n\n    if (sessionHandle !== 0) {\n      wasm._OrtReleaseSession(sessionHandle);\n    }\n    throw e;\n  } finally {\n    wasm._free(modelDataOffset);\n    if (sessionOptionsHandle !== 0) {\n      wasm._OrtReleaseSessionOptions(sessionOptionsHandle);\n    }\n    allocs.forEach(alloc => wasm._free(alloc));\n\n    // unmount external data if necessary\n    wasm.unmountExternalData?.();\n  }\n};\n\nexport const releaseSession = (sessionId: number): void => {\n  const wasm = getInstance();\n  const session = activeSessions.get(sessionId);\n  if (!session) {\n    throw new Error(`cannot release session. invalid session id: ${sessionId}`);\n  }\n  const [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture] = session;\n\n  if (ioBindingState) {\n    if (enableGraphCapture) {\n      wasm._OrtClearBoundOutputs(ioBindingState.handle);\n    }\n    wasm._OrtReleaseBinding(ioBindingState.handle);\n  }\n\n  wasm.jsepOnReleaseSession?.(sessionId);\n\n  inputNamesUTF8Encoded.forEach(buf => wasm._OrtFree(buf));\n  outputNamesUTF8Encoded.forEach(buf => wasm._OrtFree(buf));\n  wasm._OrtReleaseSession(sessionHandle);\n  activeSessions.delete(sessionId);\n};\n\nexport const prepareInputOutputTensor =\n    (tensor: TensorMetadata|null, tensorHandles: number[], allocs: number[], sessionId: number, index: number,\n     enableGraphCapture = false): void => {\n      if (!tensor) {\n        tensorHandles.push(0);\n        return;\n      }\n\n      const wasm = getInstance();\n\n      const dataType = tensor[0];\n      const dims = tensor[1];\n      const location = tensor[3];\n\n      let rawData: number;\n      let dataByteLength: number;\n\n      if (dataType === 'string' && location === 'gpu-buffer') {\n        throw new Error('String tensor is not supported on GPU.');\n      }\n\n      if (enableGraphCapture && location !== 'gpu-buffer') {\n        throw new Error(\n            `External buffer must be provided for input/output index ${index} when enableGraphCapture is true.`);\n      }\n\n      if (location === 'gpu-buffer') {\n        const gpuBuffer = tensor[2].gpuBuffer as GPUBuffer;\n        const elementSizeInBytes = getTensorElementSize(tensorDataTypeStringToEnum(dataType))!;\n        dataByteLength = dims.reduce((a, b) => a * b, 1) * elementSizeInBytes;\n\n        const registerBuffer = wasm.jsepRegisterBuffer;\n        if (!registerBuffer) {\n          throw new Error('Tensor location \"gpu-buffer\" is not supported without using WebGPU.');\n        }\n        rawData = registerBuffer(sessionId, index, gpuBuffer, dataByteLength);\n      } else {\n        const data = tensor[2];\n\n        if (Array.isArray(data)) {\n          // string tensor\n          dataByteLength = 4 * data.length;\n          rawData = wasm._malloc(dataByteLength);\n          allocs.push(rawData);\n          let dataIndex = rawData / 4;\n          for (let i = 0; i < data.length; i++) {\n            if (typeof data[i] !== 'string') {\n              throw new TypeError(`tensor data at index ${i} is not a string`);\n            }\n            wasm.HEAPU32[dataIndex++] = allocWasmString(data[i], allocs);\n          }\n        } else {\n          dataByteLength = data.byteLength;\n          rawData = wasm._malloc(dataByteLength);\n          allocs.push(rawData);\n          wasm.HEAPU8.set(new Uint8Array(data.buffer, data.byteOffset, dataByteLength), rawData);\n        }\n      }\n\n      const stack = wasm.stackSave();\n      const dimsOffset = wasm.stackAlloc(4 * dims.length);\n      try {\n        let dimIndex = dimsOffset / 4;\n        dims.forEach(d => wasm.HEAP32[dimIndex++] = d);\n        const tensor = wasm._OrtCreateTensor(\n            tensorDataTypeStringToEnum(dataType), rawData, dataByteLength, dimsOffset, dims.length,\n            dataLocationStringToEnum(location));\n        if (tensor === 0) {\n          checkLastError(`Can't create tensor for input/output. session=${sessionId}, index=${index}.`);\n        }\n        tensorHandles.push(tensor);\n      } finally {\n        wasm.stackRestore(stack);\n      }\n    };\n\n/**\n * perform inference run\n */\nexport const run = async(\n    sessionId: number, inputIndices: number[], inputTensors: TensorMetadata[], outputIndices: number[],\n    outputTensors: Array<TensorMetadata|null>, options: InferenceSession.RunOptions): Promise<TensorMetadata[]> => {\n  const wasm = getInstance();\n  const session = activeSessions.get(sessionId);\n  if (!session) {\n    throw new Error(`cannot run inference. invalid session id: ${sessionId}`);\n  }\n  const sessionHandle = session[0];\n  const inputNamesUTF8Encoded = session[1];\n  const outputNamesUTF8Encoded = session[2];\n  const ioBindingState = session[3];\n  const enableGraphCapture = session[4];\n  const inputOutputBound = session[5];\n\n  const inputCount = inputIndices.length;\n  const outputCount = outputIndices.length;\n\n  let runOptionsHandle = 0;\n  let runOptionsAllocs: number[] = [];\n\n  const inputTensorHandles: number[] = [];\n  const outputTensorHandles: number[] = [];\n  const inputOutputAllocs: number[] = [];\n\n  const beforeRunStack = wasm.stackSave();\n  const inputValuesOffset = wasm.stackAlloc(inputCount * 4);\n  const inputNamesOffset = wasm.stackAlloc(inputCount * 4);\n  const outputValuesOffset = wasm.stackAlloc(outputCount * 4);\n  const outputNamesOffset = wasm.stackAlloc(outputCount * 4);\n\n  try {\n    [runOptionsHandle, runOptionsAllocs] = setRunOptions(options);\n\n    // create input tensors\n    for (let i = 0; i < inputCount; i++) {\n      prepareInputOutputTensor(\n          inputTensors[i], inputTensorHandles, inputOutputAllocs, sessionId, inputIndices[i], enableGraphCapture);\n    }\n\n    // create output tensors\n    for (let i = 0; i < outputCount; i++) {\n      prepareInputOutputTensor(\n          outputTensors[i], outputTensorHandles, inputOutputAllocs, sessionId, inputCount + outputIndices[i],\n          enableGraphCapture);\n    }\n\n    let inputValuesIndex = inputValuesOffset / 4;\n    let inputNamesIndex = inputNamesOffset / 4;\n    let outputValuesIndex = outputValuesOffset / 4;\n    let outputNamesIndex = outputNamesOffset / 4;\n    for (let i = 0; i < inputCount; i++) {\n      wasm.HEAPU32[inputValuesIndex++] = inputTensorHandles[i];\n      wasm.HEAPU32[inputNamesIndex++] = inputNamesUTF8Encoded[inputIndices[i]];\n    }\n    for (let i = 0; i < outputCount; i++) {\n      wasm.HEAPU32[outputValuesIndex++] = outputTensorHandles[i];\n      wasm.HEAPU32[outputNamesIndex++] = outputNamesUTF8Encoded[outputIndices[i]];\n    }\n\n    if (!BUILD_DEFS.DISABLE_WEBGPU && ioBindingState && !inputOutputBound) {\n      const {handle, outputPreferredLocations, outputPreferredLocationsEncoded} = ioBindingState;\n\n      if (inputNamesUTF8Encoded.length !== inputCount) {\n        throw new Error(`input count from feeds (${\n            inputCount}) is expected to be always equal to model's input count (${inputNamesUTF8Encoded.length}).`);\n      }\n\n      // process inputs\n      for (let i = 0; i < inputCount; i++) {\n        const index = inputIndices[i];\n        const errorCode = await wasm._OrtBindInput(handle, inputNamesUTF8Encoded[index], inputTensorHandles[i]);\n        if (errorCode !== 0) {\n          checkLastError(`Can't bind input[${i}] for session=${sessionId}.`);\n        }\n      }\n\n      // process pre-allocated outputs\n      for (let i = 0; i < outputCount; i++) {\n        const index = outputIndices[i];\n        const location = outputTensors[i]?.[3];  // undefined means output is not pre-allocated.\n\n        if (location) {\n          // output is pre-allocated. bind the tensor.\n          const errorCode = wasm._OrtBindOutput(handle, outputNamesUTF8Encoded[index], outputTensorHandles[i], 0);\n          if (errorCode !== 0) {\n            checkLastError(`Can't bind pre-allocated output[${i}] for session=${sessionId}.`);\n          }\n        } else {\n          // output is not pre-allocated. reset preferred location.\n          const errorCode =\n              wasm._OrtBindOutput(handle, outputNamesUTF8Encoded[index], 0, outputPreferredLocationsEncoded[index]);\n          if (errorCode !== 0) {\n            checkLastError(`Can't bind output[${i}] to ${outputPreferredLocations[i]} for session=${sessionId}.`);\n          }\n        }\n      }\n      activeSessions.set(\n          sessionId,\n          [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture, true]);\n    }\n\n    wasm.jsepOnRunStart?.(sessionHandle);\n    let errorCode: number;\n    if (!BUILD_DEFS.DISABLE_WEBGPU && ioBindingState) {\n      errorCode = await wasm._OrtRunWithBinding(\n          sessionHandle, ioBindingState.handle, outputCount, outputValuesOffset, runOptionsHandle);\n    } else {\n      errorCode = await wasm._OrtRun(\n          sessionHandle, inputNamesOffset, inputValuesOffset, inputCount, outputNamesOffset, outputCount,\n          outputValuesOffset, runOptionsHandle);\n    }\n\n    if (errorCode !== 0) {\n      checkLastError('failed to call OrtRun().');\n    }\n\n    const output: TensorMetadata[] = [];\n\n    for (let i = 0; i < outputCount; i++) {\n      const tensor = wasm.HEAPU32[outputValuesOffset / 4 + i];\n      if (tensor === outputTensorHandles[i]) {\n        // output tensor is pre-allocated. no need to copy data.\n        output.push(outputTensors[i]!);\n        continue;\n      }\n\n      const beforeGetTensorDataStack = wasm.stackSave();\n      // stack allocate 4 pointer value\n      const tensorDataOffset = wasm.stackAlloc(4 * 4);\n\n      let keepOutputTensor = false;\n      let type: Tensor.Type|undefined, dataOffset = 0;\n      try {\n        const errorCode = wasm._OrtGetTensorData(\n            tensor, tensorDataOffset, tensorDataOffset + 4, tensorDataOffset + 8, tensorDataOffset + 12);\n        if (errorCode !== 0) {\n          checkLastError(`Can't access output tensor data on index ${i}.`);\n        }\n        let tensorDataIndex = tensorDataOffset / 4;\n        const dataType = wasm.HEAPU32[tensorDataIndex++];\n        dataOffset = wasm.HEAPU32[tensorDataIndex++];\n        const dimsOffset = wasm.HEAPU32[tensorDataIndex++];\n        const dimsLength = wasm.HEAPU32[tensorDataIndex++];\n        const dims = [];\n        for (let i = 0; i < dimsLength; i++) {\n          dims.push(wasm.HEAPU32[dimsOffset / 4 + i]);\n        }\n        wasm._OrtFree(dimsOffset);\n\n        const size = dims.reduce((a, b) => a * b, 1);\n        type = tensorDataTypeEnumToString(dataType);\n\n        const preferredLocation = ioBindingState?.outputPreferredLocations[outputIndices[i]];\n\n        if (type === 'string') {\n          if (preferredLocation === 'gpu-buffer') {\n            throw new Error('String tensor is not supported on GPU.');\n          }\n          const stringData: string[] = [];\n          let dataIndex = dataOffset / 4;\n          for (let i = 0; i < size; i++) {\n            const offset = wasm.HEAPU32[dataIndex++];\n            const maxBytesToRead = i === size - 1 ? undefined : wasm.HEAPU32[dataIndex] - offset;\n            stringData.push(wasm.UTF8ToString(offset, maxBytesToRead));\n          }\n          output.push([type, dims, stringData, 'cpu']);\n        } else {\n          // If a certain output's preferred location is GPU but the tensor is empty, we still need to create a CPU\n          // tensor for it. There is no mapping GPU buffer for an empty tensor.\n          if (preferredLocation === 'gpu-buffer' && size > 0) {\n            const getBuffer = wasm.jsepGetBuffer;\n            if (!getBuffer) {\n              throw new Error('preferredLocation \"gpu-buffer\" is not supported without using WebGPU.');\n            }\n            const gpuBuffer = getBuffer(dataOffset);\n            const elementSize = getTensorElementSize(dataType);\n            if (elementSize === undefined || !isGpuBufferSupportedType(type)) {\n              throw new Error(`Unsupported data type: ${type}`);\n            }\n\n            // do not release the tensor right now. it will be released when user calls tensor.dispose().\n            keepOutputTensor = true;\n\n            output.push([\n              type, dims, {\n                gpuBuffer,\n                download: wasm.jsepCreateDownloader!(gpuBuffer, size * elementSize, type),\n                dispose: () => {\n                  wasm._OrtReleaseTensor(tensor);\n                }\n              },\n              'gpu-buffer'\n            ]);\n          } else {\n            const typedArrayConstructor = tensorTypeToTypedArrayConstructor(type);\n            const data = new typedArrayConstructor(size);\n            new Uint8Array(data.buffer, data.byteOffset, data.byteLength)\n                .set(wasm.HEAPU8.subarray(dataOffset, dataOffset + data.byteLength));\n            output.push([type, dims, data, 'cpu']);\n          }\n        }\n      } finally {\n        wasm.stackRestore(beforeGetTensorDataStack);\n        if (type === 'string' && dataOffset) {\n          wasm._free(dataOffset);\n        }\n        if (!keepOutputTensor) {\n          wasm._OrtReleaseTensor(tensor);\n        }\n      }\n    }\n\n    if (ioBindingState && !enableGraphCapture) {\n      wasm._OrtClearBoundOutputs(ioBindingState.handle);\n      activeSessions.set(\n          sessionId,\n          [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture, false]);\n    }\n    return output;\n  } finally {\n    wasm.stackRestore(beforeRunStack);\n\n    inputTensorHandles.forEach(v => wasm._OrtReleaseTensor(v));\n    outputTensorHandles.forEach(v => wasm._OrtReleaseTensor(v));\n    inputOutputAllocs.forEach(p => wasm._free(p));\n\n    if (runOptionsHandle !== 0) {\n      wasm._OrtReleaseRunOptions(runOptionsHandle);\n    }\n    runOptionsAllocs.forEach(p => wasm._free(p));\n  }\n};\n\n/**\n * end profiling\n */\nexport const endProfiling = (sessionId: number): void => {\n  const wasm = getInstance();\n  const session = activeSessions.get(sessionId);\n  if (!session) {\n    throw new Error('invalid session id');\n  }\n  const sessionHandle = session[0];\n\n  // profile file name is not used yet, but it must be freed.\n  const profileFileName = wasm._OrtEndProfiling(sessionHandle);\n  if (profileFileName === 0) {\n    checkLastError('Can\\'t get an profile file name.');\n  }\n  wasm._OrtFree(profileFileName);\n};\n\nexport const extractTransferableBuffers = (tensors: readonly SerializableTensorMetadata[]): ArrayBufferLike[] => {\n  const buffers: ArrayBufferLike[] = [];\n  for (const tensor of tensors) {\n    const data = tensor[2];\n    if (!Array.isArray(data) && 'buffer' in data) {\n      buffers.push(data.buffer);\n    }\n  }\n  return buffers;\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport * as fs from 'fs';\nimport {readFile} from 'node:fs/promises';\n\n/**\n * Load a file into a Uint8Array.\n *\n * @param file - the file to load. Can be a URL/path, a Blob, an ArrayBuffer, or a Uint8Array.\n * @returns a Uint8Array containing the file data.\n */\nexport const loadFile = async(file: string|Blob|ArrayBufferLike|Uint8Array): Promise<Uint8Array> => {\n  if (typeof file === 'string') {\n    if (typeof process !== 'undefined' && process.versions && process.versions.node) {\n      // load file into ArrayBuffer in Node.js\n      try {\n        return new Uint8Array(await readFile(file));\n      } catch (e) {\n        if (e.code === 'ERR_FS_FILE_TOO_LARGE') {\n          // file is too large, use fs.createReadStream instead\n          const stream = fs.createReadStream(file);\n          const chunks: Uint8Array[] = [];\n          for await (const chunk of stream) {\n            chunks.push(chunk);\n          }\n          return new Uint8Array(Buffer.concat(chunks));\n        }\n        throw e;\n      }\n    } else {\n      // load file into ArrayBuffer in browsers\n      const response = await fetch(file);\n      if (!response.ok) {\n        throw new Error(`failed to load external data file: ${file}`);\n      }\n      const contentLengthHeader = response.headers.get('Content-Length');\n      const fileSize = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;\n      if (fileSize < 1073741824 /* 1GB */) {\n        // when Content-Length header is not set, we cannot determine the file size. We assume it is small enough to\n        // load into memory.\n        return new Uint8Array(await response.arrayBuffer());\n      } else {\n        // file is too large, use stream instead\n        if (!response.body) {\n          throw new Error(`failed to load external data file: ${file}, no response body.`);\n        }\n        const reader = response.body.getReader();\n\n        let buffer;\n        try {\n          // try to create ArrayBuffer directly\n          buffer = new ArrayBuffer(fileSize);\n        } catch (e) {\n          if (e instanceof RangeError) {\n            // use WebAssembly Memory to allocate larger ArrayBuffer\n            const pages = Math.ceil(fileSize / 65536);\n            buffer = new WebAssembly.Memory({initial: pages, maximum: pages}).buffer;\n          } else {\n            throw e;\n          }\n        }\n\n        let offset = 0;\n        // eslint-disable-next-line no-constant-condition\n        while (true) {\n          const {done, value} = await reader.read();\n          if (done) {\n            break;\n          }\n          const chunkSize = value.byteLength;\n          const chunk = new Uint8Array(buffer, offset, chunkSize);\n          chunk.set(value);\n          offset += chunkSize;\n        }\n        return new Uint8Array(buffer, 0, fileSize);\n      }\n    }\n\n  } else if (file instanceof Blob) {\n    return new Uint8Array(await file.arrayBuffer());\n  } else if (file instanceof Uint8Array) {\n    return file;\n  } else {\n    return new Uint8Array(file);\n  }\n};\n", "export const readFile = undefined;export const readFileSync = undefined;export const createReadStream = undefined;", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/// <reference lib=\"webworker\" />\n\n//\n// * type hack for \"HTMLImageElement\"\n//\n// in typescript, the type of \"HTMLImageElement\" is defined in lib.dom.d.ts, which is conflict with lib.webworker.d.ts.\n// when we use webworker, the lib.webworker.d.ts will be used, which does not have HTMLImageElement defined.\n//\n// we will get the following errors complaining that HTMLImageElement is not defined:\n//\n// ====================================================================================================================\n//\n// ../common/dist/cjs/tensor-factory.d.ts:187:29 - error TS2552: Cannot find name 'HTMLImageElement'. Did you mean\n// 'HTMLLIElement'?\n//\n// 187     fromImage(imageElement: HTMLImageElement, options?: TensorFromImageElementOptions):\n// Promise<TypedTensor<'float32'> | TypedTensor<'uint8'>>;\n//                                 ~~~~~~~~~~~~~~~~\n//\n// node_modules/@webgpu/types/dist/index.d.ts:83:7 - error TS2552: Cannot find name 'HTMLImageElement'. Did you mean\n// 'HTMLLIElement'?\n//\n// 83     | HTMLImageElement\n//          ~~~~~~~~~~~~~~~~\n//\n// ====================================================================================================================\n//\n// `HTMLImageElement` is only used in type declaration and not in real code. So we define it as `unknown` here to\n// bypass the type check.\n//\ndeclare global {\n  type HTMLImageElement = unknown;\n}\n\nimport {OrtWasmMessage, SerializableTensorMetadata} from '../proxy-messages';\nimport {createSession, copyFromExternalBuffer, endProfiling, extractTransferableBuffers, initEp, initRuntime, releaseSession, run} from '../wasm-core-impl';\nimport {initializeWebAssembly} from '../wasm-factory';\n\nself.onmessage = (ev: MessageEvent<OrtWasmMessage>): void => {\n  const {type, in : message} = ev.data;\n  try {\n    switch (type) {\n      case 'init-wasm':\n        initializeWebAssembly(message!.wasm)\n            .then(\n                () => {\n                  initRuntime(message!).then(\n                      () => {\n                        postMessage({type});\n                      },\n                      err => {\n                        postMessage({type, err});\n                      });\n                },\n                err => {\n                  postMessage({type, err});\n                });\n        break;\n      case 'init-ep': {\n        const {epName, env} = message!;\n        initEp(env, epName)\n            .then(\n                () => {\n                  postMessage({type});\n                },\n                err => {\n                  postMessage({type, err});\n                });\n        break;\n      }\n      case 'copy-from': {\n        const {buffer} = message!;\n        const bufferData = copyFromExternalBuffer(buffer);\n        postMessage({type, out: bufferData} as OrtWasmMessage);\n        break;\n      }\n      case 'create': {\n        const {model, options} = message!;\n        createSession(model, options)\n            .then(\n                sessionMetadata => {\n                  postMessage({type, out: sessionMetadata} as OrtWasmMessage);\n                },\n                err => {\n                  postMessage({type, err});\n                });\n        break;\n      }\n      case 'release':\n        releaseSession(message!);\n        postMessage({type});\n        break;\n      case 'run': {\n        const {sessionId, inputIndices, inputs, outputIndices, options} = message!;\n        run(sessionId, inputIndices, inputs, outputIndices, new Array(outputIndices.length).fill(null), options)\n            .then(\n                outputs => {\n                  if (outputs.some(o => o[3] !== 'cpu')) {\n                    postMessage({type, err: 'Proxy does not support non-cpu tensor location.'});\n                  } else {\n                    postMessage(\n                        {type, out: outputs} as OrtWasmMessage,\n                        extractTransferableBuffers([...inputs, ...outputs] as SerializableTensorMetadata[]));\n                  }\n                },\n                err => {\n                  postMessage({type, err});\n                });\n        break;\n      }\n      case 'end-profiling':\n        endProfiling(message!);\n        postMessage({type});\n        break;\n      default:\n    }\n  } catch (err) {\n    postMessage({type, err} as OrtWasmMessage);\n  }\n};\n"],
  "mappings": "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YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YACnf,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA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",
  "names": ["join", "env", "pad", "init", "offsets", "indices", "impl", "validateInputs", "reduceOps", "validateInputs", "validateInputs", "i", "validateInputs", "env", "validateInputs", "validateInputs", "a", "b", "transpose", "outputVariable", "innerElementSize", "validateInputs", "validateInputs", "outputShape", "transposedWeight", "convInputs", "innerElementSize", "validateInputs", "validateInputs", "permFunctionBody", "symbol", "reduceOps", "validateInputs", "calculateOutputShape", "fastGelu", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "dataType", "validateInputs", "weightTransposeAttribute", "validateInputs", "validateInputs", "env", "env", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "components", "validateInputs", "validateInputs", "getOutputShape", "a", "b", "c", "fastGelu", "env", "i", "env", "wasm", "wasm", "wasm", "readFile", "readFile", "env", "wasm", "tensor", "errorCode", "i", "env"]
}
\n'; + } +}); + +// web/lib/wasm/proxy-wrapper.ts +var isProxy, proxyWorker, initializing2, initialized2, aborted2, initWasmCallbacks, queuedCallbacks, enqueueCallbacks, ensureWorker, onProxyWorkerMessage, scriptSrc, initializeWebAssemblyAndOrtRuntime, initializeOrtEp, copyFromExternalBuffer2, createSession2, releaseSession2, run2, endProfiling2; +var init_proxy_wrapper = __esm({ + "web/lib/wasm/proxy-wrapper.ts"() { + "use strict"; + init_esm(); + init_wasm_core_impl(); + init_wasm_factory(); + isProxy = () => !!env2.wasm.proxy && typeof document !== "undefined"; + initializing2 = false; + initialized2 = false; + aborted2 = false; + queuedCallbacks = /* @__PURE__ */ new Map(); + enqueueCallbacks = (type, callbacks) => { + const queue = queuedCallbacks.get(type); + if (queue) { + queue.push(callbacks); + } else { + queuedCallbacks.set(type, [callbacks]); + } + }; + ensureWorker = () => { + if (initializing2 || !initialized2 || aborted2 || !proxyWorker) { + throw new Error("worker not ready"); + } + }; + onProxyWorkerMessage = (ev) => { + switch (ev.data.type) { + case "init-wasm": + initializing2 = false; + if (ev.data.err) { + aborted2 = true; + initWasmCallbacks[1](ev.data.err); + } else { + initialized2 = true; + initWasmCallbacks[0](); + } + break; + case "init-ep": + case "copy-from": + case "create": + case "release": + case "run": + case "end-profiling": { + const callbacks = queuedCallbacks.get(ev.data.type); + if (ev.data.err) { + callbacks.shift()[1](ev.data.err); + } else { + callbacks.shift()[0](ev.data.out); + } + break; + } + default: + } + }; + scriptSrc = typeof document !== "undefined" ? document?.currentScript?.src : void 0; + initializeWebAssemblyAndOrtRuntime = async () => { + if (initialized2) { + return; + } + if (initializing2) { + throw new Error("multiple calls to 'initWasm()' detected."); + } + if (aborted2) { + throw new Error("previous call to 'initWasm()' failed."); + } + initializing2 = true; + if (isProxy()) { + if (env2.wasm.wasmPaths === void 0) { + if (scriptSrc && scriptSrc.indexOf("blob:") !== 0) { + env2.wasm.wasmPaths = scriptSrc.substr(0, +scriptSrc.lastIndexOf("/") + 1); + } + } + return new Promise((resolve, reject) => { + proxyWorker?.terminate(); + const workerUrl = URL.createObjectURL(new Blob( + [ + // This require() function is handled by esbuild plugin to load file content as string. + // eslint-disable-next-line @typescript-eslint/no-require-imports + require_main() + ], + { type: "text/javascript" } + )); + proxyWorker = new Worker(workerUrl, { name: "ort-wasm-proxy-worker" }); + proxyWorker.onerror = (ev) => reject(ev); + proxyWorker.onmessage = onProxyWorkerMessage; + URL.revokeObjectURL(workerUrl); + initWasmCallbacks = [resolve, reject]; + const message = { type: "init-wasm", in: env2 }; + proxyWorker.postMessage(message); + }); + } else { + try { + await initializeWebAssembly(env2.wasm); + await initRuntime(env2); + initialized2 = true; + } catch (e) { + aborted2 = true; + throw e; + } finally { + initializing2 = false; + } + } + }; + initializeOrtEp = async (epName) => { + if (isProxy()) { + ensureWorker(); + return new Promise((resolve, reject) => { + enqueueCallbacks("init-ep", [resolve, reject]); + const message = { type: "init-ep", in: { epName, env: env2 } }; + proxyWorker.postMessage(message); + }); + } else { + await initEp(env2, epName); + } + }; + copyFromExternalBuffer2 = async (buffer) => { + if (isProxy()) { + ensureWorker(); + return new Promise((resolve, reject) => { + enqueueCallbacks("copy-from", [resolve, reject]); + const message = { type: "copy-from", in: { buffer } }; + proxyWorker.postMessage(message, [buffer.buffer]); + }); + } else { + return copyFromExternalBuffer(buffer); + } + }; + createSession2 = async (model, options) => { + if (isProxy()) { + if (options?.preferredOutputLocation) { + throw new Error('session option "preferredOutputLocation" is not supported for proxy.'); + } + ensureWorker(); + return new Promise((resolve, reject) => { + enqueueCallbacks("create", [resolve, reject]); + const message = { type: "create", in: { model, options: { ...options } } }; + const transferable = []; + if (model instanceof Uint8Array) { + transferable.push(model.buffer); + } + proxyWorker.postMessage(message, transferable); + }); + } else { + return createSession(model, options); + } + }; + releaseSession2 = async (sessionId) => { + if (isProxy()) { + ensureWorker(); + return new Promise((resolve, reject) => { + enqueueCallbacks("release", [resolve, reject]); + const message = { type: "release", in: sessionId }; + proxyWorker.postMessage(message); + }); + } else { + releaseSession(sessionId); + } + }; + run2 = async (sessionId, inputIndices, inputs, outputIndices, outputs, options) => { + if (isProxy()) { + if (inputs.some((t) => t[3] !== "cpu")) { + throw new Error("input tensor on GPU is not supported for proxy."); + } + if (outputs.some((t) => t)) { + throw new Error("pre-allocated output tensor is not supported for proxy."); + } + ensureWorker(); + return new Promise((resolve, reject) => { + enqueueCallbacks("run", [resolve, reject]); + const serializableInputs = inputs; + const message = { type: "run", in: { sessionId, inputIndices, inputs: serializableInputs, outputIndices, options } }; + proxyWorker.postMessage(message, extractTransferableBuffers(serializableInputs)); + }); + } else { + return run(sessionId, inputIndices, inputs, outputIndices, outputs, options); + } + }; + endProfiling2 = async (sessionId) => { + if (isProxy()) { + ensureWorker(); + return new Promise((resolve, reject) => { + enqueueCallbacks("end-profiling", [resolve, reject]); + const message = { type: "end-profiling", in: sessionId }; + proxyWorker.postMessage(message); + }); + } else { + endProfiling(sessionId); + } + }; + } +}); + +// web/lib/wasm/session-handler-inference.ts +var encodeTensorMetadata, decodeTensorMetadata, OnnxruntimeWebAssemblySessionHandler; +var init_session_handler_inference = __esm({ + "web/lib/wasm/session-handler-inference.ts"() { + "use strict"; + init_esm(); + init_proxy_wrapper(); + init_wasm_common(); + init_wasm_utils_load_file(); + encodeTensorMetadata = (tensor, getName) => { + switch (tensor.location) { + case "cpu": + return [tensor.type, tensor.dims, tensor.data, "cpu"]; + case "gpu-buffer": + return [tensor.type, tensor.dims, { gpuBuffer: tensor.gpuBuffer }, "gpu-buffer"]; + default: + throw new Error(`invalid data location: ${tensor.location} for ${getName()}`); + } + }; + decodeTensorMetadata = (tensor) => { + switch (tensor[3]) { + case "cpu": + return new Tensor2(tensor[0], tensor[2], tensor[1]); + case "gpu-buffer": { + const dataType = tensor[0]; + if (!isGpuBufferSupportedType(dataType)) { + throw new Error(`not supported data type: ${dataType} for deserializing GPU tensor`); + } + const { gpuBuffer, download, dispose } = tensor[2]; + return Tensor2.fromGpuBuffer(gpuBuffer, { dataType, dims: tensor[1], download, dispose }); + } + default: + throw new Error(`invalid data location: ${tensor[3]}`); + } + }; + OnnxruntimeWebAssemblySessionHandler = class { + async fetchModelAndCopyToWasmMemory(path) { + return copyFromExternalBuffer2(await loadFile(path)); + } + async loadModel(pathOrBuffer, options) { + TRACE_FUNC_BEGIN(); + let model; + if (typeof pathOrBuffer === "string") { + if (typeof process !== "undefined" && process.versions && process.versions.node) { + model = await loadFile(pathOrBuffer); + } else { + model = await this.fetchModelAndCopyToWasmMemory(pathOrBuffer); + } + } else { + model = pathOrBuffer; + } + [this.sessionId, this.inputNames, this.outputNames] = await createSession2(model, options); + TRACE_FUNC_END(); + } + async dispose() { + return releaseSession2(this.sessionId); + } + async run(feeds, fetches, options) { + TRACE_FUNC_BEGIN(); + const inputArray = []; + const inputIndices = []; + Object.entries(feeds).forEach((kvp) => { + const name = kvp[0]; + const tensor = kvp[1]; + const index = this.inputNames.indexOf(name); + if (index === -1) { + throw new Error(`invalid input '${name}'`); + } + inputArray.push(tensor); + inputIndices.push(index); + }); + const outputArray = []; + const outputIndices = []; + Object.entries(fetches).forEach((kvp) => { + const name = kvp[0]; + const tensor = kvp[1]; + const index = this.outputNames.indexOf(name); + if (index === -1) { + throw new Error(`invalid output '${name}'`); + } + outputArray.push(tensor); + outputIndices.push(index); + }); + const inputs = inputArray.map((t, i) => encodeTensorMetadata(t, () => `input "${this.inputNames[inputIndices[i]]}"`)); + const outputs = outputArray.map( + (t, i) => t ? encodeTensorMetadata(t, () => `output "${this.outputNames[outputIndices[i]]}"`) : null + ); + const results = await run2(this.sessionId, inputIndices, inputs, outputIndices, outputs, options); + const resultMap = {}; + for (let i = 0; i < results.length; i++) { + resultMap[this.outputNames[outputIndices[i]]] = outputArray[i] ?? decodeTensorMetadata(results[i]); + } + TRACE_FUNC_END(); + return resultMap; + } + startProfiling() { + } + endProfiling() { + void endProfiling2(this.sessionId); + } + }; + } +}); + +// web/lib/backend-wasm.ts +var initializeFlags, OnnxruntimeWebAssemblyBackend; +var init_backend_wasm = __esm({ + "web/lib/backend-wasm.ts"() { + "use strict"; + init_node_os(); + init_esm(); + init_proxy_wrapper(); + init_session_handler_inference(); + initializeFlags = () => { + if (typeof env2.wasm.initTimeout !== "number" || env2.wasm.initTimeout < 0) { + env2.wasm.initTimeout = 0; + } + if (typeof env2.wasm.simd !== "boolean") { + env2.wasm.simd = true; + } + if (typeof env2.wasm.proxy !== "boolean") { + env2.wasm.proxy = false; + } + if (typeof env2.wasm.trace !== "boolean") { + env2.wasm.trace = false; + } + if (typeof env2.wasm.numThreads !== "number" || !Number.isInteger(env2.wasm.numThreads) || env2.wasm.numThreads <= 0) { + if (typeof self !== "undefined" && !self.crossOriginIsolated || typeof process !== "undefined" && process.versions && process.versions.node) { + env2.wasm.numThreads = 1; + } + const numCpuLogicalCores = typeof navigator === "undefined" ? cpus().length : navigator.hardwareConcurrency; + env2.wasm.numThreads = Math.min(4, Math.ceil((numCpuLogicalCores || 1) / 2)); + } + }; + OnnxruntimeWebAssemblyBackend = class { + /** + * This function initializes the WebAssembly backend. + * + * This function will be called only once for each backend name. It will be called the first time when + * `ort.InferenceSession.create()` is called with a registered backend name. + * + * @param backendName - the registered backend name. + */ + async init(backendName) { + initializeFlags(); + await initializeWebAssemblyAndOrtRuntime(); + await initializeOrtEp(backendName); + } + async createInferenceSessionHandler(pathOrBuffer, options) { + const handler = new OnnxruntimeWebAssemblySessionHandler(); + await handler.loadModel(pathOrBuffer, options); + return Promise.resolve(handler); + } + }; + } +}); + +// web/lib/backend-wasm-inference.ts +var backend_wasm_inference_exports = {}; +__export(backend_wasm_inference_exports, { + wasmBackend: () => wasmBackend +}); +var wasmBackend; +var init_backend_wasm_inference = __esm({ + "web/lib/backend-wasm-inference.ts"() { + "use strict"; + init_backend_wasm(); + wasmBackend = new OnnxruntimeWebAssemblyBackend(); + } +}); + +// web/lib/index.ts +init_esm(); +init_esm(); +init_esm(); + +// web/lib/version.ts +var version2 = "1.18.0"; + +// web/lib/index.ts +var lib_default = esm_exports; +if (false) { + const onnxjsBackend = null.onnxjsBackend; + registerBackend("webgl", onnxjsBackend, -10); +} +if (true) { + const wasmBackend2 = true ? (init_backend_wasm_inference(), __toCommonJS(backend_wasm_inference_exports)).wasmBackend : null.wasmBackend; + if (true) { + registerBackend("webgpu", wasmBackend2, 5); + registerBackend("webnn", wasmBackend2, 5); + } + registerBackend("cpu", wasmBackend2, 10); + registerBackend("wasm", wasmBackend2, 10); +} +Object.defineProperty(env2.versions, "web", { value: version2, enumerable: true }); +export { + InferenceSession2 as InferenceSession, + TRACE, + TRACE_FUNC_BEGIN, + TRACE_FUNC_END, + Tensor2 as Tensor, + TrainingSession2 as TrainingSession, + lib_default as default, + env2 as env, + registerBackend +}; +/** + * @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. + * ============================================================================= + */ +/** + * @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. + * ============================================================================= + */ +/** + * @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. + * ============================================================================= + */ +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../common/lib/backend-impl.ts", "../../../common/lib/backend.ts", "../../../common/lib/version.ts", "../../../common/lib/env-impl.ts", "../../../common/lib/env.ts", "../../../common/lib/tensor-conversion-impl.ts", "../../../common/lib/tensor-factory-impl.ts", "../../../common/lib/tensor-impl-type-mapping.ts", "../../../common/lib/tensor-utils-impl.ts", "../../../common/lib/tensor-impl.ts", "../../../common/lib/tensor.ts", "../../../common/lib/trace.ts", "../../../common/lib/inference-session-impl.ts", "../../../common/lib/inference-session.ts", "../../../common/lib/tensor-conversion.ts", "../../../common/lib/tensor-factory.ts", "../../../common/lib/onnx-model.ts", "../../../common/lib/onnx-value.ts", "../../../common/lib/training-session-impl.ts", "../../../common/lib/training-session.ts", "../../../common/lib/index.ts", "nodejs-ignore:node:os", "nodejs-ignore:node:path", "nodejs-ignore:fs", "nodejs-ignore:path", "../../lib/wasm/binding/ort-wasm-simd.jsep.js", "nodejs-ignore:worker_threads", "nodejs-ignore:perf_hooks", "nodejs-ignore:os", "../../lib/wasm/binding/ort-wasm-simd-threaded.jsep.js", "../../lib/wasm/binding/ort-wasm-threaded.worker.js", "../../lib/wasm/wasm-factory.ts", "../../lib/wasm/wasm-utils.ts", "../../lib/wasm/run-options.ts", "../../lib/wasm/session-options.ts", "../../lib/wasm/wasm-common.ts", "nodejs-ignore:node:fs/promises", "../../lib/wasm/wasm-utils-load-file.ts", "../../lib/wasm/jsep/log.ts", "../../lib/wasm/jsep/tensor-view.ts", "../../lib/wasm/jsep/webgpu/types.ts", "../../lib/wasm/jsep/webgpu/gpu-data-manager.ts", "../../lib/wasm/jsep/webgpu/attribute-with-cache-key.ts", "../../lib/wasm/jsep/util.ts", "../../lib/wasm/jsep/webgpu/ops/common.ts", "../../lib/wasm/jsep/webgpu/ops/transpose.ts", "../../lib/wasm/jsep/webgpu/ops/reduce-shared.ts", "../../lib/wasm/jsep/webgpu/ops/reduce.ts", "../../lib/wasm/jsep/webgpu/ops/argminmax.ts", "../../lib/wasm/jsep/webgpu/ops/concat.ts", "../../lib/wasm/jsep/webgpu/ops/attention.ts", "../../lib/wasm/jsep/webgpu/ops/batch-norm.ts", "../../lib/wasm/jsep/webgpu/ops/bias-add.ts", "../../lib/wasm/jsep/webgpu/ops/unary-op.ts", "../../lib/wasm/jsep/webgpu/ops/bias-split-gelu.ts", "../../lib/wasm/jsep/webgpu/ops/binary-op.ts", "../../lib/wasm/jsep/webgpu/ops/fuse-utils.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/activation_util.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/conv_util.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/matmul_packed_webgpu.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/conv2d_mm_webgpu.ts", "../../lib/wasm/jsep/webgpu/ops/conv-grouped.ts", "../../lib/wasm/jsep/webgpu/ops/matmul.ts", "../../lib/wasm/jsep/webgpu/ops/conv.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_mm_webgpu.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_webgpu.ts", "../../lib/wasm/jsep/webgpu/ops/conv-transpose.ts", "../../lib/wasm/jsep/webgpu/ops/cumsum.ts", "../../lib/wasm/jsep/webgpu/ops/depth-to-space.ts", "../../lib/wasm/jsep/webgpu/ops/einsum.ts", "../../lib/wasm/jsep/webgpu/ops/expand.ts", "../../lib/wasm/jsep/webgpu/ops/fast-gelu.ts", "../../lib/wasm/jsep/webgpu/ops/gather.ts", "../../lib/wasm/jsep/webgpu/ops/gather-elements.ts", "../../lib/wasm/jsep/webgpu/ops/gemm.ts", "../../lib/wasm/jsep/webgpu/ops/instance-norm.ts", "../../lib/wasm/jsep/webgpu/ops/layer-norm.ts", "../../lib/wasm/jsep/webgpu/ops/matmulnbits.ts", "../../lib/wasm/jsep/webgpu/ops/multihead-attentiion.ts", "../../lib/wasm/jsep/webgpu/ops/pad.ts", "../../lib/wasm/jsep/webgpu/ops/pool.ts", "../../lib/wasm/jsep/webgpu/ops/range.ts", "../../lib/wasm/jsep/webgpu/ops/resize.ts", "../../lib/wasm/jsep/webgpu/ops/rotary-embedding.ts", "../../lib/wasm/jsep/webgpu/ops/skip-layer-norm.ts", "../../lib/wasm/jsep/webgpu/ops/slice.ts", "../../lib/wasm/jsep/webgpu/ops/softmax.ts", "../../lib/wasm/jsep/webgpu/ops/split.ts", "../../lib/wasm/jsep/webgpu/ops/tile.ts", "../../lib/wasm/jsep/webgpu/ops/where.ts", "../../lib/wasm/jsep/webgpu/op-resolve-rules.ts", "../../lib/wasm/jsep/webgpu/program-manager.ts", "../../lib/wasm/jsep/backend-webgpu.ts", "../../lib/wasm/jsep/init.ts", "../../lib/wasm/wasm-core-impl.ts", "proxy-worker:./proxy-worker/main", "../../lib/wasm/proxy-wrapper.ts", "../../lib/wasm/session-handler-inference.ts", "../../lib/backend-wasm.ts", "../../lib/backend-wasm-inference.ts", "../../lib/index.ts", "../../lib/version.ts"],
  "sourcesContent": ["// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Backend} from './backend.js';\nimport {InferenceSession} from './inference-session.js';\n\ninterface BackendInfo {\n  backend: Backend;\n  priority: number;\n\n  initPromise?: Promise<void>;\n  initialized?: boolean;\n  aborted?: boolean;\n  error?: string;\n}\n\nconst backends: Map<string, BackendInfo> = new Map();\nconst backendsSortedByPriority: string[] = [];\n\n/**\n * Register a backend.\n *\n * @param name - the name as a key to lookup as an execution provider.\n * @param backend - the backend object.\n * @param priority - an integer indicating the priority of the backend. Higher number means higher priority. if priority\n * < 0, it will be considered as a 'beta' version and will not be used as a fallback backend by default.\n *\n * @ignore\n */\nexport const registerBackend = (name: string, backend: Backend, priority: number): void => {\n  if (backend && typeof backend.init === 'function' && typeof backend.createInferenceSessionHandler === 'function') {\n    const currentBackend = backends.get(name);\n    if (currentBackend === undefined) {\n      backends.set(name, {backend, priority});\n    } else if (currentBackend.priority > priority) {\n      // same name is already registered with a higher priority. skip registeration.\n      return;\n    } else if (currentBackend.priority === priority) {\n      if (currentBackend.backend !== backend) {\n        throw new Error(`cannot register backend \"${name}\" using priority ${priority}`);\n      }\n    }\n\n    if (priority >= 0) {\n      const i = backendsSortedByPriority.indexOf(name);\n      if (i !== -1) {\n        backendsSortedByPriority.splice(i, 1);\n      }\n\n      for (let i = 0; i < backendsSortedByPriority.length; i++) {\n        if (backends.get(backendsSortedByPriority[i])!.priority <= priority) {\n          backendsSortedByPriority.splice(i, 0, name);\n          return;\n        }\n      }\n      backendsSortedByPriority.push(name);\n    }\n    return;\n  }\n\n  throw new TypeError('not a valid backend');\n};\n\n/**\n * Try to resolve and initialize a backend.\n *\n * @param backendName - the name of the backend.\n * @returns the backend instance if resolved and initialized successfully, or an error message if failed.\n */\nconst tryResolveAndInitializeBackend = async(backendName: string): Promise<Backend|string> => {\n  const backendInfo = backends.get(backendName);\n  if (!backendInfo) {\n    return 'backend not found.';\n  }\n\n  if (backendInfo.initialized) {\n    return backendInfo.backend;\n  } else if (backendInfo.aborted) {\n    return backendInfo.error!;\n  } else {\n    const isInitializing = !!backendInfo.initPromise;\n    try {\n      if (!isInitializing) {\n        backendInfo.initPromise = backendInfo.backend.init(backendName);\n      }\n      await backendInfo.initPromise;\n      backendInfo.initialized = true;\n      return backendInfo.backend;\n    } catch (e) {\n      if (!isInitializing) {\n        backendInfo.error = `${e}`;\n        backendInfo.aborted = true;\n      }\n      return backendInfo.error!;\n    } finally {\n      delete backendInfo.initPromise;\n    }\n  }\n};\n\n/**\n * Resolve execution providers from the specific session options.\n *\n * @param options - the session options object.\n * @returns a promise that resolves to a tuple of an initialized backend instance and a session options object with\n * filtered EP list.\n *\n * @ignore\n */\nexport const resolveBackendAndExecutionProviders = async(options: InferenceSession.SessionOptions):\n    Promise<[backend: Backend, options: InferenceSession.SessionOptions]> => {\n      // extract backend hints from session options\n      const eps = options.executionProviders || [];\n      const backendHints = eps.map(i => typeof i === 'string' ? i : i.name);\n      const backendNames = backendHints.length === 0 ? backendsSortedByPriority : backendHints;\n\n      // try to resolve and initialize all requested backends\n      let backend: Backend|undefined;\n      const errors = [];\n      const availableBackendNames = new Set<string>();\n      for (const backendName of backendNames) {\n        const resolveResult = await tryResolveAndInitializeBackend(backendName);\n        if (typeof resolveResult === 'string') {\n          errors.push({name: backendName, err: resolveResult});\n        } else {\n          if (!backend) {\n            backend = resolveResult;\n          }\n          if (backend === resolveResult) {\n            availableBackendNames.add(backendName);\n          }\n        }\n      }\n\n      // if no backend is available, throw error.\n      if (!backend) {\n        throw new Error(`no available backend found. ERR: ${errors.map(e => `[${e.name}] ${e.err}`).join(', ')}`);\n      }\n\n      // for each explicitly requested backend, if it's not available, output warning message.\n      for (const {name, err} of errors) {\n        if (backendHints.includes(name)) {\n          // eslint-disable-next-line no-console\n          console.warn(`removing requested execution provider \"${\n              name}\" from session options because it is not available: ${err}`);\n        }\n      }\n\n      const filteredEps = eps.filter(i => availableBackendNames.has(typeof i === 'string' ? i : i.name));\n\n      return [\n        backend, new Proxy(options, {\n          get: (target, prop) => {\n            if (prop === 'executionProviders') {\n              return filteredEps;\n            }\n            return Reflect.get(target, prop);\n          }\n        })\n      ];\n    };\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {InferenceSession} from './inference-session.js';\nimport {OnnxValue} from './onnx-value.js';\nimport {TrainingSession} from './training-session.js';\n\n/**\n * @ignore\n */\nexport declare namespace SessionHandler {\n  type FeedsType = {[name: string]: OnnxValue};\n  type FetchesType = {[name: string]: OnnxValue | null};\n  type ReturnType = {[name: string]: OnnxValue};\n}\n\n/**\n * Represents shared SessionHandler functionality\n *\n * @ignore\n */\ninterface SessionHandler {\n  dispose(): Promise<void>;\n\n  readonly inputNames: readonly string[];\n  readonly outputNames: readonly string[];\n}\n\n/**\n * Represent a handler instance of an inference session.\n *\n * @ignore\n */\nexport interface InferenceSessionHandler extends SessionHandler {\n  startProfiling(): void;\n  endProfiling(): void;\n\n  run(feeds: SessionHandler.FeedsType, fetches: SessionHandler.FetchesType,\n      options: InferenceSession.RunOptions): Promise<SessionHandler.ReturnType>;\n}\n\n/**\n * Represent a handler instance of a training inference session.\n *\n * @ignore\n */\nexport interface TrainingSessionHandler extends SessionHandler {\n  readonly evalInputNames: readonly string[];\n  readonly evalOutputNames: readonly string[];\n\n  lazyResetGrad(): Promise<void>;\n  runTrainStep(\n      feeds: SessionHandler.FeedsType, fetches: SessionHandler.FetchesType,\n      options: InferenceSession.RunOptions): Promise<SessionHandler.ReturnType>;\n  runOptimizerStep(options: InferenceSession.RunOptions): Promise<void>;\n  runEvalStep(\n      feeds: SessionHandler.FeedsType, fetches: SessionHandler.FetchesType,\n      options: InferenceSession.RunOptions): Promise<SessionHandler.ReturnType>;\n\n  getParametersSize(trainableOnly: boolean): Promise<number>;\n  loadParametersBuffer(buffer: Uint8Array, trainableOnly: boolean): Promise<void>;\n  getContiguousParameters(trainableOnly: boolean): Promise<OnnxValue>;\n}\n\n/**\n * Represent a backend that provides implementation of model inferencing.\n *\n * @ignore\n */\nexport interface Backend {\n  /**\n   * Initialize the backend asynchronously. Should throw when failed.\n   */\n  init(backendName: string): Promise<void>;\n\n  createInferenceSessionHandler(uriOrBuffer: string|Uint8Array, options?: InferenceSession.SessionOptions):\n      Promise<InferenceSessionHandler>;\n\n  createTrainingSessionHandler?\n      (checkpointStateUriOrBuffer: TrainingSession.UriOrBuffer, trainModelUriOrBuffer: TrainingSession.UriOrBuffer,\n       evalModelUriOrBuffer: TrainingSession.UriOrBuffer, optimizerModelUriOrBuffer: TrainingSession.UriOrBuffer,\n       options: InferenceSession.SessionOptions): Promise<TrainingSessionHandler>;\n}\n\nexport {registerBackend} from './backend-impl.js';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// This file is generated by /js/scripts/update-version.ts\n// Do not modify file content manually.\n\nexport const version = '1.18.0';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Env} from './env.js';\nimport {version} from './version.js';\n\ntype LogLevelType = Env['logLevel'];\n\nlet logLevelValue: Required<LogLevelType> = 'warning';\n\nexport const env: Env = {\n  wasm: {} as Env.WebAssemblyFlags,\n  webgl: {} as Env.WebGLFlags,\n  webgpu: {} as Env.WebGpuFlags,\n  versions: {common: version},\n\n  set logLevel(value: LogLevelType) {\n    if (value === undefined) {\n      return;\n    }\n    if (typeof value !== 'string' || ['verbose', 'info', 'warning', 'error', 'fatal'].indexOf(value) === -1) {\n      throw new Error(`Unsupported logging level: ${value}`);\n    }\n    logLevelValue = value;\n  },\n  get logLevel(): Required<LogLevelType> {\n    return logLevelValue;\n  },\n};\n\n// set property 'logLevel' so that they can be correctly transferred to worker by `postMessage()`.\nObject.defineProperty(env, 'logLevel', {enumerable: true});\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {env as envImpl} from './env-impl.js';\n\nexport declare namespace Env {\n  export type WasmPrefixOrFilePaths = string|{\n    /* eslint-disable @typescript-eslint/naming-convention */\n    'ort-wasm.wasm'?: string;\n    'ort-wasm-threaded.wasm'?: string;\n    'ort-wasm-simd.wasm'?: string;\n    'ort-training-wasm-simd.wasm'?: string;\n    'ort-wasm-simd-threaded.wasm'?: string;\n    /* eslint-enable @typescript-eslint/naming-convention */\n  };\n  export interface WebAssemblyFlags {\n    /**\n     * set or get number of thread(s). If omitted or set to 0, number of thread(s) will be determined by system. If set\n     * to 1, no worker thread will be spawned.\n     *\n     * This setting is available only when WebAssembly multithread feature is available in current context.\n     *\n     * @defaultValue `0`\n     */\n    numThreads?: number;\n\n    /**\n     * set or get a boolean value indicating whether to enable SIMD. If set to false, SIMD will be forcely disabled.\n     *\n     * This setting is available only when WebAssembly SIMD feature is available in current context.\n     *\n     * @defaultValue `true`\n     */\n    simd?: boolean;\n\n    /**\n     * set or get a boolean value indicating whether to enable trace.\n     *\n     * @deprecated Use `env.trace` instead. If `env.trace` is set, this property will be ignored.\n     * @defaultValue `false`\n     */\n    trace?: boolean;\n\n    /**\n     * Set or get a number specifying the timeout for initialization of WebAssembly backend, in milliseconds. A zero\n     * value indicates no timeout is set.\n     *\n     * @defaultValue `0`\n     */\n    initTimeout?: number;\n\n    /**\n     * Set a custom URL prefix to the .wasm files or a set of overrides for each .wasm file. The override path should be\n     * an absolute path.\n     */\n    wasmPaths?: WasmPrefixOrFilePaths;\n\n    /**\n     * Set or get a boolean value indicating whether to proxy the execution of main thread to a worker thread.\n     *\n     * @defaultValue `false`\n     */\n    proxy?: boolean;\n  }\n\n  export interface WebGLFlags {\n    /**\n     * Set or get the WebGL Context ID (webgl or webgl2).\n     *\n     * @defaultValue `'webgl2'`\n     */\n    contextId?: 'webgl'|'webgl2';\n    /**\n     * Get the WebGL rendering context.\n     */\n    readonly context: WebGLRenderingContext;\n    /**\n     * Set or get the maximum batch size for matmul. 0 means to disable batching.\n     *\n     * @deprecated\n     */\n    matmulMaxBatchSize?: number;\n    /**\n     * Set or get the texture cache mode.\n     *\n     * @defaultValue `'full'`\n     */\n    textureCacheMode?: 'initializerOnly'|'full';\n    /**\n     * Set or get the packed texture mode\n     *\n     * @defaultValue `false`\n     */\n    pack?: boolean;\n    /**\n     * Set or get whether enable async download.\n     *\n     * @defaultValue `false`\n     */\n    async?: boolean;\n  }\n\n  export interface WebGpuProfilingDataV1TensorMetadata {\n    dims: readonly number[];\n    dataType: string;\n  }\n  export interface WebGpuProfilingDataV1 {\n    version: 1;\n    inputsMetadata: readonly WebGpuProfilingDataV1TensorMetadata[];\n    outputsMetadata: readonly WebGpuProfilingDataV1TensorMetadata[];\n    kernelId: number;\n    kernelType: string;\n    kernelName: string;\n    programName: string;\n    startTime: number;\n    endTime: number;\n  }\n\n  export type WebGpuProfilingData = WebGpuProfilingDataV1;\n\n  export interface WebGpuFlags {\n    /**\n     * Set or get the profiling mode.\n     *\n     * @deprecated Use `env.webgpu.profiling.mode` instead. If `env.webgpu.profiling.mode` is set, this property will be\n     * ignored.\n     */\n    profilingMode?: 'off'|'default';\n    /**\n     * Set or get the profiling configuration.\n     */\n    profiling?: {\n      /**\n       * Set or get the profiling mode.\n       *\n       * @defaultValue `'off'`\n       */\n      mode?: 'off'|'default';\n\n      /**\n       * Set or get a callback function when a profiling data is received. If not set, the profiling data will be\n       * printed to console.\n       */\n      ondata?: (data: WebGpuProfilingData) => void;\n    };\n    /**\n     * Set or get the power preference.\n     *\n     * Setting this property only has effect before the first WebGPU inference session is created. The value will be\n     * used as options for `navigator.gpu.requestAdapter()`.\n     *\n     * See {@link https://gpuweb.github.io/gpuweb/#dictdef-gpurequestadapteroptions} for more details.\n     *\n     * @defaultValue `undefined`\n     */\n    powerPreference?: 'low-power'|'high-performance';\n    /**\n     * Set or get the force fallback adapter flag.\n     *\n     * Setting this property only has effect before the first WebGPU inference session is created. The value will be\n     * used as options for `navigator.gpu.requestAdapter()`.\n     *\n     * See {@link https://gpuweb.github.io/gpuweb/#dictdef-gpurequestadapteroptions} for more details.\n     *\n     * @defaultValue `undefined`\n     */\n    forceFallbackAdapter?: boolean;\n    /**\n     * Set or get the adapter for WebGPU.\n     *\n     * Setting this property only has effect before the first WebGPU inference session is created. The value will be\n     * used as the GPU adapter for the underlying WebGPU backend to create GPU device.\n     *\n     * If this property is not set, it will be available to get after the first WebGPU inference session is created. The\n     * value will be the GPU adapter that created by the underlying WebGPU backend.\n     *\n     * When use with TypeScript, the type of this property is `GPUAdapter` defined in \"@webgpu/types\".\n     * Use `const adapter = env.webgpu.adapter as GPUAdapter;` in TypeScript to access this property with correct type.\n     *\n     * see comments on {@link Tensor.GpuBufferType}\n     */\n    adapter: unknown;\n    /**\n     * Get the device for WebGPU.\n     *\n     * This property is only available after the first WebGPU inference session is created.\n     *\n     * When use with TypeScript, the type of this property is `GPUDevice` defined in \"@webgpu/types\".\n     * Use `const device = env.webgpu.device as GPUDevice;` in TypeScript to access this property with correct type.\n     *\n     * see comments on {@link Tensor.GpuBufferType} for more details about why not use types defined in \"@webgpu/types\".\n     */\n    readonly device: unknown;\n    /**\n     * Set or get whether validate input content.\n     *\n     * @defaultValue `false`\n     */\n    validateInputContent?: boolean;\n  }\n}\n\nexport interface Env {\n  /**\n   * set the severity level for logging.\n   *\n   * @defaultValue `'warning'`\n   */\n  logLevel?: 'verbose'|'info'|'warning'|'error'|'fatal';\n\n  /**\n   * Indicate whether run in debug mode.\n   *\n   * @defaultValue `false`\n   */\n  debug?: boolean;\n\n  /**\n   * set or get a boolean value indicating whether to enable trace.\n   *\n   * @defaultValue `false`\n   */\n  trace?: boolean;\n\n  /**\n   * Get version of the current package.\n   */\n  readonly versions: {\n    readonly common: string;\n    readonly web?: string;\n    readonly node?: string;\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    readonly 'react-native'?: string;\n  };\n\n  /**\n   * Represent a set of flags for WebAssembly\n   */\n  readonly wasm: Env.WebAssemblyFlags;\n\n  /**\n   * Represent a set of flags for WebGL\n   */\n  readonly webgl: Env.WebGLFlags;\n\n  /**\n   * Represent a set of flags for WebGPU\n   */\n  readonly webgpu: Env.WebGpuFlags;\n\n  [name: string]: unknown;\n}\n\n/**\n * Represent a set of flags as a global singleton.\n */\nexport const env: Env = envImpl;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorToDataUrlOptions, TensorToImageDataOptions} from './tensor-conversion.js';\nimport {Tensor} from './tensor.js';\n\n/**\n * implementation of Tensor.toDataURL()\n */\nexport const tensorToDataURL = (tensor: Tensor, options?: TensorToDataUrlOptions): string => {\n  const canvas = typeof document !== 'undefined' ? document.createElement('canvas') : (new OffscreenCanvas(1, 1));\n  canvas.width = tensor.dims[3];\n  canvas.height = tensor.dims[2];\n  const pixels2DContext =\n      canvas.getContext('2d') as (CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | null);\n\n  if (pixels2DContext != null) {\n    // Default values for height and width & format\n    let width: number;\n    let height: number;\n    if (options?.tensorLayout !== undefined && options.tensorLayout === 'NHWC') {\n      width = tensor.dims[2];\n      height = tensor.dims[3];\n    } else {  // Default layout is NCWH\n      width = tensor.dims[3];\n      height = tensor.dims[2];\n    }\n\n    const inputformat = options?.format !== undefined ? options.format : 'RGB';\n\n    const norm = options?.norm;\n    let normMean: [number, number, number, number];\n    let normBias: [number, number, number, number];\n    if (norm === undefined || norm.mean === undefined) {\n      normMean = [255, 255, 255, 255];\n    } else {\n      if (typeof (norm.mean) === 'number') {\n        normMean = [norm.mean, norm.mean, norm.mean, norm.mean];\n      } else {\n        normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 0];\n        if (norm.mean[3] !== undefined) {\n          normMean[3] = norm.mean[3];\n        }\n      }\n    }\n    if (norm === undefined || norm.bias === undefined) {\n      normBias = [0, 0, 0, 0];\n    } else {\n      if (typeof (norm.bias) === 'number') {\n        normBias = [norm.bias, norm.bias, norm.bias, norm.bias];\n      } else {\n        normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];\n        if (norm.bias[3] !== undefined) {\n          normBias[3] = norm.bias[3];\n        }\n      }\n    }\n\n    const stride = height * width;\n    // Default pointer assignments\n    let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;\n\n    // Updating the pointer assignments based on the input image format\n    if (inputformat === 'RGBA') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n      aTensorPointer = stride * 3;\n    } else if (inputformat === 'RGB') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n    } else if (inputformat === 'RBG') {\n      rTensorPointer = 0;\n      bTensorPointer = stride;\n      gTensorPointer = stride * 2;\n    }\n\n    for (let i = 0; i < height; i++) {\n      for (let j = 0; j < width; j++) {\n        const R = ((tensor.data[rTensorPointer++] as number) - normBias[0]) * normMean[0];  // R value\n        const G = ((tensor.data[gTensorPointer++] as number) - normBias[1]) * normMean[1];  // G value\n        const B = ((tensor.data[bTensorPointer++] as number) - normBias[2]) * normMean[2];  // B value\n        const A = aTensorPointer === -1 ?\n            255 :\n            ((tensor.data[aTensorPointer++] as number) - normBias[3]) * normMean[3];  // A value\n        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n        pixels2DContext.fillStyle = 'rgba(' + R + ',' + G + ',' + B + ',' + A + ')';\n        pixels2DContext.fillRect(j, i, 1, 1);\n      }\n    }\n    if ('toDataURL' in canvas) {\n      return canvas.toDataURL();\n    } else {\n      throw new Error('toDataURL is not supported');\n    }\n  } else {\n    throw new Error('Can not access image data');\n  }\n};\n\n/**\n * implementation of Tensor.toImageData()\n */\nexport const tensorToImageData = (tensor: Tensor, options?: TensorToImageDataOptions): ImageData => {\n  const pixels2DContext = typeof document !== 'undefined' ?\n      document.createElement('canvas').getContext('2d') :\n      new OffscreenCanvas(1, 1).getContext('2d') as OffscreenCanvasRenderingContext2D;\n  let image: ImageData;\n  if (pixels2DContext != null) {\n    // Default values for height and width & format\n    let width: number;\n    let height: number;\n    let channels: number;\n    if (options?.tensorLayout !== undefined && options.tensorLayout === 'NHWC') {\n      width = tensor.dims[2];\n      height = tensor.dims[1];\n      channels = tensor.dims[3];\n    } else {  // Default layout is NCWH\n      width = tensor.dims[3];\n      height = tensor.dims[2];\n      channels = tensor.dims[1];\n    }\n    const inputformat = options !== undefined ? (options.format !== undefined ? options.format : 'RGB') : 'RGB';\n\n    const norm = options?.norm;\n    let normMean: [number, number, number, number];\n    let normBias: [number, number, number, number];\n    if (norm === undefined || norm.mean === undefined) {\n      normMean = [255, 255, 255, 255];\n    } else {\n      if (typeof (norm.mean) === 'number') {\n        normMean = [norm.mean, norm.mean, norm.mean, norm.mean];\n      } else {\n        normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 255];\n        if (norm.mean[3] !== undefined) {\n          normMean[3] = norm.mean[3];\n        }\n      }\n    }\n    if (norm === undefined || norm.bias === undefined) {\n      normBias = [0, 0, 0, 0];\n    } else {\n      if (typeof (norm.bias) === 'number') {\n        normBias = [norm.bias, norm.bias, norm.bias, norm.bias];\n      } else {\n        normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];\n        if (norm.bias[3] !== undefined) {\n          normBias[3] = norm.bias[3];\n        }\n      }\n    }\n\n    const stride = height * width;\n    if (options !== undefined) {\n      if (options.format !== undefined && (channels === 4 && options.format !== 'RGBA') ||\n          (channels === 3 && (options.format !== 'RGB' && options.format !== 'BGR'))) {\n        throw new Error('Tensor format doesn\\'t match input tensor dims');\n      }\n    }\n\n    // Default pointer assignments\n    const step = 4;\n    let rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;\n    let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;\n\n    // Updating the pointer assignments based on the input image format\n    if (inputformat === 'RGBA') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n      aTensorPointer = stride * 3;\n    } else if (inputformat === 'RGB') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n    } else if (inputformat === 'RBG') {\n      rTensorPointer = 0;\n      bTensorPointer = stride;\n      gTensorPointer = stride * 2;\n    }\n\n    image = pixels2DContext.createImageData(width, height);\n\n    for (let i = 0; i < height * width;\n         rImagePointer += step, gImagePointer += step, bImagePointer += step, aImagePointer += step, i++) {\n      image.data[rImagePointer] = ((tensor.data[rTensorPointer++] as number) - normBias[0]) * normMean[0];  // R value\n      image.data[gImagePointer] = ((tensor.data[gTensorPointer++] as number) - normBias[1]) * normMean[1];  // G value\n      image.data[bImagePointer] = ((tensor.data[bTensorPointer++] as number) - normBias[2]) * normMean[2];  // B value\n      image.data[aImagePointer] = aTensorPointer === -1 ?\n          255 :\n          ((tensor.data[aTensorPointer++] as number) - normBias[3]) * normMean[3];  // A value\n    }\n\n  } else {\n    throw new Error('Can not access image data');\n  }\n  return image;\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {OptionsDimensions, OptionsFormat, OptionsNormalizationParameters, OptionsTensorFormat, OptionsTensorLayout, TensorFromGpuBufferOptions, TensorFromImageBitmapOptions, TensorFromImageDataOptions, TensorFromImageElementOptions, TensorFromTextureOptions, TensorFromUrlOptions} from './tensor-factory.js';\nimport {Tensor} from './tensor-impl.js';\nimport {Tensor as TensorInterface} from './tensor.js';\n\ninterface BufferToTensorOptions extends OptionsDimensions, OptionsTensorLayout, OptionsNormalizationParameters,\n                                        OptionsFormat, OptionsTensorFormat {}\n\n/**\n * Create a new tensor object from image object\n *\n * @param buffer - Extracted image buffer data - assuming RGBA format\n * @param imageFormat - input image configuration - required configurations height, width, format\n * @param tensorFormat - output tensor configuration - Default is RGB format\n */\nexport const bufferToTensor = (buffer: Uint8ClampedArray|undefined, options: BufferToTensorOptions): Tensor => {\n  if (buffer === undefined) {\n    throw new Error('Image buffer must be defined');\n  }\n  if (options.height === undefined || options.width === undefined) {\n    throw new Error('Image height and width must be defined');\n  }\n  if (options.tensorLayout === 'NHWC') {\n    throw new Error('NHWC Tensor layout is not supported yet');\n  }\n\n  const {height, width} = options;\n\n  const norm = options.norm ?? {mean: 255, bias: 0};\n  let normMean: [number, number, number, number];\n  let normBias: [number, number, number, number];\n\n  if (typeof (norm.mean) === 'number') {\n    normMean = [norm.mean, norm.mean, norm.mean, norm.mean];\n  } else {\n    normMean = [norm.mean![0], norm.mean![1], norm.mean![2], norm.mean![3] ?? 255];\n  }\n\n  if (typeof (norm.bias) === 'number') {\n    normBias = [norm.bias, norm.bias, norm.bias, norm.bias];\n  } else {\n    normBias = [norm.bias![0], norm.bias![1], norm.bias![2], norm.bias![3] ?? 0];\n  }\n\n  const inputformat = options.format !== undefined ? options.format : 'RGBA';\n  // default value is RGBA since imagedata and HTMLImageElement uses it\n\n  const outputformat =\n      options.tensorFormat !== undefined ? (options.tensorFormat !== undefined ? options.tensorFormat : 'RGB') : 'RGB';\n  const stride = height * width;\n  const float32Data = outputformat === 'RGBA' ? new Float32Array(stride * 4) : new Float32Array(stride * 3);\n\n  // Default pointer assignments\n  let step = 4, rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;\n  let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;\n\n  // Updating the pointer assignments based on the input image format\n  if (inputformat === 'RGB') {\n    step = 3;\n    rImagePointer = 0;\n    gImagePointer = 1;\n    bImagePointer = 2;\n    aImagePointer = -1;\n  }\n\n  // Updating the pointer assignments based on the output tensor format\n  if (outputformat === 'RGBA') {\n    aTensorPointer = stride * 3;\n  } else if (outputformat === 'RBG') {\n    rTensorPointer = 0;\n    bTensorPointer = stride;\n    gTensorPointer = stride * 2;\n  } else if (outputformat === 'BGR') {\n    bTensorPointer = 0;\n    gTensorPointer = stride;\n    rTensorPointer = stride * 2;\n  }\n\n  for (let i = 0; i < stride;\n       i++, rImagePointer += step, bImagePointer += step, gImagePointer += step, aImagePointer += step) {\n    float32Data[rTensorPointer++] = (buffer[rImagePointer] + normBias[0]) / normMean[0];\n    float32Data[gTensorPointer++] = (buffer[gImagePointer] + normBias[1]) / normMean[1];\n    float32Data[bTensorPointer++] = (buffer[bImagePointer] + normBias[2]) / normMean[2];\n    if (aTensorPointer !== -1 && aImagePointer !== -1) {\n      float32Data[aTensorPointer++] = (buffer[aImagePointer] + normBias[3]) / normMean[3];\n    }\n  }\n\n  // Float32Array -> ort.Tensor\n  const outputTensor = outputformat === 'RGBA' ? new Tensor('float32', float32Data, [1, 4, height, width]) :\n                                                 new Tensor('float32', float32Data, [1, 3, height, width]);\n  return outputTensor;\n};\n\n/**\n * implementation of Tensor.fromImage().\n */\nexport const tensorFromImage = async(\n    image: ImageData|HTMLImageElement|ImageBitmap|string,\n    options?: TensorFromImageDataOptions|TensorFromImageElementOptions|TensorFromImageBitmapOptions|\n    TensorFromUrlOptions): Promise<Tensor> => {\n  // checking the type of image object\n  const isHTMLImageEle = typeof (HTMLImageElement) !== 'undefined' && image instanceof HTMLImageElement;\n  const isImageDataEle = typeof (ImageData) !== 'undefined' && image instanceof ImageData;\n  const isImageBitmap = typeof (ImageBitmap) !== 'undefined' && image instanceof ImageBitmap;\n  const isString = typeof image === 'string';\n\n  let data: Uint8ClampedArray|undefined;\n  let bufferToTensorOptions: BufferToTensorOptions = options ?? {};\n\n  const createCanvas = () => {\n    if (typeof document !== 'undefined') {\n      return document.createElement('canvas');\n    } else if (typeof OffscreenCanvas !== 'undefined') {\n      return new OffscreenCanvas(1, 1);\n    } else {\n      throw new Error('Canvas is not supported');\n    }\n  };\n  const createCanvasContext = (canvas: HTMLCanvasElement|OffscreenCanvas) => {\n    if (canvas instanceof HTMLCanvasElement) {\n      return canvas.getContext('2d');\n    } else if (canvas instanceof OffscreenCanvas) {\n      return canvas.getContext('2d') as OffscreenCanvasRenderingContext2D;\n    } else {\n      return null;\n    }\n  };\n  // filling and checking image configuration options\n  if (isHTMLImageEle) {\n    // HTMLImageElement - image object - format is RGBA by default\n    const canvas = createCanvas();\n    canvas.width = image.width;\n    canvas.height = image.height;\n    const pixels2DContext = createCanvasContext(canvas);\n\n    if (pixels2DContext != null) {\n      let height = image.height;\n      let width = image.width;\n      if (options !== undefined && options.resizedHeight !== undefined && options.resizedWidth !== undefined) {\n        height = options.resizedHeight;\n        width = options.resizedWidth;\n      }\n\n      if (options !== undefined) {\n        bufferToTensorOptions = options;\n        if (options.tensorFormat !== undefined) {\n          throw new Error('Image input config format must be RGBA for HTMLImageElement');\n        } else {\n          bufferToTensorOptions.tensorFormat = 'RGBA';\n        }\n        bufferToTensorOptions.height = height;\n        bufferToTensorOptions.width = width;\n      } else {\n        bufferToTensorOptions.tensorFormat = 'RGBA';\n        bufferToTensorOptions.height = height;\n        bufferToTensorOptions.width = width;\n      }\n\n      pixels2DContext.drawImage(image, 0, 0);\n      data = pixels2DContext.getImageData(0, 0, width, height).data;\n    } else {\n      throw new Error('Can not access image data');\n    }\n  } else if (isImageDataEle) {\n    let height: number;\n    let width: number;\n\n    if (options !== undefined && options.resizedWidth !== undefined && options.resizedHeight !== undefined) {\n      height = options.resizedHeight;\n      width = options.resizedWidth;\n    } else {\n      height = image.height;\n      width = image.width;\n    }\n\n    if (options !== undefined) {\n      bufferToTensorOptions = options;\n    }\n    bufferToTensorOptions.format = 'RGBA';\n    bufferToTensorOptions.height = height;\n    bufferToTensorOptions.width = width;\n\n    if (options !== undefined) {\n      const tempCanvas = createCanvas();\n\n      tempCanvas.width = width;\n      tempCanvas.height = height;\n\n      const pixels2DContext = createCanvasContext(tempCanvas);\n\n      if (pixels2DContext != null) {\n        pixels2DContext.putImageData(image, 0, 0);\n        data = pixels2DContext.getImageData(0, 0, width, height).data;\n      } else {\n        throw new Error('Can not access image data');\n      }\n    } else {\n      data = image.data;\n    }\n  } else if (isImageBitmap) {\n    // ImageBitmap - image object - format must be provided by user\n    if (options === undefined) {\n      throw new Error('Please provide image config with format for Imagebitmap');\n    }\n\n    const canvas = createCanvas();\n    canvas.width = image.width;\n    canvas.height = image.height;\n    const pixels2DContext = createCanvasContext(canvas);\n\n    if (pixels2DContext != null) {\n      const height = image.height;\n      const width = image.width;\n      pixels2DContext.drawImage(image, 0, 0, width, height);\n      data = pixels2DContext.getImageData(0, 0, width, height).data;\n      bufferToTensorOptions.height = height;\n      bufferToTensorOptions.width = width;\n      return bufferToTensor(data, bufferToTensorOptions);\n    } else {\n      throw new Error('Can not access image data');\n    }\n  } else if (isString) {\n    return new Promise((resolve, reject) => {\n      const canvas = createCanvas();\n      const context = createCanvasContext(canvas);\n      if (!image || !context) {\n        return reject();\n      }\n      const newImage = new Image();\n      newImage.crossOrigin = 'Anonymous';\n      newImage.src = image;\n      newImage.onload = () => {\n        canvas.width = newImage.width;\n        canvas.height = newImage.height;\n        context.drawImage(newImage, 0, 0, canvas.width, canvas.height);\n        const img = context.getImageData(0, 0, canvas.width, canvas.height);\n\n        bufferToTensorOptions.height = canvas.height;\n        bufferToTensorOptions.width = canvas.width;\n        resolve(bufferToTensor(img.data, bufferToTensorOptions));\n      };\n    });\n  } else {\n    throw new Error('Input data provided is not supported - aborted tensor creation');\n  }\n\n  if (data !== undefined) {\n    return bufferToTensor(data, bufferToTensorOptions);\n  } else {\n    throw new Error('Input data provided is not supported - aborted tensor creation');\n  }\n};\n\n/**\n * implementation of Tensor.fromTexture().\n */\nexport const tensorFromTexture = <T extends TensorInterface.TextureDataTypes>(\n    texture: TensorInterface.TextureType, options: TensorFromTextureOptions<T>): Tensor => {\n  const {width, height, download, dispose} = options;\n  // Always assume RGBAF32. TODO: support different texture format\n  const dims = [1, height, width, 4];\n  return new Tensor({location: 'texture', type: 'float32', texture, dims, download, dispose});\n};\n\n/**\n * implementation of Tensor.fromGpuBuffer().\n */\nexport const tensorFromGpuBuffer = <T extends TensorInterface.GpuBufferDataTypes>(\n    gpuBuffer: TensorInterface.GpuBufferType, options: TensorFromGpuBufferOptions<T>): Tensor => {\n  const {dataType, dims, download, dispose} = options;\n  return new Tensor({location: 'gpu-buffer', type: dataType ?? 'float32', gpuBuffer, dims, download, dispose});\n};\n\n/**\n * implementation of Tensor.fromPinnedBuffer().\n */\nexport const tensorFromPinnedBuffer = <T extends TensorInterface.CpuPinnedDataTypes>(\n    type: T, buffer: TensorInterface.DataTypeMap[T], dims?: readonly number[]): Tensor =>\n    new Tensor({location: 'cpu-pinned', type, data: buffer, dims: dims ?? [buffer.length]});\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Tensor} from './tensor.js';\n\nexport type SupportedTypedArrayConstructors = Float32ArrayConstructor|Uint8ArrayConstructor|Int8ArrayConstructor|\n    Uint16ArrayConstructor|Int16ArrayConstructor|Int32ArrayConstructor|BigInt64ArrayConstructor|Uint8ArrayConstructor|\n    Float64ArrayConstructor|Uint32ArrayConstructor|BigUint64ArrayConstructor;\nexport type SupportedTypedArray = InstanceType<SupportedTypedArrayConstructors>;\n\n// a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.\nexport const NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP = new Map<string, SupportedTypedArrayConstructors>([\n  ['float32', Float32Array],\n  ['uint8', Uint8Array],\n  ['int8', Int8Array],\n  ['uint16', Uint16Array],\n  ['int16', Int16Array],\n  ['int32', Int32Array],\n  ['bool', Uint8Array],\n  ['float64', Float64Array],\n  ['uint32', Uint32Array],\n]);\n\n// a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.\nexport const NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP = new Map<SupportedTypedArrayConstructors, Tensor.Type>([\n  [Float32Array, 'float32'],\n  [Uint8Array, 'uint8'],\n  [Int8Array, 'int8'],\n  [Uint16Array, 'uint16'],\n  [Int16Array, 'int16'],\n  [Int32Array, 'int32'],\n  [Float64Array, 'float64'],\n  [Uint32Array, 'uint32'],\n]);\n\n// a dummy type declaration for Float16Array in case any polyfill is available.\ndeclare global {\n  // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any\n  const Float16Array: any;\n}\n\n// the following code allows delaying execution of BigInt/Float16Array checking. This allows lazy initialization for\n// NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP and NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP, which allows BigInt/Float16Array\n// polyfill if available.\nlet isTypedArrayChecked = false;\nexport const checkTypedArray = () => {\n  if (!isTypedArrayChecked) {\n    isTypedArrayChecked = true;\n    const isBigInt64ArrayAvailable = typeof BigInt64Array !== 'undefined' && BigInt64Array.from;\n    const isBigUint64ArrayAvailable = typeof BigUint64Array !== 'undefined' && BigUint64Array.from;\n    const isFloat16ArrayAvailable = typeof Float16Array !== 'undefined' && Float16Array.from;\n\n    if (isBigInt64ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('int64', BigInt64Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigInt64Array, 'int64');\n    }\n    if (isBigUint64ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('uint64', BigUint64Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigUint64Array, 'uint64');\n    }\n    if (isFloat16ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('float16', Float16Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(Float16Array, 'float16');\n    } else {\n      // if Float16Array is not available, use 'Uint16Array' to store the data.\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('float16', Uint16Array);\n    }\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {CpuPinnedConstructorParameters, GpuBufferConstructorParameters, TextureConstructorParameters} from './tensor-factory.js';\nimport {Tensor} from './tensor-impl.js';\n\n/**\n * calculate size from dims.\n *\n * @param dims the dims array. May be an illegal input.\n */\nexport const calculateSize = (dims: readonly unknown[]): number => {\n  let size = 1;\n  for (let i = 0; i < dims.length; i++) {\n    const dim = dims[i];\n    if (typeof dim !== 'number' || !Number.isSafeInteger(dim)) {\n      throw new TypeError(`dims[${i}] must be an integer, got: ${dim}`);\n    }\n    if (dim < 0) {\n      throw new RangeError(`dims[${i}] must be a non-negative integer, got: ${dim}`);\n    }\n    size *= dim;\n  }\n  return size;\n};\n\n/**\n * implementation of Tensor.reshape()\n */\nexport const tensorReshape = (tensor: Tensor, dims: readonly number[]): Tensor => {\n  switch (tensor.location) {\n    case 'cpu':\n      return new Tensor(tensor.type, tensor.data, dims);\n    case 'cpu-pinned':\n      return new Tensor({\n        location: 'cpu-pinned',\n        data: tensor.data as CpuPinnedConstructorParameters['data'],\n        type: tensor.type as CpuPinnedConstructorParameters['type'],\n        dims,\n      });\n    case 'texture':\n      return new Tensor({\n        location: 'texture',\n        texture: tensor.texture,\n        type: tensor.type as TextureConstructorParameters['type'],\n        dims,\n      });\n    case 'gpu-buffer':\n      return new Tensor({\n        location: 'gpu-buffer',\n        gpuBuffer: tensor.gpuBuffer,\n        type: tensor.type as GpuBufferConstructorParameters['type'],\n        dims,\n      });\n    default:\n      throw new Error(`tensorReshape: tensor location ${tensor.location} is not supported`);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {tensorToDataURL, tensorToImageData} from './tensor-conversion-impl.js';\nimport {TensorToDataUrlOptions, TensorToImageDataOptions} from './tensor-conversion.js';\nimport {tensorFromGpuBuffer, tensorFromImage, tensorFromPinnedBuffer, tensorFromTexture} from './tensor-factory-impl.js';\nimport {CpuPinnedConstructorParameters, GpuBufferConstructorParameters, TensorFromGpuBufferOptions, TensorFromImageBitmapOptions, TensorFromImageDataOptions, TensorFromImageElementOptions, TensorFromTextureOptions, TensorFromUrlOptions, TextureConstructorParameters} from './tensor-factory.js';\nimport {checkTypedArray, NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP, NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP, SupportedTypedArray, SupportedTypedArrayConstructors} from './tensor-impl-type-mapping.js';\nimport {calculateSize, tensorReshape} from './tensor-utils-impl.js';\nimport {Tensor as TensorInterface} from './tensor.js';\n\n// type aliases for those exported from Tensor interface\n\ntype TensorType = TensorInterface.Type;\ntype TensorDataType = TensorInterface.DataType;\ntype TensorDataLocation = TensorInterface.DataLocation;\ntype TensorTextureType = TensorInterface.TextureType;\ntype TensorGpuBufferType = TensorInterface.GpuBufferType;\n\n/**\n * the implementation of Tensor interface.\n *\n * @ignore\n */\nexport class Tensor implements TensorInterface {\n  // #region constructors\n\n  /**\n   * Construct a new CPU tensor object from the given type, data and dims.\n   */\n  constructor(\n      type: TensorType, data: TensorDataType|readonly string[]|readonly number[]|readonly boolean[],\n      dims?: readonly number[]);\n  /**\n   * Construct a new CPU tensor object from the given data and dims. Type is inferred from data.\n   */\n  constructor(data: TensorDataType|readonly string[]|readonly boolean[], dims?: readonly number[]);\n  /**\n   * Construct a new tensor object from the pinned CPU data with the given type and dims.\n   *\n   * Tensor's location will be set to 'cpu-pinned'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: CpuPinnedConstructorParameters);\n  /**\n   * Construct a new tensor object from the WebGL texture with the given type and dims.\n   *\n   * Tensor's location will be set to 'texture'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: TextureConstructorParameters);\n  /**\n   * Construct a new tensor object from the WebGPU buffer with the given type and dims.\n   *\n   * Tensor's location will be set to 'gpu-buffer'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: GpuBufferConstructorParameters);\n\n  /**\n   * implementation.\n   */\n  constructor(\n      arg0: TensorType|TensorDataType|readonly string[]|readonly boolean[]|CpuPinnedConstructorParameters|\n      TextureConstructorParameters|GpuBufferConstructorParameters,\n      arg1?: TensorDataType|readonly number[]|readonly string[]|readonly boolean[], arg2?: readonly number[]) {\n    // perform one-time check for BigInt/Float16Array support\n    checkTypedArray();\n\n    let type: TensorType;\n    let dims: readonly number[];\n\n    if (typeof arg0 === 'object' && 'location' in arg0) {\n      //\n      // constructing tensor from specific location\n      //\n      this.dataLocation = arg0.location;\n      type = arg0.type;\n      dims = arg0.dims;\n      switch (arg0.location) {\n        case 'cpu-pinned': {\n          const expectedTypedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(type);\n          if (!expectedTypedArrayConstructor) {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from pinned buffer`);\n          }\n          if (!(arg0.data instanceof expectedTypedArrayConstructor)) {\n            throw new TypeError(`buffer should be of type ${expectedTypedArrayConstructor.name}`);\n          }\n          this.cpuData = arg0.data;\n          break;\n        }\n        case 'texture': {\n          if (type !== 'float32') {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from texture`);\n          }\n          this.gpuTextureData = arg0.texture;\n          this.downloader = arg0.download;\n          this.disposer = arg0.dispose;\n          break;\n        }\n        case 'gpu-buffer': {\n          if ((type !== 'float32' && type !== 'float16' && type !== 'int32' && type !== 'int64' && type !== 'uint32' &&\n               type !== 'uint8' && type !== 'bool')) {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from gpu buffer`);\n          }\n          this.gpuBufferData = arg0.gpuBuffer;\n          this.downloader = arg0.download;\n          this.disposer = arg0.dispose;\n          break;\n        }\n        default:\n          throw new Error(`Tensor constructor: unsupported location '${this.dataLocation}'`);\n      }\n    } else {\n      //\n      // constructing tensor of location 'cpu'\n      //\n      let data: TensorDataType;\n      let maybeDims: typeof arg1|typeof arg2;\n      // check whether arg0 is type or data\n      if (typeof arg0 === 'string') {\n        //\n        // Override: constructor(type, data, ...)\n        //\n        type = arg0;\n        maybeDims = arg2;\n        if (arg0 === 'string') {\n          // string tensor\n          if (!Array.isArray(arg1)) {\n            throw new TypeError('A string tensor\\'s data must be a string array.');\n          }\n          // we don't check whether every element in the array is string; this is too slow. we assume it's correct and\n          // error will be populated at inference\n          data = arg1;\n        } else {\n          // numeric tensor\n          const typedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(arg0);\n          if (typedArrayConstructor === undefined) {\n            throw new TypeError(`Unsupported tensor type: ${arg0}.`);\n          }\n          if (Array.isArray(arg1)) {\n            if (arg0 === 'float16' && typedArrayConstructor === Uint16Array) {\n              // When no Float16Array polyfill is used, we cannot create 'float16' tensor from number array.\n              //\n              // Throw error here because when user try to use number array as data,\n              // e.g. new Tensor('float16', [1, 2, 3, 4], dims)), it will actually call\n              // Uint16Array.from(arg1) which generates wrong data.\n              throw new TypeError(\n                  'Creating a float16 tensor from number array is not supported. Please use Uint16Array as data.');\n            } else if (arg0 === 'uint64' || arg0 === 'int64') {\n              // use 'as any' here because:\n              // 1. TypeScript's check on type of 'Array.isArray()' does not work with readonly arrays.\n              // see https://github.com/microsoft/TypeScript/issues/17002\n              // 2. TypeScript's check on union type of '(BigInt64ArrayConstructor|BigUint64ArrayConstructor).from()'\n              // does not accept parameter mapFn.\n              // 3. parameters of 'SupportedTypedArrayConstructors.from()' does not match the requirement of the union\n              // type.\n\n              // assume 'arg1' is of type \"readonly number[]|readonly bigint[]\" here.\n\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              data = (typedArrayConstructor as any).from(arg1, BigInt);\n            } else {\n              // assume 'arg1' is of type \"readonly number[]\" here.\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              data = (typedArrayConstructor as any).from(arg1);\n            }\n          } else if (arg1 instanceof typedArrayConstructor) {\n            data = arg1;\n          } else {\n            throw new TypeError(`A ${type} tensor's data must be type of ${typedArrayConstructor}`);\n          }\n        }\n      } else {\n        //\n        // Override: constructor(data, ...)\n        //\n        maybeDims = arg1;\n        if (Array.isArray(arg0)) {\n          // only boolean[] and string[] is supported\n          if (arg0.length === 0) {\n            throw new TypeError('Tensor type cannot be inferred from an empty array.');\n          }\n          const firstElementType = typeof arg0[0];\n          if (firstElementType === 'string') {\n            type = 'string';\n            data = arg0;\n          } else if (firstElementType === 'boolean') {\n            type = 'bool';\n            // 'arg0' is of type 'boolean[]'. Uint8Array.from(boolean[]) actually works, but typescript thinks this is\n            // wrong type. We use 'as any' to make it happy.\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            data = Uint8Array.from(arg0 as any[]);\n          } else {\n            throw new TypeError(`Invalid element type of data array: ${firstElementType}.`);\n          }\n        } else {\n          // get tensor type from TypedArray\n          const mappedType =\n              NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.get(arg0.constructor as SupportedTypedArrayConstructors);\n          if (mappedType === undefined) {\n            throw new TypeError(`Unsupported type for tensor data: ${arg0.constructor}.`);\n          }\n          type = mappedType;\n          data = arg0 as SupportedTypedArray;\n        }\n      }\n\n      // type and data is processed, now processing dims\n      if (maybeDims === undefined) {\n        // assume 1-D tensor if dims omitted\n        maybeDims = [data.length];\n      } else if (!Array.isArray(maybeDims)) {\n        throw new TypeError('A tensor\\'s dims must be a number array');\n      }\n      dims = maybeDims as readonly number[];\n\n      this.cpuData = data;\n      this.dataLocation = 'cpu';\n    }\n\n    // perform check on dims\n    const size = calculateSize(dims);\n    // if data is on CPU, check whether data length matches tensor size\n    if (this.cpuData && size !== this.cpuData.length) {\n      throw new Error(`Tensor's size(${size}) does not match data length(${this.cpuData.length}).`);\n    }\n\n    this.type = type;\n    this.dims = dims;\n    this.size = size;\n  }\n  // #endregion\n\n  // #region factory\n  static async fromImage(\n      image: ImageData|HTMLImageElement|ImageBitmap|string,\n      options?: TensorFromImageDataOptions|TensorFromImageElementOptions|TensorFromImageBitmapOptions|\n      TensorFromUrlOptions): Promise<TensorInterface> {\n    return tensorFromImage(image, options);\n  }\n\n  static fromTexture<T extends TensorInterface.TextureDataTypes>(\n      texture: TensorTextureType, options: TensorFromTextureOptions<T>): TensorInterface {\n    return tensorFromTexture(texture, options);\n  }\n\n  static fromGpuBuffer<T extends TensorInterface.GpuBufferDataTypes>(\n      gpuBuffer: TensorGpuBufferType, options: TensorFromGpuBufferOptions<T>): TensorInterface {\n    return tensorFromGpuBuffer(gpuBuffer, options);\n  }\n\n  static fromPinnedBuffer<T extends TensorInterface.CpuPinnedDataTypes>(\n      type: T, buffer: TensorInterface.DataTypeMap[T], dims?: readonly number[]): Tensor {\n    return tensorFromPinnedBuffer(type, buffer, dims);\n  }\n\n  // #endregion\n\n  // #region conversions\n  toDataURL(options?: TensorToDataUrlOptions): string {\n    return tensorToDataURL(this, options);\n  }\n\n  toImageData(options?: TensorToImageDataOptions): ImageData {\n    return tensorToImageData(this, options);\n  }\n  // #endregion\n\n  // #region public fields\n  readonly dims: readonly number[];\n  readonly type: TensorType;\n  readonly size: number;\n  // #endregion\n\n  // #region private fields\n\n  /**\n   * stores the location of the data.\n   */\n  private dataLocation: TensorDataLocation;\n\n  /**\n   * stores the data on CPU, if location is 'cpu' or 'cpu-pinned'. otherwise empty.\n   */\n  private cpuData?: TensorDataType;\n\n  /**\n   * stores the underlying texture when location is 'texture'. otherwise empty.\n   */\n  private gpuTextureData?: TensorTextureType;\n\n  /**\n   * stores the underlying GPU buffer when location is 'gpu-buffer'. otherwise empty.\n   */\n  private gpuBufferData?: TensorGpuBufferType;\n\n  /**\n   * stores an optional downloader function to download data from GPU to CPU.\n   */\n  private downloader?(): Promise<TensorDataType>;\n\n  /**\n   * a flag indicating whether the data is being downloaded from GPU to CPU.\n   */\n  private isDownloading?: boolean;\n\n  /**\n   * stores an optional disposer function to dispose the underlying data.\n   */\n  private disposer?(): void;\n  // #endregion\n\n  // #region properties\n  get data(): TensorDataType {\n    this.ensureValid();\n    if (!this.cpuData) {\n      throw new Error(\n          'The data is not on CPU. Use `getData()` to download GPU data to CPU, ' +\n          'or use `texture` or `gpuBuffer` property to access the GPU data directly.');\n    }\n    return this.cpuData;\n  }\n\n  get location(): TensorDataLocation {\n    return this.dataLocation;\n  }\n\n  get texture(): TensorTextureType {\n    this.ensureValid();\n    if (!this.gpuTextureData) {\n      throw new Error('The data is not stored as a WebGL texture.');\n    }\n    return this.gpuTextureData;\n  }\n\n  get gpuBuffer(): TensorGpuBufferType {\n    this.ensureValid();\n    if (!this.gpuBufferData) {\n      throw new Error('The data is not stored as a WebGPU buffer.');\n    }\n    return this.gpuBufferData;\n  }\n  // #endregion\n\n  // #region methods\n\n  async getData(releaseData?: boolean): Promise<TensorDataType> {\n    this.ensureValid();\n    switch (this.dataLocation) {\n      case 'cpu':\n      case 'cpu-pinned':\n        return this.data;\n      case 'texture':\n      case 'gpu-buffer': {\n        if (!this.downloader) {\n          throw new Error('The current tensor is not created with a specified data downloader.');\n        }\n        if (this.isDownloading) {\n          throw new Error('The current tensor is being downloaded.');\n        }\n        try {\n          this.isDownloading = true;\n          const data = await this.downloader();\n          this.downloader = undefined;\n          this.dataLocation = 'cpu';\n          this.cpuData = data;\n\n          if (releaseData && this.disposer) {\n            this.disposer();\n            this.disposer = undefined;\n          }\n\n          return data;\n\n        } finally {\n          this.isDownloading = false;\n        }\n      }\n      default:\n        throw new Error(`cannot get data from location: ${this.dataLocation}`);\n    }\n  }\n\n  dispose(): void {\n    if (this.isDownloading) {\n      throw new Error('The current tensor is being downloaded.');\n    }\n\n    if (this.disposer) {\n      this.disposer();\n      this.disposer = undefined;\n    }\n    this.cpuData = undefined;\n    this.gpuTextureData = undefined;\n    this.gpuBufferData = undefined;\n    this.downloader = undefined;\n    this.isDownloading = undefined;\n\n    this.dataLocation = 'none';\n  }\n\n  // #endregion\n\n  // #region tensor utilities\n  private ensureValid(): void {\n    if (this.dataLocation === 'none') {\n      throw new Error('The tensor is disposed.');\n    }\n  }\n\n  reshape(dims: readonly number[]): TensorInterface {\n    this.ensureValid();\n    if (this.downloader || this.disposer) {\n      throw new Error('Cannot reshape a tensor that owns GPU resource.');\n    }\n    return tensorReshape(this, dims);\n  }\n  // #endregion\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorFactory} from './tensor-factory.js';\nimport {Tensor as TensorImpl} from './tensor-impl.js';\nimport {TypedTensorUtils} from './tensor-utils.js';\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\n/**\n * represent a basic tensor with specified dimensions and data type.\n */\ninterface TypedTensorBase<T extends Tensor.Type> {\n  /**\n   * Get the dimensions of the tensor.\n   */\n  readonly dims: readonly number[];\n  /**\n   * Get the data type of the tensor.\n   */\n  readonly type: T;\n  /**\n   * Get the buffer data of the tensor.\n   *\n   * If the data is not on CPU (eg. it's in the form of WebGL texture or WebGPU buffer), throw error.\n   */\n  readonly data: Tensor.DataTypeMap[T];\n  /**\n   * Get the location of the data.\n   */\n  readonly location: Tensor.DataLocation;\n  /**\n   * Get the WebGL texture that holds the tensor data.\n   *\n   * If the data is not on GPU as WebGL texture, throw error.\n   */\n  readonly texture: Tensor.TextureType;\n  /**\n   * Get the WebGPU buffer that holds the tensor data.\n   *\n   * If the data is not on GPU as WebGPU buffer, throw error.\n   */\n  readonly gpuBuffer: Tensor.GpuBufferType;\n\n  /**\n   * Get the buffer data of the tensor.\n   *\n   * If the data is on CPU, returns the data immediately.\n   * If the data is on GPU, downloads the data and returns the promise.\n   *\n   * @param releaseData - whether release the data on GPU. Ignore if data is already on CPU.\n   */\n  getData(releaseData?: boolean): Promise<Tensor.DataTypeMap[T]>;\n\n  /**\n   * Dispose the tensor data.\n   *\n   * If the data is on CPU, remove its internal reference to the underlying data.\n   * If the data is on GPU, release the data on GPU.\n   *\n   * After calling this function, the tensor is considered no longer valid. Its location will be set to 'none'.\n   */\n  dispose(): void;\n}\n\nexport declare namespace Tensor {\n  interface DataTypeMap {\n    float32: Float32Array;\n    uint8: Uint8Array;\n    int8: Int8Array;\n    uint16: Uint16Array;\n    int16: Int16Array;\n    int32: Int32Array;\n    int64: BigInt64Array;\n    string: string[];\n    bool: Uint8Array;\n    float16: Uint16Array;  // Keep using Uint16Array until we have a concrete solution for float 16.\n    float64: Float64Array;\n    uint32: Uint32Array;\n    uint64: BigUint64Array;\n    // complex64: never;\n    // complex128: never;\n    // bfloat16: never;\n  }\n\n  interface ElementTypeMap {\n    float32: number;\n    uint8: number;\n    int8: number;\n    uint16: number;\n    int16: number;\n    int32: number;\n    int64: bigint;\n    string: string;\n    bool: boolean;\n    float16: number;  // Keep using Uint16Array until we have a concrete solution for float 16.\n    float64: number;\n    uint32: number;\n    uint64: bigint;\n    // complex64: never;\n    // complex128: never;\n    // bfloat16: never;\n  }\n\n  type DataType = DataTypeMap[Type];\n  type ElementType = ElementTypeMap[Type];\n\n  /**\n   * supported data types for constructing a tensor from a pinned CPU buffer\n   */\n  export type CpuPinnedDataTypes = Exclude<Tensor.Type, 'string'>;\n\n  /**\n   * type alias for WebGL texture\n   */\n  export type TextureType = WebGLTexture;\n\n  /**\n   * supported data types for constructing a tensor from a WebGL texture\n   */\n  export type TextureDataTypes = 'float32';\n\n  /**\n   * type alias for WebGPU buffer\n   *\n   * The reason why we don't use type \"GPUBuffer\" defined in webgpu.d.ts from @webgpu/types is because \"@webgpu/types\"\n   * requires \"@types/dom-webcodecs\" as peer dependency when using TypeScript < v5.1 and its version need to be chosen\n   * carefully according to the TypeScript version being used. This means so far there is not a way to keep every\n   * TypeScript version happy. It turns out that we will easily broke users on some TypeScript version.\n   *\n   * for more info see https://github.com/gpuweb/types/issues/127\n   */\n  export type GpuBufferType = {size: number; mapState: 'unmapped' | 'pending' | 'mapped'};\n\n  /**\n   * supported data types for constructing a tensor from a WebGPU buffer\n   */\n  export type GpuBufferDataTypes = 'float32'|'float16'|'int32'|'int64'|'uint32'|'uint8'|'bool';\n\n  /**\n   * represent where the tensor data is stored\n   */\n  export type DataLocation = 'none'|'cpu'|'cpu-pinned'|'texture'|'gpu-buffer';\n\n  /**\n   * represent the data type of a tensor\n   */\n  export type Type = keyof DataTypeMap;\n}\n\n/**\n * Represent multi-dimensional arrays to feed to or fetch from model inferencing.\n */\nexport interface TypedTensor<T extends Tensor.Type> extends TypedTensorBase<T>, TypedTensorUtils<T> {}\n/**\n * Represent multi-dimensional arrays to feed to or fetch from model inferencing.\n */\nexport interface Tensor extends TypedTensorBase<Tensor.Type>, TypedTensorUtils<Tensor.Type> {}\n\n/**\n * type TensorConstructor defines the constructors of 'Tensor' to create CPU tensor instances.\n */\nexport interface TensorConstructor extends TensorFactory {\n  // #region CPU tensor - specify element type\n  /**\n   * Construct a new string tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(type: 'string', data: Tensor.DataTypeMap['string']|readonly string[],\n      dims?: readonly number[]): TypedTensor<'string'>;\n\n  /**\n   * Construct a new bool tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(type: 'bool', data: Tensor.DataTypeMap['bool']|readonly boolean[], dims?: readonly number[]): TypedTensor<'bool'>;\n\n  /**\n   * Construct a new 64-bit integer typed tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new<T extends 'uint64'|'int64'>(\n      type: T, data: Tensor.DataTypeMap[T]|readonly bigint[]|readonly number[],\n      dims?: readonly number[]): TypedTensor<T>;\n\n  /**\n   * Construct a new numeric tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new<T extends Exclude<Tensor.Type, 'string'|'bool'|'uint64'|'int64'>>(\n      type: T, data: Tensor.DataTypeMap[T]|readonly number[], dims?: readonly number[]): TypedTensor<T>;\n  // #endregion\n\n  // #region CPU tensor - infer element types\n\n  /**\n   * Construct a new float32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Float32Array, dims?: readonly number[]): TypedTensor<'float32'>;\n\n  /**\n   * Construct a new int8 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Int8Array, dims?: readonly number[]): TypedTensor<'int8'>;\n\n  /**\n   * Construct a new uint8 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Uint8Array, dims?: readonly number[]): TypedTensor<'uint8'>;\n\n  /**\n   * Construct a new uint16 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Uint16Array, dims?: readonly number[]): TypedTensor<'uint16'>;\n\n  /**\n   * Construct a new int16 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Int16Array, dims?: readonly number[]): TypedTensor<'int16'>;\n\n  /**\n   * Construct a new int32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Int32Array, dims?: readonly number[]): TypedTensor<'int32'>;\n\n  /**\n   * Construct a new int64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: BigInt64Array, dims?: readonly number[]): TypedTensor<'int64'>;\n\n  /**\n   * Construct a new string tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: readonly string[], dims?: readonly number[]): TypedTensor<'string'>;\n\n  /**\n   * Construct a new bool tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: readonly boolean[], dims?: readonly number[]): TypedTensor<'bool'>;\n\n  /**\n   * Construct a new float64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Float64Array, dims?: readonly number[]): TypedTensor<'float64'>;\n\n  /**\n   * Construct a new uint32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Uint32Array, dims?: readonly number[]): TypedTensor<'uint32'>;\n\n  /**\n   * Construct a new uint64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: BigUint64Array, dims?: readonly number[]): TypedTensor<'uint64'>;\n\n  // #endregion\n\n  // #region CPU tensor - fall back to non-generic tensor type declaration\n\n  /**\n   * Construct a new tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(type: Tensor.Type, data: Tensor.DataType|readonly number[]|readonly string[]|readonly bigint[]|readonly boolean[],\n      dims?: readonly number[]): Tensor;\n\n  /**\n   * Construct a new tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Tensor.DataType, dims?: readonly number[]): Tensor;\n  // #endregion\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const Tensor = TensorImpl as TensorConstructor;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {env} from './env-impl.js';\n\n/**\n * @ignore\n */\nexport const TRACE = (deviceType: string, label: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  // eslint-disable-next-line no-console\n  console.timeStamp(`${deviceType}::ORT::${label}`);\n};\n\nconst TRACE_FUNC = (msg: string, extraMsg?: string) => {\n  const stack = new Error().stack?.split(/\\r\\n|\\r|\\n/g) || [];\n  let hasTraceFunc = false;\n  for (let i = 0; i < stack.length; i++) {\n    if (hasTraceFunc && !stack[i].includes('TRACE_FUNC')) {\n      let label = `FUNC_${msg}::${stack[i].trim().split(' ')[1]}`;\n      if (extraMsg) {\n        label += `::${extraMsg}`;\n      }\n      TRACE('CPU', label);\n      return;\n    }\n    if (stack[i].includes('TRACE_FUNC')) {\n      hasTraceFunc = true;\n    }\n  }\n};\n\n/**\n * @ignore\n */\nexport const TRACE_FUNC_BEGIN = (extraMsg?: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  TRACE_FUNC('BEGIN', extraMsg);\n};\n\n/**\n * @ignore\n */\nexport const TRACE_FUNC_END = (extraMsg?: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  TRACE_FUNC('END', extraMsg);\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {resolveBackendAndExecutionProviders} from './backend-impl.js';\nimport {InferenceSessionHandler} from './backend.js';\nimport {InferenceSession as InferenceSessionInterface} from './inference-session.js';\nimport {OnnxValue} from './onnx-value.js';\nimport {Tensor} from './tensor.js';\nimport {TRACE_FUNC_BEGIN, TRACE_FUNC_END} from './trace.js';\n\ntype SessionOptions = InferenceSessionInterface.SessionOptions;\ntype RunOptions = InferenceSessionInterface.RunOptions;\ntype FeedsType = InferenceSessionInterface.FeedsType;\ntype FetchesType = InferenceSessionInterface.FetchesType;\ntype ReturnType = InferenceSessionInterface.ReturnType;\n\nexport class InferenceSession implements InferenceSessionInterface {\n  private constructor(handler: InferenceSessionHandler) {\n    this.handler = handler;\n  }\n  run(feeds: FeedsType, options?: RunOptions): Promise<ReturnType>;\n  run(feeds: FeedsType, fetches: FetchesType, options?: RunOptions): Promise<ReturnType>;\n  async run(feeds: FeedsType, arg1?: FetchesType|RunOptions, arg2?: RunOptions): Promise<ReturnType> {\n    TRACE_FUNC_BEGIN();\n    const fetches: {[name: string]: OnnxValue|null} = {};\n    let options: RunOptions = {};\n    // check inputs\n    if (typeof feeds !== 'object' || feeds === null || feeds instanceof Tensor || Array.isArray(feeds)) {\n      throw new TypeError(\n          '\\'feeds\\' must be an object that use input names as keys and OnnxValue as corresponding values.');\n    }\n\n    let isFetchesEmpty = true;\n    // determine which override is being used\n    if (typeof arg1 === 'object') {\n      if (arg1 === null) {\n        throw new TypeError('Unexpected argument[1]: cannot be null.');\n      }\n      if (arg1 instanceof Tensor) {\n        throw new TypeError('\\'fetches\\' cannot be a Tensor');\n      }\n\n      if (Array.isArray(arg1)) {\n        if (arg1.length === 0) {\n          throw new TypeError('\\'fetches\\' cannot be an empty array.');\n        }\n        isFetchesEmpty = false;\n        // output names\n        for (const name of arg1) {\n          if (typeof name !== 'string') {\n            throw new TypeError('\\'fetches\\' must be a string array or an object.');\n          }\n          if (this.outputNames.indexOf(name) === -1) {\n            throw new RangeError(`'fetches' contains invalid output name: ${name}.`);\n          }\n          fetches[name] = null;\n        }\n\n        if (typeof arg2 === 'object' && arg2 !== null) {\n          options = arg2;\n        } else if (typeof arg2 !== 'undefined') {\n          throw new TypeError('\\'options\\' must be an object.');\n        }\n      } else {\n        // decide whether arg1 is fetches or options\n        // if any output name is present and its value is valid OnnxValue, we consider it fetches\n        let isFetches = false;\n        const arg1Keys = Object.getOwnPropertyNames(arg1);\n        for (const name of this.outputNames) {\n          if (arg1Keys.indexOf(name) !== -1) {\n            const v = (arg1 as InferenceSessionInterface.NullableOnnxValueMapType)[name];\n            if (v === null || v instanceof Tensor) {\n              isFetches = true;\n              isFetchesEmpty = false;\n              fetches[name] = v;\n            }\n          }\n        }\n\n        if (isFetches) {\n          if (typeof arg2 === 'object' && arg2 !== null) {\n            options = arg2;\n          } else if (typeof arg2 !== 'undefined') {\n            throw new TypeError('\\'options\\' must be an object.');\n          }\n        } else {\n          options = arg1 as RunOptions;\n        }\n      }\n    } else if (typeof arg1 !== 'undefined') {\n      throw new TypeError('Unexpected argument[1]: must be \\'fetches\\' or \\'options\\'.');\n    }\n\n    // check if all inputs are in feed\n    for (const name of this.inputNames) {\n      if (typeof feeds[name] === 'undefined') {\n        throw new Error(`input '${name}' is missing in 'feeds'.`);\n      }\n    }\n\n    // if no fetches is specified, we use the full output names list\n    if (isFetchesEmpty) {\n      for (const name of this.outputNames) {\n        fetches[name] = null;\n      }\n    }\n\n    // feeds, fetches and options are prepared\n\n    const results = await this.handler.run(feeds, fetches, options);\n    const returnValue: {[name: string]: OnnxValue} = {};\n    for (const key in results) {\n      if (Object.hasOwnProperty.call(results, key)) {\n        const result = results[key];\n        if (result instanceof Tensor) {\n          returnValue[key] = result;\n        } else {\n          returnValue[key] = new Tensor(result.type, result.data, result.dims);\n        }\n      }\n    }\n    TRACE_FUNC_END();\n    return returnValue;\n  }\n\n  async release(): Promise<void> {\n    return this.handler.dispose();\n  }\n\n  static create(path: string, options?: SessionOptions): Promise<InferenceSessionInterface>;\n  static create(buffer: ArrayBufferLike, options?: SessionOptions): Promise<InferenceSessionInterface>;\n  static create(buffer: ArrayBufferLike, byteOffset: number, byteLength?: number, options?: SessionOptions):\n      Promise<InferenceSessionInterface>;\n  static create(buffer: Uint8Array, options?: SessionOptions): Promise<InferenceSessionInterface>;\n  static async create(\n      arg0: string|ArrayBufferLike|Uint8Array, arg1?: SessionOptions|number, arg2?: number,\n      arg3?: SessionOptions): Promise<InferenceSessionInterface> {\n    TRACE_FUNC_BEGIN();\n    // either load from a file or buffer\n    let filePathOrUint8Array: string|Uint8Array;\n    let options: SessionOptions = {};\n\n    if (typeof arg0 === 'string') {\n      filePathOrUint8Array = arg0;\n      if (typeof arg1 === 'object' && arg1 !== null) {\n        options = arg1;\n      } else if (typeof arg1 !== 'undefined') {\n        throw new TypeError('\\'options\\' must be an object.');\n      }\n    } else if (arg0 instanceof Uint8Array) {\n      filePathOrUint8Array = arg0;\n      if (typeof arg1 === 'object' && arg1 !== null) {\n        options = arg1;\n      } else if (typeof arg1 !== 'undefined') {\n        throw new TypeError('\\'options\\' must be an object.');\n      }\n    } else if (\n        arg0 instanceof ArrayBuffer ||\n        (typeof SharedArrayBuffer !== 'undefined' && arg0 instanceof SharedArrayBuffer)) {\n      const buffer = arg0;\n      let byteOffset = 0;\n      let byteLength = arg0.byteLength;\n      if (typeof arg1 === 'object' && arg1 !== null) {\n        options = arg1;\n      } else if (typeof arg1 === 'number') {\n        byteOffset = arg1;\n        if (!Number.isSafeInteger(byteOffset)) {\n          throw new RangeError('\\'byteOffset\\' must be an integer.');\n        }\n        if (byteOffset < 0 || byteOffset >= buffer.byteLength) {\n          throw new RangeError(`'byteOffset' is out of range [0, ${buffer.byteLength}).`);\n        }\n        byteLength = arg0.byteLength - byteOffset;\n        if (typeof arg2 === 'number') {\n          byteLength = arg2;\n          if (!Number.isSafeInteger(byteLength)) {\n            throw new RangeError('\\'byteLength\\' must be an integer.');\n          }\n          if (byteLength <= 0 || byteOffset + byteLength > buffer.byteLength) {\n            throw new RangeError(`'byteLength' is out of range (0, ${buffer.byteLength - byteOffset}].`);\n          }\n          if (typeof arg3 === 'object' && arg3 !== null) {\n            options = arg3;\n          } else if (typeof arg3 !== 'undefined') {\n            throw new TypeError('\\'options\\' must be an object.');\n          }\n        } else if (typeof arg2 !== 'undefined') {\n          throw new TypeError('\\'byteLength\\' must be a number.');\n        }\n      } else if (typeof arg1 !== 'undefined') {\n        throw new TypeError('\\'options\\' must be an object.');\n      }\n      filePathOrUint8Array = new Uint8Array(buffer, byteOffset, byteLength);\n    } else {\n      throw new TypeError('Unexpected argument[0]: must be \\'path\\' or \\'buffer\\'.');\n    }\n\n    // resolve backend, update session options with validated EPs, and create session handler\n    const [backend, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);\n    const handler = await backend.createInferenceSessionHandler(filePathOrUint8Array, optionsWithValidatedEPs);\n    TRACE_FUNC_END();\n    return new InferenceSession(handler);\n  }\n\n  startProfiling(): void {\n    this.handler.startProfiling();\n  }\n  endProfiling(): void {\n    this.handler.endProfiling();\n  }\n\n  get inputNames(): readonly string[] {\n    return this.handler.inputNames;\n  }\n  get outputNames(): readonly string[] {\n    return this.handler.outputNames;\n  }\n\n  private handler: InferenceSessionHandler;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {InferenceSession as InferenceSessionImpl} from './inference-session-impl.js';\nimport {OnnxModelOptions} from './onnx-model.js';\nimport {OnnxValue, OnnxValueDataLocation} from './onnx-value.js';\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\nexport declare namespace InferenceSession {\n  // #region input/output types\n\n  type OnnxValueMapType = {readonly [name: string]: OnnxValue};\n  type NullableOnnxValueMapType = {readonly [name: string]: OnnxValue | null};\n\n  /**\n   * A feeds (model inputs) is an object that uses input names as keys and OnnxValue as corresponding values.\n   */\n  type FeedsType = OnnxValueMapType;\n\n  /**\n   * A fetches (model outputs) could be one of the following:\n   *\n   * - Omitted. Use model's output names definition.\n   * - An array of string indicating the output names.\n   * - An object that use output names as keys and OnnxValue or null as corresponding values.\n   *\n   * @remark\n   * different from input argument, in output, OnnxValue is optional. If an OnnxValue is present it will be\n   * used as a pre-allocated value by the inference engine; if omitted, inference engine will allocate buffer\n   * internally.\n   */\n  type FetchesType = readonly string[]|NullableOnnxValueMapType;\n\n  /**\n   * A inferencing return type is an object that uses output names as keys and OnnxValue as corresponding values.\n   */\n  type ReturnType = OnnxValueMapType;\n\n  // #endregion\n\n  // #region session options\n\n  /**\n   * A set of configurations for session behavior.\n   */\n  export interface SessionOptions extends OnnxModelOptions {\n    /**\n     * An array of execution provider options.\n     *\n     * An execution provider option can be a string indicating the name of the execution provider,\n     * or an object of corresponding type.\n     */\n    executionProviders?: readonly ExecutionProviderConfig[];\n\n    /**\n     * The intra OP threads number.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native).\n     */\n    intraOpNumThreads?: number;\n\n    /**\n     * The inter OP threads number.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native).\n     */\n    interOpNumThreads?: number;\n\n    /**\n     * The free dimension override.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    freeDimensionOverrides?: {readonly [dimensionName: string]: number};\n\n    /**\n     * The optimization level.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    graphOptimizationLevel?: 'disabled'|'basic'|'extended'|'all';\n\n    /**\n     * Whether enable CPU memory arena.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    enableCpuMemArena?: boolean;\n\n    /**\n     * Whether enable memory pattern.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    enableMemPattern?: boolean;\n\n    /**\n     * Execution mode.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    executionMode?: 'sequential'|'parallel';\n\n    /**\n     * Optimized model file path.\n     *\n     * If this setting is specified, the optimized model will be dumped. In browser, a blob will be created\n     * with a pop-up window.\n     */\n    optimizedModelFilePath?: string;\n\n    /**\n     * Whether enable profiling.\n     *\n     * This setting is a placeholder for a future use.\n     */\n    enableProfiling?: boolean;\n\n    /**\n     * File prefix for profiling.\n     *\n     * This setting is a placeholder for a future use.\n     */\n    profileFilePrefix?: string;\n\n    /**\n     * Log ID.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    logId?: string;\n\n    /**\n     * Log severity level. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/common/logging/severity.h\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    logSeverityLevel?: 0|1|2|3|4;\n\n    /**\n     * Log verbosity level.\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     */\n    logVerbosityLevel?: number;\n\n    /**\n     * Specify string as a preferred data location for all outputs, or an object that use output names as keys and a\n     * preferred data location as corresponding values.\n     *\n     * This setting is available only in ONNXRuntime Web for WebGL and WebGPU EP.\n     */\n    preferredOutputLocation?: OnnxValueDataLocation|{readonly [outputName: string]: OnnxValueDataLocation};\n\n    /**\n     * Whether enable graph capture.\n     * This setting is available only in ONNXRuntime Web for WebGPU EP.\n     */\n    enableGraphCapture?: boolean;\n\n    /**\n     * Store configurations for a session. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/session/\n     * onnxruntime_session_options_config_keys.h\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     *\n     * @example\n     * ```js\n     * extra: {\n     *   session: {\n     *     set_denormal_as_zero: \"1\",\n     *     disable_prepacking: \"1\"\n     *   },\n     *   optimization: {\n     *     enable_gelu_approximation: \"1\"\n     *   }\n     * }\n     * ```\n     */\n    extra?: Record<string, unknown>;\n  }\n\n  // #region execution providers\n\n  // Currently, we have the following backends to support execution providers:\n  // Backend Node.js binding: supports 'cpu', 'dml' (win32), 'coreml' (macOS) and 'cuda' (linux).\n  // Backend WebAssembly: supports 'cpu', 'wasm', 'webgpu' and 'webnn'.\n  // Backend ONNX.js: supports 'webgl'.\n  // Backend React Native: supports 'cpu', 'xnnpack', 'coreml' (iOS), 'nnapi' (Android).\n  interface ExecutionProviderOptionMap {\n    coreml: CoreMLExecutionProviderOption;\n    cpu: CpuExecutionProviderOption;\n    cuda: CudaExecutionProviderOption;\n    dml: DmlExecutionProviderOption;\n    nnapi: NnapiExecutionProviderOption;\n    tensorrt: TensorRtExecutionProviderOption;\n    wasm: WebAssemblyExecutionProviderOption;\n    webgl: WebGLExecutionProviderOption;\n    webgpu: WebGpuExecutionProviderOption;\n    webnn: WebNNExecutionProviderOption;\n    xnnpack: XnnpackExecutionProviderOption;\n  }\n\n  type ExecutionProviderName = keyof ExecutionProviderOptionMap;\n  type ExecutionProviderConfig =\n      ExecutionProviderOptionMap[ExecutionProviderName]|ExecutionProviderOption|ExecutionProviderName|string;\n\n  export interface ExecutionProviderOption {\n    readonly name: string;\n  }\n  export interface CpuExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'cpu';\n    useArena?: boolean;\n  }\n  export interface CudaExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'cuda';\n    deviceId?: number;\n  }\n  export interface DmlExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'dml';\n    deviceId?: number;\n  }\n  export interface TensorRtExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'tensorrt';\n    deviceId?: number;\n  }\n  export interface WebAssemblyExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'wasm';\n  }\n  export interface WebGLExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'webgl';\n    // TODO: add flags\n  }\n  export interface XnnpackExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'xnnpack';\n  }\n  export interface WebGpuExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'webgpu';\n    preferredLayout?: 'NCHW'|'NHWC';\n  }\n  export interface WebNNExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'webnn';\n    deviceType?: 'cpu'|'gpu'|'npu';\n    numThreads?: number;\n    powerPreference?: 'default'|'low-power'|'high-performance';\n  }\n  export interface CoreMLExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'coreml';\n    /**\n     * The bit flags for CoreML execution provider.\n     *\n     * ```\n     * COREML_FLAG_USE_CPU_ONLY = 0x001\n     * COREML_FLAG_ENABLE_ON_SUBGRAPH = 0x002\n     * COREML_FLAG_ONLY_ENABLE_DEVICE_WITH_ANE = 0x004\n     * COREML_FLAG_ONLY_ALLOW_STATIC_INPUT_SHAPES = 0x008\n     * COREML_FLAG_CREATE_MLPROGRAM = 0x010\n     * ```\n     *\n     * See include/onnxruntime/core/providers/coreml/coreml_provider_factory.h for more details.\n     *\n     * This flag is available only in ONNXRuntime (Node.js binding).\n     */\n    coreMlFlags?: number;\n    /**\n     * Specify whether to use CPU only in CoreML EP.\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    useCPUOnly?: boolean;\n    /**\n     * Specify whether to enable CoreML EP on subgraph.\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    enableOnSubgraph?: boolean;\n    /**\n     * Specify whether to only enable CoreML EP for Apple devices with ANE (Apple Neural Engine).\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    onlyEnableDeviceWithANE?: boolean;\n  }\n  export interface NnapiExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'nnapi';\n    useFP16?: boolean;\n    useNCHW?: boolean;\n    cpuDisabled?: boolean;\n    cpuOnly?: boolean;\n  }\n  // #endregion\n\n  // #endregion\n\n  // #region run options\n\n  /**\n   * A set of configurations for inference run behavior\n   */\n  export interface RunOptions {\n    /**\n     * Log severity level. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/common/logging/severity.h\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    logSeverityLevel?: 0|1|2|3|4;\n\n    /**\n     * Log verbosity level.\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     */\n    logVerbosityLevel?: number;\n\n    /**\n     * Terminate all incomplete OrtRun calls as soon as possible if true\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     */\n    terminate?: boolean;\n\n    /**\n     * A tag for the Run() calls using this\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    tag?: string;\n\n    /**\n     * Set a single run configuration entry. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/session/\n     * onnxruntime_run_options_config_keys.h\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     *\n     * @example\n     *\n     * ```js\n     * extra: {\n     *   memory: {\n     *     enable_memory_arena_shrinkage: \"1\",\n     *   }\n     * }\n     * ```\n     */\n    extra?: Record<string, unknown>;\n  }\n\n  // #endregion\n\n  // #region value metadata\n\n  // eslint-disable-next-line @typescript-eslint/no-empty-interface\n  interface ValueMetadata {\n    // TBD\n  }\n\n  // #endregion\n}\n\n/**\n * Represent a runtime instance of an ONNX model.\n */\nexport interface InferenceSession {\n  // #region run()\n\n  /**\n   * Execute the model asynchronously with the given feeds and options.\n   *\n   * @param feeds - Representation of the model input. See type description of `InferenceSession.InputType` for detail.\n   * @param options - Optional. A set of options that controls the behavior of model inference.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding values.\n   */\n  run(feeds: InferenceSession.FeedsType, options?: InferenceSession.RunOptions): Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Execute the model asynchronously with the given feeds, fetches and options.\n   *\n   * @param feeds - Representation of the model input. See type description of `InferenceSession.InputType` for detail.\n   * @param fetches - Representation of the model output. See type description of `InferenceSession.OutputType` for\n   * detail.\n   * @param options - Optional. A set of options that controls the behavior of model inference.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding values.\n   */\n  run(feeds: InferenceSession.FeedsType, fetches: InferenceSession.FetchesType,\n      options?: InferenceSession.RunOptions): Promise<InferenceSession.ReturnType>;\n\n  // #endregion\n\n  // #region release()\n\n  /**\n   * Release the inference session and the underlying resources.\n   */\n  release(): Promise<void>;\n\n  // #endregion\n\n  // #region profiling\n\n  /**\n   * Start profiling.\n   */\n  startProfiling(): void;\n\n  /**\n   * End profiling.\n   */\n  endProfiling(): void;\n\n  // #endregion\n\n  // #region metadata\n\n  /**\n   * Get input names of the loaded model.\n   */\n  readonly inputNames: readonly string[];\n\n  /**\n   * Get output names of the loaded model.\n   */\n  readonly outputNames: readonly string[];\n\n  // /**\n  //  * Get input metadata of the loaded model.\n  //  */\n  // readonly inputMetadata: ReadonlyArray<Readonly<InferenceSession.ValueMetadata>>;\n\n  // /**\n  //  * Get output metadata of the loaded model.\n  //  */\n  // readonly outputMetadata: ReadonlyArray<Readonly<InferenceSession.ValueMetadata>>;\n\n  // #endregion\n}\n\nexport interface InferenceSessionFactory {\n  // #region create()\n\n  /**\n   * Create a new inference session and load model asynchronously from an ONNX model file.\n   *\n   * @param uri - The URI or file path of the model to load.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(uri: string, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from an array bufer.\n   *\n   * @param buffer - An ArrayBuffer representation of an ONNX model.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(buffer: ArrayBufferLike, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from segment of an array bufer.\n   *\n   * @param buffer - An ArrayBuffer representation of an ONNX model.\n   * @param byteOffset - The beginning of the specified portion of the array buffer.\n   * @param byteLength - The length in bytes of the array buffer.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(buffer: ArrayBufferLike, byteOffset: number, byteLength?: number, options?: InferenceSession.SessionOptions):\n      Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from a Uint8Array.\n   *\n   * @param buffer - A Uint8Array representation of an ONNX model.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(buffer: Uint8Array, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  // #endregion\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const InferenceSession: InferenceSessionFactory = InferenceSessionImpl;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {OptionsFormat, OptionsNormalizationParameters, OptionsTensorLayout} from './tensor-factory.js';\n\nexport interface TensorToDataUrlOptions extends OptionsTensorLayout, OptionsFormat, OptionsNormalizationParameters {}\n\nexport interface TensorToImageDataOptions extends OptionsTensorLayout, OptionsFormat, OptionsNormalizationParameters {}\n\nexport interface ConversionUtils {\n  /**\n   * creates a DataURL instance from tensor\n   *\n   * @param options - An optional object representing options for creating a DataURL instance from the tensor.\n   *\n   * The following default settings will be applied:\n   * - `format`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * @returns a DataURL string representing the image converted from tensor data\n   */\n  toDataURL(options?: TensorToDataUrlOptions): string;\n\n  /**\n   * creates an ImageData instance from tensor\n   *\n   * @param options - An optional object representing options for creating an ImageData instance from the tensor.\n   *\n   * The following default settings will be applied:\n   * - `format`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * @returns an ImageData instance representing the image converted from tensor data\n   */\n  toImageData(options?: TensorToImageDataOptions): ImageData;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Tensor, TypedTensor} from './tensor.js';\n\nexport type ImageFormat = 'RGB'|'RGBA'|'BGR'|'RBG';\nexport type ImageTensorLayout = 'NHWC'|'NCHW';\n\n// the following region contains type definitions for constructing tensor from a specific location.\n\n// #region types for constructing a tensor from a specific location\n\n/**\n * represent common properties of the parameter for constructing a tensor from a specific location.\n */\ninterface CommonConstructorParameters<T> extends Pick<Tensor, 'dims'> {\n  /**\n   * Specify the data type of the tensor.\n   */\n  readonly type: T;\n}\n\n/**\n * represent the parameter for constructing a tensor from a GPU resource.\n */\ninterface GpuResourceConstructorParameters<T extends Tensor.Type> {\n  /**\n   * an optional callback function to download data from GPU to CPU.\n   *\n   * If not provided, the tensor treat the GPU data as external resource.\n   */\n  download?(): Promise<Tensor.DataTypeMap[T]>;\n\n  /**\n   * an optional callback function that will be called when the tensor is disposed.\n   *\n   * If not provided, the tensor treat the GPU data as external resource.\n   */\n  dispose?(): void;\n}\n\n/**\n * represent the parameter for constructing a tensor from a pinned CPU buffer\n */\nexport interface CpuPinnedConstructorParameters<T extends Tensor.CpuPinnedDataTypes = Tensor.CpuPinnedDataTypes> extends\n    CommonConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'cpu-pinned'.\n   */\n  readonly location: 'cpu-pinned';\n  /**\n   * Specify the CPU pinned buffer that holds the tensor data.\n   */\n  readonly data: Tensor.DataTypeMap[T];\n}\n\n/**\n * represent the parameter for constructing a tensor from a WebGL texture\n */\nexport interface TextureConstructorParameters<T extends Tensor.TextureDataTypes = Tensor.TextureDataTypes> extends\n    CommonConstructorParameters<T>, GpuResourceConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'texture'.\n   */\n  readonly location: 'texture';\n  /**\n   * Specify the WebGL texture that holds the tensor data.\n   */\n  readonly texture: Tensor.TextureType;\n}\n\n/**\n * represent the parameter for constructing a tensor from a WebGPU buffer\n */\nexport interface GpuBufferConstructorParameters<T extends Tensor.GpuBufferDataTypes = Tensor.GpuBufferDataTypes> extends\n    CommonConstructorParameters<T>, GpuResourceConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'gpu-buffer'.\n   */\n  readonly location: 'gpu-buffer';\n  /**\n   * Specify the WebGPU buffer that holds the tensor data.\n   */\n  readonly gpuBuffer: Tensor.GpuBufferType;\n}\n\n// #endregion\n\n// the following region contains type definitions of each individual options.\n// the tensor factory functions use a composition of those options as the parameter type.\n\n// #region Options fields\n\nexport interface OptionsFormat {\n  /**\n   * Describes the image format represented in RGBA color space.\n   */\n  format?: ImageFormat;\n}\n\nexport interface OptionsTensorFormat {\n  /**\n   * Describes the image format of the tensor.\n   *\n   * NOTE: this is different from option 'format'. While option 'format' represents the original image, 'tensorFormat'\n   * represents the target format of the tensor. A transpose will be performed if they are different.\n   */\n  tensorFormat?: ImageFormat;\n}\n\nexport interface OptionsTensorDataType {\n  /**\n   * Describes the data type of the tensor.\n   */\n  dataType?: 'float32'|'uint8';\n}\n\nexport interface OptionsTensorLayout {\n  /**\n   * Describes the tensor layout when representing data of one or more image(s).\n   */\n  tensorLayout?: ImageTensorLayout;\n}\n\nexport interface OptionsDimensions {\n  /**\n   * Describes the image height in pixel\n   */\n  height?: number;\n  /**\n   * Describes the image width in pixel\n   */\n  width?: number;\n}\n\nexport interface OptionResizedDimensions {\n  /**\n   * Describes the resized height. If omitted, original height will be used.\n   */\n  resizedHeight?: number;\n  /**\n   * Describes resized width - can be accessed via tensor dimensions as well\n   */\n  resizedWidth?: number;\n}\n\nexport interface OptionsNormalizationParameters {\n  /**\n   * Describes normalization parameters when preprocessing the image as model input.\n   *\n   * Data element are ranged from 0 to 255.\n   */\n  norm?: {\n    /**\n     * The 'bias' value for image normalization.\n     * - If omitted, use default value 0.\n     * - If it's a single number, apply to each channel\n     * - If it's an array of 3 or 4 numbers, apply element-wise. Number of elements need to match the number of channels\n     * for the corresponding image format\n     */\n    bias?: number|[number, number, number]|[number, number, number, number];\n    /**\n     * The 'mean' value for image normalization.\n     * - If omitted, use default value 255.\n     * - If it's a single number, apply to each channel\n     * - If it's an array of 3 or 4 numbers, apply element-wise. Number of elements need to match the number of channels\n     * for the corresponding image format\n     */\n    mean?: number | [number, number, number] | [number, number, number, number];\n  };\n}\n\n// #endregion\n\n// #region Options composition\n\nexport interface TensorFromImageDataOptions extends OptionResizedDimensions, OptionsTensorFormat, OptionsTensorLayout,\n                                                    OptionsTensorDataType, OptionsNormalizationParameters {}\n\nexport interface TensorFromImageElementOptions extends OptionResizedDimensions, OptionsTensorFormat,\n                                                       OptionsTensorLayout, OptionsTensorDataType,\n                                                       OptionsNormalizationParameters {}\n\nexport interface TensorFromUrlOptions extends OptionsDimensions, OptionResizedDimensions, OptionsTensorFormat,\n                                              OptionsTensorLayout, OptionsTensorDataType,\n                                              OptionsNormalizationParameters {}\n\nexport interface TensorFromImageBitmapOptions extends OptionResizedDimensions, OptionsTensorFormat, OptionsTensorLayout,\n                                                      OptionsTensorDataType, OptionsNormalizationParameters {}\n\nexport interface TensorFromTextureOptions<T extends Tensor.TextureDataTypes> extends\n    Required<OptionsDimensions>, OptionsFormat, GpuResourceConstructorParameters<T>/* TODO: add more */ {}\n\nexport interface TensorFromGpuBufferOptions<T extends Tensor.GpuBufferDataTypes> extends\n    Pick<Tensor, 'dims'>, GpuResourceConstructorParameters<T> {\n  /**\n   * Describes the data type of the tensor.\n   */\n  dataType?: T;\n}\n\n// #endregion\n\n/**\n * type TensorFactory defines the factory functions of 'Tensor' to create tensor instances from existing data or\n * resources.\n */\nexport interface TensorFactory {\n  /**\n   * create a tensor from an ImageData object\n   *\n   * @param imageData - the ImageData object to create tensor from\n   * @param options - An optional object representing options for creating tensor from ImageData.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(imageData: ImageData, options?: TensorFromImageDataOptions):\n      Promise<TypedTensor<'float32'>|TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from a HTMLImageElement object\n   *\n   * @param imageElement - the HTMLImageElement object to create tensor from\n   * @param options - An optional object representing options for creating tensor from HTMLImageElement.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(imageElement: HTMLImageElement, options?: TensorFromImageElementOptions):\n      Promise<TypedTensor<'float32'>|TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from URL\n   *\n   * @param urlSource - a string as a URL to the image or a data URL containing the image data.\n   * @param options - An optional object representing options for creating tensor from URL.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(urlSource: string, options?: TensorFromUrlOptions): Promise<TypedTensor<'float32'>|TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from an ImageBitmap object\n   *\n   * @param bitmap - the ImageBitmap object to create tensor from\n   * @param options - An optional object representing options for creating tensor from URL.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(bitmap: ImageBitmap, options: TensorFromImageBitmapOptions):\n      Promise<TypedTensor<'float32'>|TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from a WebGL texture\n   *\n   * @param texture - the WebGLTexture object to create tensor from\n   * @param options - An optional object representing options for creating tensor from WebGL texture.\n   *\n   * The options include following properties:\n   * - `width`: the width of the texture. Required.\n   * - `height`: the height of the texture. Required.\n   * - `format`: the format of the texture. If omitted, assume 'RGBA'.\n   * - `download`: an optional function to download the tensor data from GPU to CPU. If omitted, the GPU data\n   * will not be able to download. Usually, this is provided by a GPU backend for the inference outputs. Users don't\n   * need to provide this function.\n   * - `dispose`: an optional function to dispose the tensor data on GPU. If omitted, the GPU data will not be disposed.\n   * Usually, this is provided by a GPU backend for the inference outputs. Users don't need to provide this function.\n   *\n   * @returns a tensor object\n   */\n  fromTexture<T extends Tensor.TextureDataTypes = 'float32'>(\n      texture: Tensor.TextureType, options: TensorFromTextureOptions<T>): TypedTensor<'float32'>;\n\n  /**\n   * create a tensor from a WebGPU buffer\n   *\n   * @param buffer - the GPUBuffer object to create tensor from\n   * @param options - An optional object representing options for creating tensor from WebGPU buffer.\n   *\n   * The options include following properties:\n   * - `dataType`: the data type of the tensor. If omitted, assume 'float32'.\n   * - `dims`: the dimension of the tensor. Required.\n   * - `download`: an optional function to download the tensor data from GPU to CPU. If omitted, the GPU data\n   * will not be able to download. Usually, this is provided by a GPU backend for the inference outputs. Users don't\n   * need to provide this function.\n   * - `dispose`: an optional function to dispose the tensor data on GPU. If omitted, the GPU data will not be disposed.\n   * Usually, this is provided by a GPU backend for the inference outputs. Users don't need to provide this function.\n   *\n   * @returns a tensor object\n   */\n  fromGpuBuffer<T extends Tensor.GpuBufferDataTypes>(\n      buffer: Tensor.GpuBufferType, options: TensorFromGpuBufferOptions<T>): TypedTensor<T>;\n\n  /**\n   * create a tensor from a pre-allocated buffer. The buffer will be used as a pinned buffer.\n   *\n   * @param type - the tensor element type.\n   * @param buffer - a TypedArray corresponding to the type.\n   * @param dims - specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   *\n   * @returns a tensor object\n   */\n  fromPinnedBuffer<T extends Exclude<Tensor.Type, 'string'>>(\n      type: T, buffer: Tensor.DataTypeMap[T], dims?: readonly number[]): TypedTensor<T>;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/**\n * A string that represents a file's URL or path.\n *\n * Path is vailable only in onnxruntime-node or onnxruntime-web running in Node.js.\n */\nexport type FileUrlOrPath = string;\n\n/**\n * A Blob object that represents a file.\n */\nexport type FileBlob = Blob;\n\n/**\n * A Uint8Array, ArrayBuffer or SharedArrayBuffer object that represents a file content.\n *\n * When it is an ArrayBuffer or SharedArrayBuffer, the whole buffer is assumed to be the file content.\n */\nexport type FileData = Uint8Array|ArrayBufferLike;\n\n/**\n * Represents a file that can be loaded by the ONNX Runtime JavaScript API.\n */\nexport type FileType = FileUrlOrPath|FileBlob|FileData;\n\n/**\n * Represents an external data file.\n */\nexport interface ExternalDataFileDescription {\n  /**\n   * Specify the external data file.\n   */\n  data: FileType;\n  /**\n   * Specify the file path.\n   */\n  path: string;\n}\n\n/**\n * Represents an external data file.\n *\n * When using a string, it should be a file URL or path that in the same directory as the model file.\n */\nexport type ExternalDataFileType = ExternalDataFileDescription|FileUrlOrPath;\n\n/**\n * Options for model loading.\n */\nexport interface OnnxModelOptions {\n  /**\n   * Specifying a list of files that represents the external data.\n   */\n  externalData?: readonly ExternalDataFileType[];\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Tensor} from './tensor.js';\n\nexport type NonTensorType = never;\n\n/**\n * Type OnnxValue Represents both tensors and non-tensors value for model's inputs/outputs.\n *\n * NOTE: currently not support non-tensor\n */\nexport type OnnxValue = Tensor|NonTensorType;\n\n/**\n * Type OnnxValueDataLocation represents the location of the data of an OnnxValue.\n */\nexport type OnnxValueDataLocation = Tensor.DataLocation;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {resolveBackendAndExecutionProviders} from './backend-impl.js';\nimport {SessionHandler, TrainingSessionHandler} from './backend.js';\nimport {InferenceSession as InferenceSession} from './inference-session.js';\nimport {OnnxValue} from './onnx-value.js';\nimport {Tensor} from './tensor.js';\nimport {TrainingSession as TrainingSessionInterface, TrainingSessionCreateOptions} from './training-session.js';\n\ntype SessionOptions = InferenceSession.SessionOptions;\ntype FeedsType = InferenceSession.FeedsType;\ntype FetchesType = InferenceSession.FetchesType;\ntype ReturnType = InferenceSession.ReturnType;\ntype RunOptions = InferenceSession.RunOptions;\n\nconst noBackendErrMsg: string = 'Training backend could not be resolved. ' +\n    'Make sure you\\'re using the correct configuration & WebAssembly files.';\n\nexport class TrainingSession implements TrainingSessionInterface {\n  private constructor(handler: TrainingSessionHandler, hasOptimizerModel: boolean, hasEvalModel: boolean) {\n    this.handler = handler;\n    this.hasOptimizerModel = hasOptimizerModel;\n    this.hasEvalModel = hasEvalModel;\n  }\n  private handler: TrainingSessionHandler;\n  private hasOptimizerModel: boolean;\n  private hasEvalModel: boolean;\n\n  get trainingInputNames(): readonly string[] {\n    return this.handler.inputNames;\n  }\n  get trainingOutputNames(): readonly string[] {\n    return this.handler.outputNames;\n  }\n\n  get evalInputNames(): readonly string[] {\n    if (this.hasEvalModel) {\n      return this.handler.evalInputNames;\n    } else {\n      throw new Error('This training session has no evalModel loaded.');\n    }\n  }\n  get evalOutputNames(): readonly string[] {\n    if (this.hasEvalModel) {\n      return this.handler.evalOutputNames;\n    } else {\n      throw new Error('This training session has no evalModel loaded.');\n    }\n  }\n\n  static async create(trainingOptions: TrainingSessionCreateOptions, sessionOptions?: SessionOptions):\n      Promise<TrainingSession> {\n    const evalModel: string|Uint8Array = trainingOptions.evalModel || '';\n    const optimizerModel: string|Uint8Array = trainingOptions.optimizerModel || '';\n    const options: SessionOptions = sessionOptions || {};\n\n    // resolve backend, update session options with validated EPs, and create session handler\n    const [backend, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);\n    if (backend.createTrainingSessionHandler) {\n      const handler = await backend.createTrainingSessionHandler(\n          trainingOptions.checkpointState, trainingOptions.trainModel, evalModel, optimizerModel,\n          optionsWithValidatedEPs);\n      return new TrainingSession(handler, !!trainingOptions.optimizerModel, !!trainingOptions.evalModel);\n    } else {\n      throw new Error(noBackendErrMsg);\n    }\n  }\n\n  /**\n   * Helper function for runTrainStep and future runStep methods that handles the type-narrowing conversion from\n   * the given parameters to SessionHandler.FetchesType and RunOptions.\n   *\n   * @param inputNames the feeds object is checked that they contain all input names in the provided list of input\n   * names.\n   * @param outputNames the fetches object is checked that their keys match up with valid names in the list of output\n   * names.\n   * @param feeds the required input\n   * @param arg1 narrowed & converted into the SessionHandler.FetchesType or RunOptions object\n   * @param arg2 optional RunOptions object.\n   * @returns\n   */\n  typeNarrowingForRunStep(\n      inputNames: readonly string[], outputNames: readonly string[], feeds: FeedsType, arg1?: FetchesType|RunOptions,\n      arg2?: RunOptions): [SessionHandler.FetchesType, RunOptions] {\n    const fetches: {[name: string]: OnnxValue|null} = {};\n    let options: RunOptions = {};\n    // check inputs\n    if (typeof feeds !== 'object' || feeds === null || feeds instanceof Tensor || Array.isArray(feeds)) {\n      throw new TypeError(\n          '\\'feeds\\' must be an object that use input names as keys and OnnxValue as corresponding values.');\n    }\n\n    let isFetchesEmpty = true;\n    // determine which override is being used\n    if (typeof arg1 === 'object') {\n      if (arg1 === null) {\n        throw new TypeError('Unexpected argument[1]: cannot be null.');\n      }\n      if (arg1 instanceof Tensor) {\n        throw new TypeError('\\'fetches\\' cannot be a Tensor');\n      }\n\n      if (Array.isArray(arg1)) {\n        if (arg1.length === 0) {\n          throw new TypeError('\\'fetches\\' cannot be an empty array.');\n        }\n        isFetchesEmpty = false;\n        // output names\n        for (const name of arg1) {\n          if (typeof name !== 'string') {\n            throw new TypeError('\\'fetches\\' must be a string array or an object.');\n          }\n          if (outputNames.indexOf(name) === -1) {\n            throw new RangeError(`'fetches' contains invalid output name: ${name}.`);\n          }\n          fetches[name] = null;\n        }\n\n        if (typeof arg2 === 'object' && arg2 !== null) {\n          options = arg2;\n        } else if (typeof arg2 !== 'undefined') {\n          throw new TypeError('\\'options\\' must be an object.');\n        }\n      } else {\n        // decide whether arg1 is fetches or options\n        // if any output name is present and its value is valid OnnxValue, we consider it fetches\n        let isFetches = false;\n        const arg1Keys = Object.getOwnPropertyNames(arg1);\n        for (const name of outputNames) {\n          if (arg1Keys.indexOf(name) !== -1) {\n            const v = (arg1 as InferenceSession.NullableOnnxValueMapType)[name];\n            if (v === null || v instanceof Tensor) {\n              isFetches = true;\n              isFetchesEmpty = false;\n              fetches[name] = v;\n            }\n          }\n        }\n\n        if (isFetches) {\n          if (typeof arg2 === 'object' && arg2 !== null) {\n            options = arg2;\n          } else if (typeof arg2 !== 'undefined') {\n            throw new TypeError('\\'options\\' must be an object.');\n          }\n        } else {\n          options = arg1 as RunOptions;\n        }\n      }\n    } else if (typeof arg1 !== 'undefined') {\n      throw new TypeError('Unexpected argument[1]: must be \\'fetches\\' or \\'options\\'.');\n    }\n\n    // check if all inputs are in feed\n    for (const name of inputNames) {\n      if (typeof feeds[name] === 'undefined') {\n        throw new Error(`input '${name}' is missing in 'feeds'.`);\n      }\n    }\n\n    // if no fetches is specified, we use the full output names list\n    if (isFetchesEmpty) {\n      for (const name of outputNames) {\n        fetches[name] = null;\n      }\n    }\n\n    return [fetches, options];\n  }\n\n  /**\n   * Helper method for runTrainStep and any other runStep methods. Takes the ReturnType result from the SessionHandler\n   * and changes it into a map of Tensors.\n   *\n   * @param results\n   * @returns\n   */\n  convertHandlerReturnTypeToMapOfTensors(results: SessionHandler.ReturnType): ReturnType {\n    const returnValue: {[name: string]: OnnxValue} = {};\n    for (const key in results) {\n      if (Object.hasOwnProperty.call(results, key)) {\n        const result = results[key];\n        if (result instanceof Tensor) {\n          returnValue[key] = result;\n        } else {\n          returnValue[key] = new Tensor(result.type, result.data, result.dims);\n        }\n      }\n    }\n    return returnValue;\n  }\n\n  async lazyResetGrad(): Promise<void> {\n    await this.handler.lazyResetGrad();\n  }\n\n  runTrainStep(feeds: FeedsType, options?: RunOptions): Promise<ReturnType>;\n  runTrainStep(feeds: FeedsType, fetches: FetchesType, options?: RunOptions): Promise<ReturnType>;\n  async runTrainStep(feeds: FeedsType, arg1?: FetchesType|RunOptions, arg2?: RunOptions): Promise<ReturnType> {\n    const [fetches, options] =\n        this.typeNarrowingForRunStep(this.trainingInputNames, this.trainingOutputNames, feeds, arg1, arg2);\n    const results = await this.handler.runTrainStep(feeds, fetches, options);\n    return this.convertHandlerReturnTypeToMapOfTensors(results);\n  }\n\n  async runOptimizerStep(options?: InferenceSession.RunOptions|undefined): Promise<void> {\n    if (this.hasOptimizerModel) {\n      await this.handler.runOptimizerStep(options || {});\n    } else {\n      throw new Error('This TrainingSession has no OptimizerModel loaded.');\n    }\n  }\n\n  runEvalStep(feeds: FeedsType, options?: RunOptions|undefined): Promise<ReturnType>;\n  runEvalStep(feeds: FeedsType, fetches: FetchesType, options?: RunOptions|undefined): Promise<ReturnType>;\n  async runEvalStep(feeds: FeedsType, arg1?: FetchesType|RunOptions, arg2?: RunOptions): Promise<ReturnType> {\n    if (this.hasEvalModel) {\n      const [fetches, options] =\n          this.typeNarrowingForRunStep(this.evalInputNames, this.evalOutputNames, feeds, arg1, arg2);\n      const results = await this.handler.runEvalStep(feeds, fetches, options);\n      return this.convertHandlerReturnTypeToMapOfTensors(results);\n    } else {\n      throw new Error('This TrainingSession has no EvalModel loaded.');\n    }\n  }\n\n  async getParametersSize(trainableOnly = true): Promise<number> {\n    return this.handler.getParametersSize(trainableOnly);\n  }\n\n  async loadParametersBuffer(array: Uint8Array, trainableOnly = true): Promise<void> {\n    const paramsSize = await this.getParametersSize(trainableOnly);\n    // checking that the size of the Uint8Array is equivalent to the byte length of a Float32Array of the number\n    // of parameters\n    if (array.length !== 4 * paramsSize) {\n      throw new Error(\n          'Size of the buffer passed into loadParametersBuffer must match the number of parameters in ' +\n          'the model. Please use getParametersSize method to check.');\n    }\n    return this.handler.loadParametersBuffer(array, trainableOnly);\n  }\n\n  async getContiguousParameters(trainableOnly = true): Promise<OnnxValue> {\n    return this.handler.getContiguousParameters(trainableOnly);\n  }\n\n  async release(): Promise<void> {\n    return this.handler.dispose();\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {InferenceSession} from './inference-session.js';\nimport {OnnxValue} from './onnx-value.js';\nimport {TrainingSession as TrainingSessionImpl} from './training-session-impl.js';\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\nexport declare namespace TrainingSession {\n  /**\n   * Either URI file path (string) or Uint8Array containing model or checkpoint information.\n   */\n  type UriOrBuffer = string|Uint8Array;\n}\n\n/**\n * Represent a runtime instance of an ONNX training session,\n * which contains a model that can be trained, and, optionally,\n * an eval and optimizer model.\n */\nexport interface TrainingSession {\n  // #region run()\n\n  /**\n   * Lazily resets the gradients of all trainable parameters to zero. Should happen after the invocation of\n   * runOptimizerStep.\n   */\n  lazyResetGrad(): Promise<void>;\n\n  /**\n   * Run TrainStep asynchronously with the given feeds and options.\n   *\n   * @param feeds - Representation of the model input. See type description of `InferenceSession.InputType` for\n   detail.\n   * @param options - Optional. A set of options that controls the behavior of model training.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding values.\n   */\n  runTrainStep(feeds: InferenceSession.FeedsType, options?: InferenceSession.RunOptions):\n      Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Run a single train step with the given inputs and options.\n   *\n   * @param feeds - Representation of the model input.\n   * @param fetches - Representation of the model output.\n   * detail.\n   * @param options - Optional. A set of options that controls the behavior of model training.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding\n   values.\n   */\n  runTrainStep(\n      feeds: InferenceSession.FeedsType, fetches: InferenceSession.FetchesType,\n      options?: InferenceSession.RunOptions): Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Runs a single optimizer step, which performs weight updates for the trainable parameters using the optimizer model.\n   *\n   * @param options - Optional. A set of options that controls the behavior of model optimizing.\n   */\n  runOptimizerStep(options?: InferenceSession.RunOptions): Promise<void>;\n\n  /**\n   * Run a single eval step with the given inputs and options using the eval model.\n   *\n   * @param feeds - Representation of the model input.\n   * @param options - Optional. A set of options that controls the behavior of model eval step.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding\n   values.\n   */\n  runEvalStep(feeds: InferenceSession.FeedsType, options?: InferenceSession.RunOptions):\n      Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Run a single eval step with the given inputs and options using the eval model.\n   *\n   * @param feeds - Representation of the model input.\n   * @param fetches - Representation of the model output.\n   * detail.\n   * @param options - Optional. A set of options that controls the behavior of model eval step.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding\n   values.\n   */\n  runEvalStep(\n      feeds: InferenceSession.FeedsType, fetches: InferenceSession.FetchesType,\n      options?: InferenceSession.RunOptions): Promise<InferenceSession.ReturnType>;\n\n  // #endregion\n\n  // #region copy parameters\n\n  /**\n   * Retrieves the size of all parameters for the training state. Calculates the total number of primitive (datatype of\n   * the parameters) elements of all the parameters in the training state.\n   *\n   * @param trainableOnly - When set to true, the size is calculated for trainable params only. Default value is true.\n   */\n  getParametersSize(trainableOnly: boolean): Promise<number>;\n\n  /**\n   * Copies parameter values from the given buffer to the training state. Currently, only supporting models with\n   * parameters of type Float32.\n   *\n   * @param buffer - A Uint8Array representation of Float32 parameters.\n   * @param trainableOnly - True if trainable parameters only to be modified, false otherwise. Default value is true.\n   */\n  loadParametersBuffer(buffer: Uint8Array, trainableOnly: boolean): Promise<void>;\n\n  /**\n   * Copies the model parameters to a contiguous buffer. Usually used in the context of Federated Learning.\n   * Currently, only supporting models with parameters of type Float32.\n   *\n   * @param trainableOnly - When set to true, only trainable parameters are copied. Trainable parameters are parameters\n   * for which requires_grad is set to true. Default value is true.\n   * @returns A promise that resolves to a Float32 OnnxValue of the requested parameters.\n   */\n  getContiguousParameters(trainableOnly: boolean): Promise<OnnxValue>;\n  // #endregion\n\n  // #region release()\n\n  /**\n   * Release the inference session and the underlying resources.\n   */\n  release(): Promise<void>;\n  // #endregion\n\n  // #region metadata\n\n  /**\n   * Get input names of the loaded training model.\n   */\n  readonly trainingInputNames: readonly string[];\n\n  /**\n   * Get output names of the loaded training model.\n   */\n  readonly trainingOutputNames: readonly string[];\n\n  /**\n   * Get input names of the loaded eval model. Is an empty array if no eval model is loaded.\n   */\n  readonly evalInputNames: readonly string[];\n\n  /**\n   * Get output names of the loaded eval model. Is an empty array if no eval model is loaded.\n   */\n  readonly evalOutputNames: readonly string[];\n\n  // #endregion\n}\n\n/**\n * Represents the optional parameters that can be passed into the TrainingSessionFactory.\n */\nexport interface TrainingSessionCreateOptions {\n  /**\n   * URI or buffer for a .ckpt file that contains the checkpoint for the training model.\n   */\n  checkpointState: TrainingSession.UriOrBuffer;\n  /**\n   * URI or buffer for the .onnx training file.\n   */\n  trainModel: TrainingSession.UriOrBuffer;\n  /**\n   * Optional. URI or buffer for the .onnx optimizer model file.\n   */\n  optimizerModel?: TrainingSession.UriOrBuffer;\n  /**\n   * Optional. URI or buffer for the .onnx eval model file.\n   */\n  evalModel?: TrainingSession.UriOrBuffer;\n}\n\n/**\n * Defines method overload possibilities for creating a TrainingSession.\n */\nexport interface TrainingSessionFactory {\n  // #region create()\n\n  /**\n   * Creates a new TrainingSession and asynchronously loads any models passed in through trainingOptions\n   *\n   * @param trainingOptions specify models and checkpoints to load into the Training Session\n   * @param sessionOptions specify configuration for training session behavior\n   *\n   * @returns Promise that resolves to a TrainingSession object\n   */\n  create(trainingOptions: TrainingSessionCreateOptions, sessionOptions?: InferenceSession.SessionOptions):\n      Promise<TrainingSession>;\n\n  // #endregion\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const TrainingSession: TrainingSessionFactory = TrainingSessionImpl;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/**\n * # ONNX Runtime JavaScript API\n *\n * ONNX Runtime JavaScript API is a unified API for all JavaScript usages, including the following NPM packages:\n *\n * - [onnxruntime-node](https://www.npmjs.com/package/onnxruntime-node)\n * - [onnxruntime-web](https://www.npmjs.com/package/onnxruntime-web)\n * - [onnxruntime-react-native](https://www.npmjs.com/package/onnxruntime-react-native)\n *\n * See also:\n * - [Get Started](https://onnxruntime.ai/docs/get-started/with-javascript/)\n * - [Inference examples](https://github.com/microsoft/onnxruntime-inference-examples/tree/main/js)\n *\n * @packageDocumentation\n */\n\nexport * from './backend.js';\nexport * from './env.js';\nexport * from './inference-session.js';\nexport * from './tensor.js';\nexport * from './tensor-conversion.js';\nexport * from './tensor-factory.js';\nexport * from './trace.js';\nexport * from './onnx-model.js';\nexport * from './onnx-value.js';\nexport * from './training-session.js';\n", "export const cpus = undefined;", "export const join = undefined;", "export const readFile = undefined;export const readFileSync = undefined;export const createReadStream = undefined;", "export const join = undefined;", "\nvar ortWasm = (() => {\n  var _scriptDir = typeof document != 'undefined' ? document.currentScript?.src : undefined;\n  if (typeof __filename != 'undefined') _scriptDir ||= __filename;\n  return (\nfunction(moduleArg = {}) {\n\nvar g=moduleArg,aa,ba,readyPromise=new Promise((a,b)=>{aa=a;ba=b});\"use strict\";g.mountExternalData=(a,b)=>{(g.Ph||(g.Ph=new Map)).set(a,b)};g.unmountExternalData=()=>{delete g.Ph};\nlet da=()=>{const a=(c,d,e)=>(...f)=>{const h=t,k=d?.();f=c(...f);const l=d?.();k!==l&&(c=l,e(k),d=e=null);return t!=h?ca():f},b=c=>async(...d)=>{try{if(g.Oh)throw Error(\"Session already started\");const e=g.Oh={gi:d[0],errors:[]},f=await c(...d);if(g.Oh!==e)throw Error(\"Session mismatch\");g.Uh?.flush();const h=e.errors;if(0<h.length){let k=await Promise.all(h);k=k.filter(l=>l);if(0<k.length)throw Error(k.join(\"\\n\"));}return f}finally{g.Oh=null}};g._OrtCreateSession=a(g._OrtCreateSession,()=>g._OrtCreateSession,\nc=>g._OrtCreateSession=c);g._OrtRun=b(a(g._OrtRun,()=>g._OrtRun,c=>g._OrtRun=c));g._OrtRunWithBinding=b(a(g._OrtRunWithBinding,()=>g._OrtRunWithBinding,c=>g._OrtRunWithBinding=c));g._OrtBindInput=a(g._OrtBindInput,()=>g._OrtBindInput,c=>g._OrtBindInput=c);da=void 0};\ng.jsepInit=(a,b)=>{da?.();if(\"webgpu\"===a){[g.Uh,g.Zh,g.ci,g.Vh,g.bi,g.je,g.di,g.fi,g.$h,g.ai,g.ei]=b;const c=g.Uh;g.jsepRegisterBuffer=(d,e,f,h)=>c.registerBuffer(d,e,f,h);g.jsepGetBuffer=d=>c.getBuffer(d);g.jsepCreateDownloader=(d,e,f)=>c.createDownloader(d,e,f);g.jsepOnReleaseSession=d=>{c.onReleaseSession(d)};g.jsepOnRunStart=d=>c.onRunStart(d)}};\nvar ea=Object.assign({},g),fa=\"./this.program\",ha=(a,b)=>{throw b;},ia=\"object\"==typeof window,ja=\"function\"==typeof importScripts,ka=\"object\"==typeof process&&\"object\"==typeof process.versions&&\"string\"==typeof process.versions.node,v=\"\",la,ma,na;\nif(ka){var fs=require(\"fs\"),oa=require(\"path\");v=ja?oa.dirname(v)+\"/\":__dirname+\"/\";la=(a,b)=>{a=pa(a)?new URL(a):oa.normalize(a);return fs.readFileSync(a,b?void 0:\"utf8\")};na=a=>{a=la(a,!0);a.buffer||(a=new Uint8Array(a));return a};ma=(a,b,c,d=!0)=>{a=pa(a)?new URL(a):oa.normalize(a);fs.readFile(a,d?void 0:\"utf8\",(e,f)=>{e?c(e):b(d?f.buffer:f)})};!g.thisProgram&&1<process.argv.length&&(fa=process.argv[1].replace(/\\\\/g,\"/\"));process.argv.slice(2);ha=(a,b)=>{process.exitCode=a;throw b;}}else if(ia||\nja)ja?v=self.location.href:\"undefined\"!=typeof document&&document.currentScript&&(v=document.currentScript.src),_scriptDir&&(v=_scriptDir),v.startsWith(\"blob:\")?v=\"\":v=v.substr(0,v.replace(/[?#].*/,\"\").lastIndexOf(\"/\")+1),la=a=>{var b=new XMLHttpRequest;b.open(\"GET\",a,!1);b.send(null);return b.responseText},ja&&(na=a=>{var b=new XMLHttpRequest;b.open(\"GET\",a,!1);b.responseType=\"arraybuffer\";b.send(null);return new Uint8Array(b.response)}),ma=(a,b,c)=>{var d=new XMLHttpRequest;d.open(\"GET\",a,!0);d.responseType=\n\"arraybuffer\";d.onload=()=>{200==d.status||0==d.status&&d.response?b(d.response):c()};d.onerror=c;d.send(null)};var qa=console.log.bind(console),w=console.error.bind(console);Object.assign(g,ea);ea=null;var ra,x=!1,sa,z,E,ta,ua,G,I,va,wa,xa,ya;\nfunction za(){var a=ra.buffer;g.HEAP8=z=new Int8Array(a);g.HEAP16=ta=new Int16Array(a);g.HEAPU8=E=new Uint8Array(a);g.HEAPU16=ua=new Uint16Array(a);g.HEAP32=G=new Int32Array(a);g.HEAPU32=I=new Uint32Array(a);g.HEAPF32=va=new Float32Array(a);g.HEAPF64=ya=new Float64Array(a);g.HEAP64=wa=new BigInt64Array(a);g.HEAPU64=xa=new BigUint64Array(a)}var Aa=[],Ba=[],Ca=[],Da=0,Ea=null,Fa=null;\nfunction Ga(a){a=\"Aborted(\"+a+\")\";w(a);x=!0;sa=1;a=new WebAssembly.RuntimeError(a+\". Build with -sASSERTIONS for more info.\");ba(a);throw a;}var Ha=a=>a.startsWith(\"data:application/octet-stream;base64,\"),pa=a=>a.startsWith(\"file://\"),Ia;Ia=\"ort-wasm-simd.wasm\";if(!Ha(Ia)){var Ja=Ia;Ia=g.locateFile?g.locateFile(Ja,v):v+Ja}function Ka(a){if(na)return na(a);throw\"both async and sync fetching of the wasm failed\";}\nfunction La(a){if(ia||ja){if(\"function\"==typeof fetch&&!pa(a))return fetch(a,{credentials:\"same-origin\"}).then(b=>{if(!b.ok)throw`failed to load wasm binary file at '${a}'`;return b.arrayBuffer()}).catch(()=>Ka(a));if(ma)return new Promise((b,c)=>{ma(a,d=>b(new Uint8Array(d)),c)})}return Promise.resolve().then(()=>Ka(a))}function Ma(a,b,c){return La(a).then(d=>WebAssembly.instantiate(d,b)).then(c,d=>{w(`failed to asynchronously prepare wasm: ${d}`);Ga(d)})}\nfunction Na(a,b){var c=Ia;return\"function\"!=typeof WebAssembly.instantiateStreaming||Ha(c)||pa(c)||ka||\"function\"!=typeof fetch?Ma(c,a,b):fetch(c,{credentials:\"same-origin\"}).then(d=>WebAssembly.instantiateStreaming(d,a).then(b,function(e){w(`wasm streaming compile failed: ${e}`);w(\"falling back to ArrayBuffer instantiation\");return Ma(c,a,b)}))}\nvar Oa={1261504:(a,b,c,d)=>{if(\"undefined\"==typeof g||!g.Ph)return 1;a=J(a>>>0);a.startsWith(\"./\")&&(a=a.substring(2));a=g.Ph.get(a);if(!a)return 2;b>>>=0;c>>>=0;if(b+c>a.byteLength)return 3;try{return E.set(a.subarray(b,b+c),d>>>0>>>0),0}catch{return 4}},1262005:(a,b,c)=>{c=J(c);const d=new Uint8Array(b);d.set(E.subarray(a>>>0,a+b>>>0));\"object\"==typeof process&&\"object\"==typeof process.versions&&\"string\"==typeof process.versions.node?require(\"fs\").writeFileSync(c,d):(a=new File([d],c,{type:\"application/octet-stream\"}),\na=URL.createObjectURL(a),window.open(a,\"_blank\"))},1262513:()=>{g.$h()},1262544:()=>{g.ai()},1262573:()=>{g.ei()},1262598:a=>g.Zh(a),1262631:a=>g.ci(a),1262663:(a,b,c)=>{g.Vh(a,b,c,!0)},1262702:(a,b,c)=>{g.Vh(a,b,c)},1262735:a=>{g.je(\"Abs\",a,void 0)},1262786:a=>{g.je(\"Neg\",a,void 0)},1262837:a=>{g.je(\"Floor\",a,void 0)},1262890:a=>{g.je(\"Ceil\",a,void 0)},1262942:a=>{g.je(\"Reciprocal\",a,void 0)},1263E3:a=>{g.je(\"Sqrt\",a,void 0)},1263052:a=>{g.je(\"Exp\",a,void 0)},1263103:a=>{g.je(\"Erf\",a,void 0)},1263154:a=>\n{g.je(\"Sigmoid\",a,void 0)},1263209:(a,b,c)=>{g.je(\"HardSigmoid\",a,{alpha:b,beta:c})},1263288:a=>{g.je(\"Log\",a,void 0)},1263339:a=>{g.je(\"Sin\",a,void 0)},1263390:a=>{g.je(\"Cos\",a,void 0)},1263441:a=>{g.je(\"Tan\",a,void 0)},1263492:a=>{g.je(\"Asin\",a,void 0)},1263544:a=>{g.je(\"Acos\",a,void 0)},1263596:a=>{g.je(\"Atan\",a,void 0)},1263648:a=>{g.je(\"Sinh\",a,void 0)},1263700:a=>{g.je(\"Cosh\",a,void 0)},1263752:a=>{g.je(\"Asinh\",a,void 0)},1263805:a=>{g.je(\"Acosh\",a,void 0)},1263858:a=>{g.je(\"Atanh\",a,void 0)},\n1263911:a=>{g.je(\"Tanh\",a,void 0)},1263963:a=>{g.je(\"Not\",a,void 0)},1264014:(a,b,c)=>{g.je(\"Clip\",a,{min:b,max:c})},1264083:a=>{g.je(\"Clip\",a,void 0)},1264135:(a,b)=>{g.je(\"Elu\",a,{alpha:b})},1264193:a=>{g.je(\"Relu\",a,void 0)},1264245:(a,b)=>{g.je(\"LeakyRelu\",a,{alpha:b})},1264309:(a,b)=>{g.je(\"ThresholdedRelu\",a,{alpha:b})},1264379:(a,b)=>{g.je(\"Cast\",a,{to:b})},1264437:a=>{g.je(\"Add\",a,void 0)},1264488:a=>{g.je(\"Sub\",a,void 0)},1264539:a=>{g.je(\"Mul\",a,void 0)},1264590:a=>{g.je(\"Div\",a,void 0)},\n1264641:a=>{g.je(\"Pow\",a,void 0)},1264692:a=>{g.je(\"Equal\",a,void 0)},1264745:a=>{g.je(\"Greater\",a,void 0)},1264800:a=>{g.je(\"GreaterOrEqual\",a,void 0)},1264862:a=>{g.je(\"Less\",a,void 0)},1264914:a=>{g.je(\"LessOrEqual\",a,void 0)},1264973:(a,b,c,d,e)=>{g.je(\"ReduceMean\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265132:(a,b,c,d,e)=>{g.je(\"ReduceMax\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265290:(a,b,c,d,e)=>\n{g.je(\"ReduceMin\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265448:(a,b,c,d,e)=>{g.je(\"ReduceProd\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265607:(a,b,c,d,e)=>{g.je(\"ReduceSum\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265765:(a,b,c,d,e)=>{g.je(\"ReduceL1\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265922:(a,b,c,d,e)=>\n{g.je(\"ReduceL2\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1266079:(a,b,c,d,e)=>{g.je(\"ReduceLogSum\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1266240:(a,b,c,d,e)=>{g.je(\"ReduceSumSquare\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1266404:(a,b,c,d,e)=>{g.je(\"ReduceLogSumExp\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1266568:a=>\n{g.je(\"Where\",a,void 0)},1266621:(a,b,c)=>{g.je(\"Transpose\",a,{perm:b?Array.from(G.subarray(b>>>0,c>>>0)):[]})},1266729:(a,b,c,d)=>{g.je(\"DepthToSpace\",a,{blocksize:b,mode:J(c),format:d?\"NHWC\":\"NCHW\"})},1266862:(a,b,c,d)=>{g.je(\"DepthToSpace\",a,{blocksize:b,mode:J(c),format:d?\"NHWC\":\"NCHW\"})},1266995:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>{g.je(\"ConvTranspose\",a,{format:l?\"NHWC\":\"NCHW\",autoPad:b,dilations:[c],group:d,kernelShape:[e],pads:[f,h],strides:[k],wIsConst:()=>!!z[m>>>0],outputPadding:n?Array.from(G.subarray(n>>>\n0,q>>>0)):[],outputShape:r?Array.from(G.subarray(r>>>0,p>>>0)):[],activation:J(u)})},1267396:(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>{g.je(\"ConvTranspose\",a,{format:k?\"NHWC\":\"NCHW\",autoPad:b,dilations:Array.from(G.subarray(c>>>0,(c>>>0)+2>>>0)),group:d,kernelShape:Array.from(G.subarray(e>>>0,(e>>>0)+2>>>0)),pads:Array.from(G.subarray(f>>>0,(f>>>0)+4>>>0)),strides:Array.from(G.subarray(h>>>0,(h>>>0)+2>>>0)),wIsConst:()=>!!z[l>>>0],outputPadding:m?Array.from(G.subarray(m>>>0,n>>>0)):[],outputShape:q?Array.from(G.subarray(q>>>\n0,r>>>0)):[],activation:J(p)})},1267961:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>{g.je(\"ConvTranspose\",a,{format:l?\"NHWC\":\"NCHW\",autoPad:b,dilations:[c],group:d,kernelShape:[e],pads:[f,h],strides:[k],wIsConst:()=>!!z[m>>>0],outputPadding:n?Array.from(G.subarray(n>>>0,q>>>0)):[],outputShape:r?Array.from(G.subarray(r>>>0,p>>>0)):[],activation:J(u)})},1268362:(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>{g.je(\"ConvTranspose\",a,{format:k?\"NHWC\":\"NCHW\",autoPad:b,dilations:Array.from(G.subarray(c>>>0,(c>>>0)+2>>>0)),group:d,\nkernelShape:Array.from(G.subarray(e>>>0,(e>>>0)+2>>>0)),pads:Array.from(G.subarray(f>>>0,(f>>>0)+4>>>0)),strides:Array.from(G.subarray(h>>>0,(h>>>0)+2>>>0)),wIsConst:()=>!!z[l>>>0],outputPadding:m?Array.from(G.subarray(m>>>0,n>>>0)):[],outputShape:q?Array.from(G.subarray(q>>>0,r>>>0)):[],activation:J(p)})},1268927:(a,b)=>{g.je(\"GlobalAveragePool\",a,{format:b?\"NHWC\":\"NCHW\"})},1269018:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>{g.je(\"AveragePool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:d,\nstorage_order:e,dilations:[f,h],kernel_shape:[k,l],pads:[m,n,q,r],strides:[p,u]})},1269302:(a,b)=>{g.je(\"GlobalAveragePool\",a,{format:b?\"NHWC\":\"NCHW\"})},1269393:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>{g.je(\"AveragePool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:e,dilations:[f,h],kernel_shape:[k,l],pads:[m,n,q,r],strides:[p,u]})},1269677:(a,b)=>{g.je(\"GlobalMaxPool\",a,{format:b?\"NHWC\":\"NCHW\"})},1269764:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>{g.je(\"MaxPool\",a,{format:y?\n\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:e,dilations:[f,h],kernel_shape:[k,l],pads:[m,n,q,r],strides:[p,u]})},1270044:(a,b)=>{g.je(\"GlobalMaxPool\",a,{format:b?\"NHWC\":\"NCHW\"})},1270131:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>{g.je(\"MaxPool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:e,dilations:[f,h],kernel_shape:[k,l],pads:[m,n,q,r],strides:[p,u]})},1270411:(a,b,c,d,e)=>{g.je(\"Gemm\",a,{alpha:b,beta:c,transA:d,transB:e})},1270515:a=>\n{g.je(\"MatMul\",a,void 0)},1270569:(a,b,c,d)=>{g.je(\"ArgMax\",a,{keepDims:!!b,selectLastIndex:!!c,axis:d})},1270677:(a,b,c,d)=>{g.je(\"ArgMin\",a,{keepDims:!!b,selectLastIndex:!!c,axis:d})},1270785:(a,b)=>{g.je(\"Softmax\",a,{axis:b})},1270848:(a,b)=>{g.je(\"Concat\",a,{axis:b})},1270908:(a,b,c,d,e)=>{g.je(\"Split\",a,{axis:b,numOutputs:c,splitSizes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1271048:a=>{g.je(\"Expand\",a,void 0)},1271102:(a,b)=>{g.je(\"Gather\",a,{axis:Number(b)})},1271173:(a,b)=>{g.je(\"GatherElements\",\na,{axis:Number(b)})},1271252:(a,b,c,d,e,f,h,k,l,m,n)=>{g.je(\"Resize\",a,{antialias:b,axes:c?Array.from(G.subarray(c>>>0,d>>>0)):[],coordinateTransformMode:J(e),cubicCoeffA:f,excludeOutside:h,extrapolationValue:k,keepAspectRatioPolicy:J(l),mode:J(m),nearestMode:J(n)})},1271598:(a,b,c,d,e,f,h)=>{g.je(\"Slice\",a,{starts:b?Array.from(G.subarray(b>>>0,c>>>0)):[],ends:d?Array.from(G.subarray(d>>>0,e>>>0)):[],axes:f?Array.from(G.subarray(f>>>0,h>>>0)):[]})},1271814:a=>{g.je(\"Tile\",a,void 0)},1271866:(a,b,\nc,d)=>{g.je(\"LayerNormalization\",a,{axis:b,epsilon:c,simplified:!!d})},1271977:(a,b,c)=>{g.je(\"InstanceNormalization\",a,{epsilon:b,format:c?\"NHWC\":\"NCHW\"})},1272091:(a,b,c)=>{g.je(\"InstanceNormalization\",a,{epsilon:b,format:c?\"NHWC\":\"NCHW\"})},1272205:a=>{g.je(\"Range\",a,void 0)},1272258:(a,b)=>{g.je(\"Einsum\",a,{equation:J(b)})},1272339:(a,b,c,d,e)=>{g.je(\"Pad\",a,{mode:b,value:c,pads:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1272466:(a,b,c,d,e,f)=>{g.je(\"BatchNormalization\",a,{epsilon:b,momentum:c,\nspatial:!!e,trainingMode:!!d,format:f?\"NHWC\":\"NCHW\"})},1272635:(a,b,c,d,e,f)=>{g.je(\"BatchNormalization\",a,{epsilon:b,momentum:c,spatial:!!e,trainingMode:!!d,format:f?\"NHWC\":\"NCHW\"})},1272804:(a,b,c)=>{g.je(\"CumSum\",a,{exclusive:Number(b),reverse:Number(c)})},1272901:(a,b,c,d,e,f,h,k,l)=>{g.je(\"Attention\",a,{numHeads:b,isUnidirectional:c,maskFilterValue:d,scale:e,doRotary:f,qkvHiddenSizes:h?Array.from(G.subarray(Number(k)>>>0,Number(k)+h>>>0)):[],pastPresentShareBuffer:!!l})},1273173:a=>{g.je(\"BiasAdd\",\na,void 0)},1273228:a=>{g.je(\"BiasSplitGelu\",a,void 0)},1273289:a=>{g.je(\"FastGelu\",a,void 0)},1273345:(a,b,c,d,e,f,h,k,l,m,n,q,r)=>{g.je(\"Conv\",a,{format:l?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c],group:d,kernel_shape:[e],pads:f?Array.from(G.subarray(f>>>0,h>>>0)):[],strides:[k],w_is_const:()=>!!z[m>>>0],activation:J(n),activation_params:q?Array.from(va.subarray(q>>>0,r>>>0)):[]})},1273715:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>{g.je(\"Conv\",a,{format:q?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c,d],group:e,kernel_shape:[f,\nh],pads:k?Array.from(G.subarray(k>>>0,l>>>0)):[],strides:[m,n],w_is_const:()=>!!z[r>>>0],activation:J(p),activation_params:u?Array.from(va.subarray(u>>>0,y>>>0)):[]})},1274106:a=>{g.je(\"Gelu\",a,void 0)},1274158:(a,b,c,d,e,f)=>{g.je(\"MatMulNBits\",a,{k:b,n:c,accuracyLevel:d,bits:e,blockSize:f})},1274285:(a,b,c,d,e,f)=>{g.je(\"MultiHeadAttention\",a,{numHeads:b,isUnidirectional:c,maskFilterValue:d,scale:e,doRotary:f})},1274444:(a,b,c,d,e)=>{g.je(\"RotaryEmbedding\",a,{interleaved:!!b,numHeads:c,rotaryEmbeddingDim:d,\nscale:e})},1274583:(a,b,c)=>{g.je(\"SkipLayerNormalization\",a,{epsilon:b,simplified:!!c})},1274685:(a,b,c)=>{g.je(\"SkipLayerNormalization\",a,{epsilon:b,simplified:!!c})},1274787:(a,b,c,d)=>{g.je(\"LayerNormalization\",a,{axis:b,epsilon:c,simplified:!!d})},1274898:a=>{g.di(a)},1274932:(a,b)=>g.fi(a,b,g.Oh.gi,g.Oh.errors)};function Pa(a){this.name=\"ExitStatus\";this.message=`Program terminated with exit(${a})`;this.status=a}var Qa=[],Ra=0,L=0;class Sa{constructor(a){this.Nh=a;this.Ih=a-24}}\nvar Za=a=>{var b=L;if(!b)return Ta(0),0;var c=new Sa(b);I[c.Ih+16>>>2>>>0]=b;var d=I[c.Ih+4>>>2>>>0];if(!d)return Ta(0),b;for(var e in a){var f=a[e];if(0===f||f===d)break;if(Ua(f,d,c.Ih+16))return Ta(f),b}Ta(d);return b},$a=\"undefined\"!=typeof TextDecoder?new TextDecoder(\"utf8\"):void 0,ab=(a,b,c)=>{b>>>=0;var d=b+c;for(c=b;a[c]&&!(c>=d);)++c;if(16<c-b&&a.buffer&&$a)return $a.decode(a.subarray(b,c));for(d=\"\";b<c;){var e=a[b++];if(e&128){var f=a[b++]&63;if(192==(e&224))d+=String.fromCharCode((e&31)<<\n6|f);else{var h=a[b++]&63;e=224==(e&240)?(e&15)<<12|f<<6|h:(e&7)<<18|f<<12|h<<6|a[b++]&63;65536>e?d+=String.fromCharCode(e):(e-=65536,d+=String.fromCharCode(55296|e>>10,56320|e&1023))}}else d+=String.fromCharCode(e)}return d},J=(a,b)=>(a>>>=0)?ab(E,a,b):\"\",bb=a=>{for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);127>=d?b++:2047>=d?b+=2:55296<=d&&57343>=d?(b+=4,++c):b+=3}return b},M=(a,b,c,d)=>{c>>>=0;if(!(0<d))return 0;var e=c;d=c+d-1;for(var f=0;f<a.length;++f){var h=a.charCodeAt(f);if(55296<=\nh&&57343>=h){var k=a.charCodeAt(++f);h=65536+((h&1023)<<10)|k&1023}if(127>=h){if(c>=d)break;b[c++>>>0]=h}else{if(2047>=h){if(c+1>=d)break;b[c++>>>0]=192|h>>6}else{if(65535>=h){if(c+2>=d)break;b[c++>>>0]=224|h>>12}else{if(c+3>=d)break;b[c++>>>0]=240|h>>18;b[c++>>>0]=128|h>>12&63}b[c++>>>0]=128|h>>6&63}b[c++>>>0]=128|h&63}}b[c>>>0]=0;return c-e},cb,N=a=>{for(var b=\"\";E[a>>>0];)b+=cb[E[a++>>>0]];return b},db={},eb={},fb={},O;\nfunction gb(a,b,c={}){var d=b.name;if(!a)throw new O(`type \"${d}\" must have a positive integer typeid pointer`);if(eb.hasOwnProperty(a)){if(c.Xh)return;throw new O(`Cannot register type '${d}' twice`);}eb[a]=b;delete fb[a];db.hasOwnProperty(a)&&(b=db[a],delete db[a],b.forEach(e=>e()))}function P(a,b,c={}){if(!(\"argPackAdvance\"in b))throw new TypeError(\"registerType registeredInstance requires argPackAdvance\");return gb(a,b,c)}\nvar hb=(a,b,c)=>{switch(b){case 1:return c?d=>z[d>>>0]:d=>E[d>>>0];case 2:return c?d=>ta[d>>>1>>>0]:d=>ua[d>>>1>>>0];case 4:return c?d=>G[d>>>2>>>0]:d=>I[d>>>2>>>0];case 8:return c?d=>wa[d>>>3]:d=>xa[d>>>3];default:throw new TypeError(`invalid integer width (${b}): ${a}`);}},ib=[],Q=[];function jb(a){a>>>=0;9<a&&0===--Q[a+1]&&(Q[a]=void 0,ib.push(a))}\nvar R=a=>{if(!a)throw new O(\"Cannot use deleted val. handle = \"+a);return Q[a]},S=a=>{switch(a){case void 0:return 2;case null:return 4;case !0:return 6;case !1:return 8;default:const b=ib.pop()||Q.length;Q[b]=a;Q[b+1]=1;return b}};function kb(a){return this.fromWireType(I[a>>>2>>>0])}\nvar lb={name:\"emscripten::val\",fromWireType:a=>{var b=R(a);jb(a);return b},toWireType:(a,b)=>S(b),argPackAdvance:8,readValueFromPointer:kb,Mh:null},mb=(a,b)=>{switch(b){case 4:return function(c){return this.fromWireType(va[c>>>2>>>0])};case 8:return function(c){return this.fromWireType(ya[c>>>3>>>0])};default:throw new TypeError(`invalid float width (${b}): ${a}`);}},nb=\"undefined\"!=typeof TextDecoder?new TextDecoder(\"utf-16le\"):void 0,ob=(a,b)=>{var c=a>>1;for(var d=c+b/2;!(c>=d)&&ua[c>>>0];)++c;\nc<<=1;if(32<c-a&&nb)return nb.decode(E.subarray(a>>>0,c>>>0));c=\"\";for(d=0;!(d>=b/2);++d){var e=ta[a+2*d>>>1>>>0];if(0==e)break;c+=String.fromCharCode(e)}return c},pb=(a,b,c)=>{c??=2147483647;if(2>c)return 0;c-=2;var d=b;c=c<2*a.length?c/2:a.length;for(var e=0;e<c;++e)ta[b>>>1>>>0]=a.charCodeAt(e),b+=2;ta[b>>>1>>>0]=0;return b-d},qb=a=>2*a.length,rb=(a,b)=>{for(var c=0,d=\"\";!(c>=b/4);){var e=G[a+4*c>>>2>>>0];if(0==e)break;++c;65536<=e?(e-=65536,d+=String.fromCharCode(55296|e>>10,56320|e&1023)):d+=\nString.fromCharCode(e)}return d},sb=(a,b,c)=>{b>>>=0;c??=2147483647;if(4>c)return 0;var d=b;c=d+c-4;for(var e=0;e<a.length;++e){var f=a.charCodeAt(e);if(55296<=f&&57343>=f){var h=a.charCodeAt(++e);f=65536+((f&1023)<<10)|h&1023}G[b>>>2>>>0]=f;b+=4;if(b+4>c)break}G[b>>>2>>>0]=0;return b-d},tb=a=>{for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);55296<=d&&57343>=d&&++c;b+=4}return b},vb=(a,b)=>{var c=eb[a];if(void 0===c)throw a=ub(a),c=N(a),T(a),new O(`${b} has unknown type ${c}`);return c},wb=\n(a,b,c)=>{var d=[];a=a.toWireType(d,c);d.length&&(I[b>>>2>>>0]=S(d));return a},xb=a=>{try{a()}catch(b){Ga(b)}},yb=a=>{if(!x)try{a();try{sa=sa=a=sa,g.onExit?.(a),x=!0,ha(a,new Pa(a))}catch(b){b instanceof Pa||\"unwind\"==b||ha(1,b)}}catch(b){b instanceof Pa||\"unwind\"==b||ha(1,b)}};\nfunction zb(){var a=U,b={};for(let [c,d]of Object.entries(a))b[c]=\"function\"==typeof d?(...e)=>{Ab.push(c);try{return d(...e)}finally{x||(Ab.pop(),t&&1===V&&0===Ab.length&&(V=0,xb(Bb),\"undefined\"!=typeof Fibers&&Fibers.mi()))}}:d;return b}var V=0,t=null,Cb=0,Ab=[],Db={},Eb={},Fb=0,Gb=null,Hb=[];function ca(){return new Promise((a,b)=>{Gb={resolve:a,reject:b}})}\nfunction Ib(){var a=Jb(65548),b=a+12;I[a>>>2>>>0]=b;I[a+4>>>2>>>0]=b+65536;b=Ab[0];var c=Db[b];void 0===c&&(c=Fb++,Db[b]=c,Eb[c]=b);G[a+8>>>2>>>0]=c;return a}\nfunction Kb(a){if(!x){if(0===V){var b=!1,c=!1;a((d=0)=>{if(!x&&(Cb=d,b=!0,c)){V=2;xb(()=>Lb(t));\"undefined\"!=typeof Browser&&Browser.Sh.Wh&&Browser.Sh.resume();d=!1;try{var e=(0,U[Eb[G[t+8>>>2>>>0]]])()}catch(k){e=k,d=!0}var f=!1;if(!t){var h=Gb;h&&(Gb=null,(d?h.reject:h.resolve)(e),f=!0)}if(d&&!f)throw e;}});c=!0;b||(V=1,t=Ib(),\"undefined\"!=typeof Browser&&Browser.Sh.Wh&&Browser.Sh.pause(),xb(()=>Mb(t)))}else 2===V?(V=0,xb(Nb),T(t),t=null,Hb.forEach(yb)):Ga(`invalid state: ${V}`);return Cb}}\nfunction Ob(a){return Kb(b=>{a().then(b)})}var Pb=[],Qb={},Rb=a=>{var b=Qb[a];return void 0===b?N(a):b},Sb=()=>\"object\"==typeof globalThis?globalThis:Function(\"return this\")(),Tb=a=>{var b=Pb.length;Pb.push(a);return b},Ub=(a,b)=>{for(var c=Array(a),d=0;d<a;++d)c[d]=vb(I[b+4*d>>>2>>>0],\"parameter \"+d);return c},Vb=(a,b)=>Object.defineProperty(b,\"name\",{value:a});\nfunction Wb(a){var b=Function;if(!(b instanceof Function))throw new TypeError(`new_ called with constructor type ${typeof b} which is not a function`);var c=Vb(b.name||\"unknownFunctionName\",function(){});c.prototype=b.prototype;c=new c;a=b.apply(c,a);return a instanceof Object?a:c}\nvar W=a=>0===a%4&&(0!==a%100||0===a%400),Xb=[0,31,60,91,121,152,182,213,244,274,305,335],Yb=[0,31,59,90,120,151,181,212,243,273,304,334],Zb=[],$b=(a,b)=>{Zb.length=0;for(var c;c=E[a++>>>0];){var d=105!=c;d&=112!=c;b+=d&&b%8?4:0;Zb.push(112==c?I[b>>>2>>>0]:106==c?wa[b>>>3]:105==c?G[b>>>2>>>0]:ya[b>>>3>>>0]);b+=d?8:4}return Zb},ac={},cc=()=>{if(!bc){var a={USER:\"web_user\",LOGNAME:\"web_user\",PATH:\"/\",PWD:\"/\",HOME:\"/home/web_user\",LANG:(\"object\"==typeof navigator&&navigator.languages&&navigator.languages[0]||\n\"C\").replace(\"-\",\"_\")+\".UTF-8\",_:fa||\"./this.program\"},b;for(b in ac)void 0===ac[b]?delete a[b]:a[b]=ac[b];var c=[];for(b in a)c.push(`${b}=${a[b]}`);bc=c}return bc},bc,dc=[null,[],[]],ec=[31,29,31,30,31,30,31,31,30,31,30,31],fc=[31,28,31,30,31,30,31,31,30,31,30,31];function gc(a){var b=Array(bb(a)+1);M(a,b,0,b.length);return b}\nfunction hc(a,b,c,d){function e(p,u,y){for(p=\"number\"==typeof p?p.toString():p||\"\";p.length<u;)p=y[0]+p;return p}function f(p,u){return e(p,u,\"0\")}function h(p,u){function y(B){return 0>B?-1:0<B?1:0}var A;0===(A=y(p.getFullYear()-u.getFullYear()))&&0===(A=y(p.getMonth()-u.getMonth()))&&(A=y(p.getDate()-u.getDate()));return A}function k(p){switch(p.getDay()){case 0:return new Date(p.getFullYear()-1,11,29);case 1:return p;case 2:return new Date(p.getFullYear(),0,3);case 3:return new Date(p.getFullYear(),\n0,2);case 4:return new Date(p.getFullYear(),0,1);case 5:return new Date(p.getFullYear()-1,11,31);case 6:return new Date(p.getFullYear()-1,11,30)}}function l(p){var u=p.Kh;for(p=new Date((new Date(p.Lh+1900,0,1)).getTime());0<u;){var y=p.getMonth(),A=(W(p.getFullYear())?ec:fc)[y];if(u>A-p.getDate())u-=A-p.getDate()+1,p.setDate(1),11>y?p.setMonth(y+1):(p.setMonth(0),p.setFullYear(p.getFullYear()+1));else{p.setDate(p.getDate()+u);break}}y=new Date(p.getFullYear()+1,0,4);u=k(new Date(p.getFullYear(),\n0,4));y=k(y);return 0>=h(u,p)?0>=h(y,p)?p.getFullYear()+1:p.getFullYear():p.getFullYear()-1}a>>>=0;b>>>=0;c>>>=0;d>>>=0;var m=I[d+40>>>2>>>0];d={ji:G[d>>>2>>>0],ii:G[d+4>>>2>>>0],Qh:G[d+8>>>2>>>0],Th:G[d+12>>>2>>>0],Rh:G[d+16>>>2>>>0],Lh:G[d+20>>>2>>>0],Jh:G[d+24>>>2>>>0],Kh:G[d+28>>>2>>>0],li:G[d+32>>>2>>>0],hi:G[d+36>>>2>>>0],ki:m?J(m):\"\"};c=J(c);m={\"%c\":\"%a %b %d %H:%M:%S %Y\",\"%D\":\"%m/%d/%y\",\"%F\":\"%Y-%m-%d\",\"%h\":\"%b\",\"%r\":\"%I:%M:%S %p\",\"%R\":\"%H:%M\",\"%T\":\"%H:%M:%S\",\"%x\":\"%m/%d/%y\",\"%X\":\"%H:%M:%S\",\n\"%Ec\":\"%c\",\"%EC\":\"%C\",\"%Ex\":\"%m/%d/%y\",\"%EX\":\"%H:%M:%S\",\"%Ey\":\"%y\",\"%EY\":\"%Y\",\"%Od\":\"%d\",\"%Oe\":\"%e\",\"%OH\":\"%H\",\"%OI\":\"%I\",\"%Om\":\"%m\",\"%OM\":\"%M\",\"%OS\":\"%S\",\"%Ou\":\"%u\",\"%OU\":\"%U\",\"%OV\":\"%V\",\"%Ow\":\"%w\",\"%OW\":\"%W\",\"%Oy\":\"%y\"};for(var n in m)c=c.replace(new RegExp(n,\"g\"),m[n]);var q=\"Sunday Monday Tuesday Wednesday Thursday Friday Saturday\".split(\" \"),r=\"January February March April May June July August September October November December\".split(\" \");m={\"%a\":p=>q[p.Jh].substring(0,3),\"%A\":p=>q[p.Jh],\"%b\":p=>\nr[p.Rh].substring(0,3),\"%B\":p=>r[p.Rh],\"%C\":p=>f((p.Lh+1900)/100|0,2),\"%d\":p=>f(p.Th,2),\"%e\":p=>e(p.Th,2,\" \"),\"%g\":p=>l(p).toString().substring(2),\"%G\":l,\"%H\":p=>f(p.Qh,2),\"%I\":p=>{p=p.Qh;0==p?p=12:12<p&&(p-=12);return f(p,2)},\"%j\":p=>{for(var u=0,y=0;y<=p.Rh-1;u+=(W(p.Lh+1900)?ec:fc)[y++]);return f(p.Th+u,3)},\"%m\":p=>f(p.Rh+1,2),\"%M\":p=>f(p.ii,2),\"%n\":()=>\"\\n\",\"%p\":p=>0<=p.Qh&&12>p.Qh?\"AM\":\"PM\",\"%S\":p=>f(p.ji,2),\"%t\":()=>\"\\t\",\"%u\":p=>p.Jh||7,\"%U\":p=>f(Math.floor((p.Kh+7-p.Jh)/7),2),\"%V\":p=>{var u=\nMath.floor((p.Kh+7-(p.Jh+6)%7)/7);2>=(p.Jh+371-p.Kh-2)%7&&u++;if(u)53==u&&(y=(p.Jh+371-p.Kh)%7,4==y||3==y&&W(p.Lh)||(u=1));else{u=52;var y=(p.Jh+7-p.Kh-1)%7;(4==y||5==y&&W(p.Lh%400-1))&&u++}return f(u,2)},\"%w\":p=>p.Jh,\"%W\":p=>f(Math.floor((p.Kh+7-(p.Jh+6)%7)/7),2),\"%y\":p=>(p.Lh+1900).toString().substring(2),\"%Y\":p=>p.Lh+1900,\"%z\":p=>{p=p.hi;var u=0<=p;p=Math.abs(p)/60;return(u?\"+\":\"-\")+String(\"0000\"+(p/60*100+p%60)).slice(-4)},\"%Z\":p=>p.ki,\"%%\":()=>\"%\"};c=c.replace(/%%/g,\"\\x00\\x00\");for(n in m)c.includes(n)&&\n(c=c.replace(new RegExp(n,\"g\"),m[n](d)));c=c.replace(/\\0\\0/g,\"%\");n=gc(c);if(n.length>b)return 0;z.set(n,a>>>0);return n.length-1}for(var ic=Array(256),jc=0;256>jc;++jc)ic[jc]=String.fromCharCode(jc);cb=ic;O=g.BindingError=class extends Error{constructor(a){super(a);this.name=\"BindingError\"}};g.InternalError=class extends Error{constructor(a){super(a);this.name=\"InternalError\"}};Q.push(0,1,void 0,1,null,1,!0,1,!1,1);g.count_emval_handles=()=>Q.length/2-5-ib.length;\nvar Cf={bd:function(a,b,c){return Ob(async()=>{await g.bi(a,b,c)})},v:function(a){a=new Sa(a>>>0);0==z[a.Ih+12>>>0]&&(z[a.Ih+12>>>0]=1,Ra--);z[a.Ih+13>>>0]=0;Qa.push(a);kc(a.Nh);if(lc(I[a.Ih+4>>>2>>>0]))a=I[a.Nh>>>2>>>0];else{var b=I[a.Ih+16>>>2>>>0];a=0!==b?b:a.Nh}return a},N:()=>{X(0,0);var a=Qa.pop();mc(a.Nh);L=0},a:function(){return Za([])},m:function(a){return Za([a>>>0])},x:function(a,b){return Za([a>>>0,b>>>0])},q:function(a,b,c){return Za([a>>>0,b>>>0,c>>>0])},Bb:()=>{var a=Qa.pop();a||Ga(\"no exception to throw\");\nvar b=a.Nh;0==z[a.Ih+13>>>0]&&(Qa.push(a),z[a.Ih+13>>>0]=1,z[a.Ih+12>>>0]=0,Ra++);L=b;throw L;},s:function(a,b,c){a>>>=0;var d=new Sa(a);I[d.Ih+16>>>2>>>0]=0;I[d.Ih+4>>>2>>>0]=b>>>0;I[d.Ih+8>>>2>>>0]=c>>>0;L=a;Ra++;throw L;},fb:()=>Ra,g:function(a){L||=a>>>0;throw L;},Cb:function(){return 0},$c:function(){},Mc:function(){},Oc:function(){},Gc:function(){return 0},Zc:function(){},Uc:function(){},Yc:function(){},_b:function(){},Nc:function(){},Kc:function(){},_c:function(){},Lc:function(){},Wb:function(a,\nb,c){b=N(b>>>0);P(a>>>0,{name:b,fromWireType:d=>d,toWireType:function(d,e){if(\"bigint\"!=typeof e&&\"number\"!=typeof e)throw null===e?e=\"null\":(d=typeof e,e=\"object\"===d||\"array\"===d||\"function\"===d?e.toString():\"\"+e),new TypeError(`Cannot convert \"${e}\" to ${this.name}`);\"number\"==typeof e&&(e=BigInt(e));return e},argPackAdvance:8,readValueFromPointer:hb(b,c>>>0,-1==b.indexOf(\"u\")),Mh:null})},Ec:function(a,b,c,d){b=N(b>>>0);P(a>>>0,{name:b,fromWireType:function(e){return!!e},toWireType:function(e,\nf){return f?c:d},argPackAdvance:8,readValueFromPointer:function(e){return this.fromWireType(E[e>>>0])},Mh:null})},Cc:function(a){return P(a>>>0,lb)},Vb:function(a,b,c){b=N(b>>>0);P(a>>>0,{name:b,fromWireType:d=>d,toWireType:(d,e)=>e,argPackAdvance:8,readValueFromPointer:mb(b,c>>>0),Mh:null})},Aa:function(a,b,c,d,e){a>>>=0;c>>>=0;b=N(b>>>0);-1===e&&(e=4294967295);e=k=>k;if(0===d){var f=32-8*c;e=k=>k<<f>>>f}var h=b.includes(\"unsigned\")?function(k,l){return l>>>0}:function(k,l){return l};P(a,{name:b,\nfromWireType:e,toWireType:h,argPackAdvance:8,readValueFromPointer:hb(b,c,0!==d),Mh:null})},_:function(a,b,c){function d(f){return new e(z.buffer,I[f+4>>>2>>>0],I[f>>>2>>>0])}var e=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,BigInt64Array,BigUint64Array][b];c=N(c>>>0);P(a>>>0,{name:c,fromWireType:d,argPackAdvance:8,readValueFromPointer:d},{Xh:!0})},Xb:function(a,b){b=N(b>>>0);var c=\"std::string\"===b;P(a>>>0,{name:b,fromWireType:function(d){var e=I[d>>>\n2>>>0],f=d+4;if(c)for(var h=f,k=0;k<=e;++k){var l=f+k;if(k==e||0==E[l>>>0]){h=J(h,l-h);if(void 0===m)var m=h;else m+=String.fromCharCode(0),m+=h;h=l+1}}else{m=Array(e);for(k=0;k<e;++k)m[k]=String.fromCharCode(E[f+k>>>0]);m=m.join(\"\")}T(d);return m},toWireType:function(d,e){e instanceof ArrayBuffer&&(e=new Uint8Array(e));var f=\"string\"==typeof e;if(!(f||e instanceof Uint8Array||e instanceof Uint8ClampedArray||e instanceof Int8Array))throw new O(\"Cannot pass non-string to std::string\");var h=c&&f?bb(e):\ne.length;var k=Jb(4+h+1),l=k+4;I[k>>>2>>>0]=h;if(c&&f)M(e,E,l,h+1);else if(f)for(f=0;f<h;++f){var m=e.charCodeAt(f);if(255<m)throw T(l),new O(\"String has UTF-16 code units that do not fit in 8 bits\");E[l+f>>>0]=m}else for(f=0;f<h;++f)E[l+f>>>0]=e[f];null!==d&&d.push(T,k);return k},argPackAdvance:8,readValueFromPointer:kb,Mh(d){T(d)}})},Ab:function(a,b,c){b>>>=0;c>>>=0;c=N(c);if(2===b){var d=ob;var e=pb;var f=qb;var h=k=>ua[k>>>1>>>0]}else 4===b&&(d=rb,e=sb,f=tb,h=k=>I[k>>>2>>>0]);P(a>>>0,{name:c,\nfromWireType:k=>{for(var l=I[k>>>2>>>0],m,n=k+4,q=0;q<=l;++q){var r=k+4+q*b;if(q==l||0==h(r))n=d(n,r-n),void 0===m?m=n:(m+=String.fromCharCode(0),m+=n),n=r+b}T(k);return m},toWireType:(k,l)=>{if(\"string\"!=typeof l)throw new O(`Cannot pass non-string to C++ string type ${c}`);var m=f(l),n=Jb(4+m+b);I[n>>>2>>>0]=m/b;e(l,n+4,m+b);null!==k&&k.push(T,n);return n},argPackAdvance:8,readValueFromPointer:kb,Mh(k){T(k)}})},Fc:function(a,b){b=N(b>>>0);P(a>>>0,{Yh:!0,name:b,argPackAdvance:0,fromWireType:()=>\n{},toWireType:()=>{}})},ad:()=>1,kd:function(a,b,c){b>>>=0;c>>>=0;a=R(a>>>0);b=vb(b,\"emval::as\");return wb(b,c,a)},Cd:function(a){a>>>=0;return Ob(()=>{a=R(a);return a.then(S)})},ud:function(a,b,c,d){c>>>=0;d>>>=0;a=Pb[a>>>0];b=R(b>>>0);return a(null,b,c,d)},ia:function(a,b,c,d,e){c>>>=0;d>>>=0;e>>>=0;a=Pb[a>>>0];b=R(b>>>0);c=Rb(c);return a(b,b[c],d,e)},Bc:jb,qd:function(a,b){b>>>=0;a=R(a>>>0);b=R(b);return a==b},zd:function(a){a>>>=0;if(0===a)return S(Sb());a=Rb(a);return S(Sb()[a])},ha:function(a,\nb,c){b=Ub(a,b>>>0);var d=b.shift();a--;var e=\"return function (obj, func, destructorsRef, args) {\\n\",f=0,h=[];0===c&&h.push(\"obj\");for(var k=[\"retType\"],l=[d],m=0;m<a;++m)h.push(\"arg\"+m),k.push(\"argType\"+m),l.push(b[m]),e+=`  var arg${m} = argType${m}.readValueFromPointer(args${f?\"+\"+f:\"\"});\\n`,f+=b[m].argPackAdvance;e+=`  var rv = ${1===c?\"new func\":\"func.call\"}(${h.join(\", \")});\\n`;d.Yh||(k.push(\"emval_returnValue\"),l.push(wb),e+=\"  return emval_returnValue(retType, destructorsRef, rv);\\n\");k.push(e+\n\"};\\n\");a=Wb(k)(...l);c=`methodCaller<(${b.map(n=>n.name).join(\", \")}) => ${d.name}>`;return Tb(Vb(c,a))},yd:function(a,b){b>>>=0;a=R(a>>>0);b=R(b);return S(a[b])},ba:function(a){a>>>=0;9<a&&(Q[a+1]+=1)},md:function(){return S([])},hd:function(a){a=R(a>>>0);for(var b=Array(a.length),c=0;c<a.length;c++)b[c]=a[c];return S(b)},U:function(a){return S(Rb(a>>>0))},Xa:function(){return S({})},vd:function(a){a>>>=0;for(var b=R(a);b.length;){var c=b.pop();b.pop()(c)}jb(a)},sd:function(a,b,c){b>>>=0;c>>>=0;\na=R(a>>>0);b=R(b);c=R(c);a[b]=c},zb:function(a,b){b>>>=0;a=vb(a>>>0,\"_emval_take_value\");a=a.readValueFromPointer(b);return S(a)},Rc:function(a,b){a=-9007199254740992>a||9007199254740992<a?NaN:Number(a);b>>>=0;a=new Date(1E3*a);G[b>>>2>>>0]=a.getUTCSeconds();G[b+4>>>2>>>0]=a.getUTCMinutes();G[b+8>>>2>>>0]=a.getUTCHours();G[b+12>>>2>>>0]=a.getUTCDate();G[b+16>>>2>>>0]=a.getUTCMonth();G[b+20>>>2>>>0]=a.getUTCFullYear()-1900;G[b+24>>>2>>>0]=a.getUTCDay();G[b+28>>>2>>>0]=(a.getTime()-Date.UTC(a.getUTCFullYear(),\n0,1,0,0,0,0))/864E5|0},Sc:function(a,b){a=-9007199254740992>a||9007199254740992<a?NaN:Number(a);b>>>=0;a=new Date(1E3*a);G[b>>>2>>>0]=a.getSeconds();G[b+4>>>2>>>0]=a.getMinutes();G[b+8>>>2>>>0]=a.getHours();G[b+12>>>2>>>0]=a.getDate();G[b+16>>>2>>>0]=a.getMonth();G[b+20>>>2>>>0]=a.getFullYear()-1900;G[b+24>>>2>>>0]=a.getDay();G[b+28>>>2>>>0]=(W(a.getFullYear())?Xb:Yb)[a.getMonth()]+a.getDate()-1|0;G[b+36>>>2>>>0]=-(60*a.getTimezoneOffset());var c=(new Date(a.getFullYear(),6,1)).getTimezoneOffset(),\nd=(new Date(a.getFullYear(),0,1)).getTimezoneOffset();G[b+32>>>2>>>0]=(c!=d&&a.getTimezoneOffset()==Math.min(d,c))|0},Tc:function(a){a>>>=0;var b=new Date(G[a+20>>>2>>>0]+1900,G[a+16>>>2>>>0],G[a+12>>>2>>>0],G[a+8>>>2>>>0],G[a+4>>>2>>>0],G[a>>>2>>>0],0),c=G[a+32>>>2>>>0],d=b.getTimezoneOffset(),e=(new Date(b.getFullYear(),6,1)).getTimezoneOffset(),f=(new Date(b.getFullYear(),0,1)).getTimezoneOffset(),h=Math.min(f,e);0>c?G[a+32>>>2>>>0]=Number(e!=f&&h==d):0<c!=(h==d)&&(e=Math.max(f,e),b.setTime(b.getTime()+\n6E4*((0<c?h:e)-d)));G[a+24>>>2>>>0]=b.getDay();G[a+28>>>2>>>0]=(W(b.getFullYear())?Xb:Yb)[b.getMonth()]+b.getDate()-1|0;G[a>>>2>>>0]=b.getSeconds();G[a+4>>>2>>>0]=b.getMinutes();G[a+8>>>2>>>0]=b.getHours();G[a+12>>>2>>>0]=b.getDate();G[a+16>>>2>>>0]=b.getMonth();G[a+20>>>2>>>0]=b.getYear();a=b.getTime();return BigInt(isNaN(a)?-1:a/1E3)},Pc:function(){return-52},Qc:function(){},Ic:function(a,b,c,d){c>>>=0;d>>>=0;var e=(new Date).getFullYear(),f=new Date(e,0,1),h=new Date(e,6,1);e=f.getTimezoneOffset();\nvar k=h.getTimezoneOffset();I[a>>>0>>>2>>>0]=60*Math.max(e,k);G[b>>>0>>>2>>>0]=Number(e!=k);a=l=>l.toLocaleTimeString(void 0,{hour12:!1,timeZoneName:\"short\"}).split(\" \")[1];f=a(f);h=a(h);k<e?(M(f,E,c,17),M(h,E,d,17)):(M(f,E,d,17),M(h,E,c,17))},bb:()=>{Ga(\"\")},A:function(a,b,c){a>>>=0;b=$b(b>>>0,c>>>0);return Oa[a](...b)},bc:function(a,b,c){a>>>=0;b=$b(b>>>0,c>>>0);return Oa[a](...b)},$b:()=>Date.now(),Jc:function(){return 4294901760},ga:()=>performance.now(),Hc:function(a){a>>>=0;var b=E.length;if(4294901760<\na)return!1;for(var c=1;4>=c;c*=2){var d=b*(1+.2/c);d=Math.min(d,a+100663296);var e=Math;d=Math.max(a,d);a:{e=(e.min.call(e,4294901760,d+(65536-d%65536)%65536)-ra.buffer.byteLength+65535)/65536;try{ra.grow(e);za();var f=1;break a}catch(h){}f=void 0}if(f)return!0}return!1},Wc:function(a,b){a>>>=0;b>>>=0;var c=0;cc().forEach((d,e)=>{var f=b+c;e=I[a+4*e>>>2>>>0]=f;for(f=0;f<d.length;++f)z[e++>>>0]=d.charCodeAt(f);z[e>>>0]=0;c+=d.length+1});return 0},Xc:function(a,b){a>>>=0;b>>>=0;var c=cc();I[a>>>2>>>\n0]=c.length;var d=0;c.forEach(e=>d+=e.length+1);I[b>>>2>>>0]=d;return 0},Db:()=>52,Zb:function(){return 52},Vc:function(){return 70},Yb:function(a,b,c,d){b>>>=0;c>>>=0;d>>>=0;for(var e=0,f=0;f<c;f++){var h=I[b>>>2>>>0],k=I[b+4>>>2>>>0];b+=8;for(var l=0;l<k;l++){var m=E[h+l>>>0],n=dc[a];0===m||10===m?((1===a?qa:w)(ab(n,0)),n.length=0):n.push(m)}e+=k}I[d>>>2>>>0]=e;return 0},xb:nc,cd:oc,ua:pc,W:qc,$:rc,ra:sc,ta:tc,dd:uc,ob:vc,P:wc,z:xc,b:yc,Ub:zc,ya:Ac,e:Bc,kb:Cc,h:Dc,X:Ec,i:Fc,ed:Gc,j:Hc,t:Ic,r:Jc,\no:Kc,Wa:Lc,Ca:Mc,ma:Nc,Qb:Oc,db:Pc,Ib:Qc,mb:Rc,kc:Sc,xc:Tc,hc:Uc,ic:Vc,ac:Wc,oa:Xc,yb:Yc,Ba:Zc,Eb:$c,ea:ad,jc:bd,Ta:cd,F:dd,G:ed,Gb:fd,jd:gd,qa:hd,O:jd,V:kd,T:ld,y:md,Fb:nd,gc:od,D:pd,Hb:qd,id:rd,Ua:sd,wa:td,lc:ud,cc:vd,Nb:wd,aa:xd,I:yd,C:zd,_a:Ad,fc:Bd,Q:Cd,d:Dd,ab:Ed,n:Fd,Ya:Gd,va:Hd,wb:Id,f:Jd,yc:Kd,da:Ld,gb:Md,Da:Nd,lb:Od,hb:Pd,c:Qd,vc:Rd,od:Sd,k:Td,tc:Ud,l:Vd,wc:Wd,sc:Xd,rd:Yd,p:Zd,Ra:$d,tb:ae,Qa:be,Kb:ce,B:de,K:ee,S:fe,$a:ge,pc:he,ub:ie,za:je,ka:ke,xa:le,Sb:me,La:ne,jb:oe,Ga:pe,nc:qe,Ha:re,\nIa:se,fd:te,xd:ue,Z:ve,pa:we,pd:xe,wd:ye,Mb:ze,Ma:Ae,Ka:Be,Tb:Ce,rc:De,Ja:Ee,Na:Fe,pb:Ge,la:He,Ea:Ie,mc:Je,qc:Ke,Jb:Le,Fa:Me,ja:Ne,Ad:Oe,nd:Pe,R:Qe,eb:Re,Za:Se,ec:Te,ib:Ue,E:Ve,M:We,Va:Xe,ld:Ye,ca:Ze,nb:$e,na:af,dc:bf,Ac:cf,u:df,L:ef,td:ff,Pb:gf,oc:hf,Bd:jf,Ob:kf,Lb:lf,cb:mf,zc:nf,Rb:of,Oa:pf,Y:qf,uc:rf,J:sf,gd:tf,vb:uf,sa:vf,H:wf,rb:xf,Pa:yf,Sa:zf,sb:Af,qb:Bf,w:function(a){return a>>>0},Dc:hc,fa:function(a,b,c,d){return hc(a>>>0,b>>>0,c>>>0,d>>>0)}},U=function(){function a(c){U=c.exports;U=zb();\nU=Df();ra=U.Dd;za();Ba.unshift(U.Ed);Da--;0==Da&&(null!==Ea&&(clearInterval(Ea),Ea=null),Fa&&(c=Fa,Fa=null,c()));return U}var b={a:Cf};Da++;if(g.instantiateWasm)try{return g.instantiateWasm(b,a)}catch(c){w(`Module.instantiateWasm callback failed with error: ${c}`),ba(c)}Na(b,function(c){a(c.instance)}).catch(ba);return{}}(),ub=a=>(ub=U.Fd)(a);g._OrtInit=(a,b)=>(g._OrtInit=U.Gd)(a,b);g._OrtGetLastError=(a,b)=>(g._OrtGetLastError=U.Hd)(a,b);\ng._OrtCreateSessionOptions=(a,b,c,d,e,f,h,k,l,m)=>(g._OrtCreateSessionOptions=U.Id)(a,b,c,d,e,f,h,k,l,m);g._OrtAppendExecutionProvider=(a,b)=>(g._OrtAppendExecutionProvider=U.Jd)(a,b);g._OrtAddFreeDimensionOverride=(a,b,c)=>(g._OrtAddFreeDimensionOverride=U.Kd)(a,b,c);g._OrtAddSessionConfigEntry=(a,b,c)=>(g._OrtAddSessionConfigEntry=U.Ld)(a,b,c);g._OrtReleaseSessionOptions=a=>(g._OrtReleaseSessionOptions=U.Md)(a);g._OrtCreateSession=(a,b,c)=>(g._OrtCreateSession=U.Nd)(a,b,c);\ng._OrtReleaseSession=a=>(g._OrtReleaseSession=U.Od)(a);g._OrtGetInputOutputCount=(a,b,c)=>(g._OrtGetInputOutputCount=U.Pd)(a,b,c);g._OrtGetInputName=(a,b)=>(g._OrtGetInputName=U.Qd)(a,b);g._OrtGetOutputName=(a,b)=>(g._OrtGetOutputName=U.Rd)(a,b);g._OrtFree=a=>(g._OrtFree=U.Sd)(a);g._OrtCreateTensor=(a,b,c,d,e,f)=>(g._OrtCreateTensor=U.Td)(a,b,c,d,e,f);g._OrtGetTensorData=(a,b,c,d,e)=>(g._OrtGetTensorData=U.Ud)(a,b,c,d,e);g._OrtReleaseTensor=a=>(g._OrtReleaseTensor=U.Vd)(a);\ng._OrtCreateRunOptions=(a,b,c,d)=>(g._OrtCreateRunOptions=U.Wd)(a,b,c,d);g._OrtAddRunConfigEntry=(a,b,c)=>(g._OrtAddRunConfigEntry=U.Xd)(a,b,c);g._OrtReleaseRunOptions=a=>(g._OrtReleaseRunOptions=U.Yd)(a);g._OrtCreateBinding=a=>(g._OrtCreateBinding=U.Zd)(a);g._OrtBindInput=(a,b,c)=>(g._OrtBindInput=U._d)(a,b,c);g._OrtBindOutput=(a,b,c,d)=>(g._OrtBindOutput=U.$d)(a,b,c,d);g._OrtClearBoundOutputs=a=>(g._OrtClearBoundOutputs=U.ae)(a);g._OrtReleaseBinding=a=>(g._OrtReleaseBinding=U.be)(a);\ng._OrtRunWithBinding=(a,b,c,d,e)=>(g._OrtRunWithBinding=U.ce)(a,b,c,d,e);g._OrtRun=(a,b,c,d,e,f,h,k)=>(g._OrtRun=U.de)(a,b,c,d,e,f,h,k);g._OrtEndProfiling=a=>(g._OrtEndProfiling=U.ee)(a);g._JsepOutput=(a,b,c)=>(g._JsepOutput=U.fe)(a,b,c);g._JsepGetNodeName=a=>(g._JsepGetNodeName=U.ge)(a);\nvar Jb=g._malloc=a=>(Jb=g._malloc=U.he)(a),T=g._free=a=>(T=g._free=U.ie)(a),X=(a,b)=>(X=U.ke)(a,b),Ta=a=>(Ta=U.le)(a),Y=a=>(Y=U.me)(a),Ef=a=>(Ef=U.ne)(a),Z=()=>(Z=U.oe)(),mc=a=>(mc=U.pe)(a),kc=a=>(kc=U.qe)(a),Ua=(a,b,c)=>(Ua=U.re)(a,b,c),lc=a=>(lc=U.se)(a),dynCall_vii=g.dynCall_vii=(a,b,c)=>(dynCall_vii=g.dynCall_vii=U.te)(a,b,c),Ff=g.dynCall_iiii=(a,b,c,d)=>(Ff=g.dynCall_iiii=U.ue)(a,b,c,d),dynCall_iii=g.dynCall_iii=(a,b,c)=>(dynCall_iii=g.dynCall_iii=U.ve)(a,b,c),Gf=g.dynCall_ii=(a,b)=>(Gf=g.dynCall_ii=\nU.we)(a,b),Hf=g.dynCall_iiiiiii=(a,b,c,d,e,f,h)=>(Hf=g.dynCall_iiiiiii=U.xe)(a,b,c,d,e,f,h),dynCall_vi=g.dynCall_vi=(a,b)=>(dynCall_vi=g.dynCall_vi=U.ye)(a,b),dynCall_v=g.dynCall_v=a=>(dynCall_v=g.dynCall_v=U.ze)(a),If=g.dynCall_iiiiii=(a,b,c,d,e,f)=>(If=g.dynCall_iiiiii=U.Ae)(a,b,c,d,e,f),Jf=g.dynCall_iiij=(a,b,c,d)=>(Jf=g.dynCall_iiij=U.Be)(a,b,c,d),Kf=g.dynCall_iiiii=(a,b,c,d,e)=>(Kf=g.dynCall_iiiii=U.Ce)(a,b,c,d,e),Lf=g.dynCall_viii=(a,b,c,d)=>(Lf=g.dynCall_viii=U.De)(a,b,c,d),Mf=g.dynCall_viiiii=\n(a,b,c,d,e,f)=>(Mf=g.dynCall_viiiii=U.Ee)(a,b,c,d,e,f),Nf=g.dynCall_viiii=(a,b,c,d,e)=>(Nf=g.dynCall_viiii=U.Fe)(a,b,c,d,e),Of=g.dynCall_viiiiii=(a,b,c,d,e,f,h)=>(Of=g.dynCall_viiiiii=U.Ge)(a,b,c,d,e,f,h),Pf=g.dynCall_viiji=(a,b,c,d,e)=>(Pf=g.dynCall_viiji=U.He)(a,b,c,d,e),Qf=g.dynCall_viiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q)=>(Qf=g.dynCall_viiiiiiiiiii=U.Ie)(a,b,c,d,e,f,h,k,l,m,n,q),Rf=g.dynCall_viiijjjii=(a,b,c,d,e,f,h,k,l)=>(Rf=g.dynCall_viiijjjii=U.Je)(a,b,c,d,e,f,h,k,l),Sf=g.dynCall_iid=(a,b,c)=>\n(Sf=g.dynCall_iid=U.Ke)(a,b,c),Tf=g.dynCall_iif=(a,b,c)=>(Tf=g.dynCall_iif=U.Le)(a,b,c),Uf=g.dynCall_iij=(a,b,c)=>(Uf=g.dynCall_iij=U.Me)(a,b,c),Vf=g.dynCall_jii=(a,b,c)=>(Vf=g.dynCall_jii=U.Ne)(a,b,c),Wf=g.dynCall_i=a=>(Wf=g.dynCall_i=U.Oe)(a),Xf=g.dynCall_viiiiiiii=(a,b,c,d,e,f,h,k,l)=>(Xf=g.dynCall_viiiiiiii=U.Pe)(a,b,c,d,e,f,h,k,l),Yf=g.dynCall_viiiiij=(a,b,c,d,e,f,h)=>(Yf=g.dynCall_viiiiij=U.Qe)(a,b,c,d,e,f,h),Zf=g.dynCall_ji=(a,b)=>(Zf=g.dynCall_ji=U.Re)(a,b),$f=g.dynCall_viij=(a,b,c,d)=>($f=\ng.dynCall_viij=U.Se)(a,b,c,d),ag=g.dynCall_iiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q)=>(ag=g.dynCall_iiiiiiiiiiii=U.Te)(a,b,c,d,e,f,h,k,l,m,n,q),bg=g.dynCall_viiiiiiiii=(a,b,c,d,e,f,h,k,l,m)=>(bg=g.dynCall_viiiiiiiii=U.Ue)(a,b,c,d,e,f,h,k,l,m),cg=g.dynCall_ij=(a,b)=>(cg=g.dynCall_ij=U.Ve)(a,b),dg=g.dynCall_iiiiij=(a,b,c,d,e,f)=>(dg=g.dynCall_iiiiij=U.We)(a,b,c,d,e,f),eg=g.dynCall_j=a=>(eg=g.dynCall_j=U.Xe)(a),fg=g.dynCall_vij=(a,b,c)=>(fg=g.dynCall_vij=U.Ye)(a,b,c),gg=g.dynCall_viijjjiiiiii=(a,b,c,d,\ne,f,h,k,l,m,n,q)=>(gg=g.dynCall_viijjjiiiiii=U.Ze)(a,b,c,d,e,f,h,k,l,m,n,q),hg=g.dynCall_viiijiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q)=>(hg=g.dynCall_viiijiiiiiii=U._e)(a,b,c,d,e,f,h,k,l,m,n,q),ig=g.dynCall_iiiiiiii=(a,b,c,d,e,f,h,k)=>(ig=g.dynCall_iiiiiiii=U.$e)(a,b,c,d,e,f,h,k),jg=g.dynCall_viiiiiii=(a,b,c,d,e,f,h,k)=>(jg=g.dynCall_viiiiiii=U.af)(a,b,c,d,e,f,h,k),kg=g.dynCall_iiiiiiiij=(a,b,c,d,e,f,h,k,l)=>(kg=g.dynCall_iiiiiiiij=U.bf)(a,b,c,d,e,f,h,k,l),lg=g.dynCall_viiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,\nm,n,q,r,p)=>(lg=g.dynCall_viiiiiiiiiiiii=U.cf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),mg=g.dynCall_iiiiiiiii=(a,b,c,d,e,f,h,k,l)=>(mg=g.dynCall_iiiiiiiii=U.df)(a,b,c,d,e,f,h,k,l),ng=g.dynCall_iiiiijiiiii=(a,b,c,d,e,f,h,k,l,m,n)=>(ng=g.dynCall_iiiiijiiiii=U.ef)(a,b,c,d,e,f,h,k,l,m,n),og=g.dynCall_vijjjiiij=(a,b,c,d,e,f,h,k,l)=>(og=g.dynCall_vijjjiiij=U.ff)(a,b,c,d,e,f,h,k,l),pg=g.dynCall_fi=(a,b)=>(pg=g.dynCall_fi=U.gf)(a,b),qg=g.dynCall_fii=(a,b,c)=>(qg=g.dynCall_fii=U.hf)(a,b,c),rg=g.dynCall_di=(a,b)=>(rg=\ng.dynCall_di=U.jf)(a,b),sg=g.dynCall_dii=(a,b,c)=>(sg=g.dynCall_dii=U.kf)(a,b,c),tg=g.dynCall_vijj=(a,b,c,d)=>(tg=g.dynCall_vijj=U.lf)(a,b,c,d),ug=g.dynCall_iiiiiiiiii=(a,b,c,d,e,f,h,k,l,m)=>(ug=g.dynCall_iiiiiiiiii=U.mf)(a,b,c,d,e,f,h,k,l,m),vg=g.dynCall_viijiii=(a,b,c,d,e,f,h)=>(vg=g.dynCall_viijiii=U.nf)(a,b,c,d,e,f,h),wg=g.dynCall_viid=(a,b,c,d)=>(wg=g.dynCall_viid=U.of)(a,b,c,d),xg=g.dynCall_viffiii=(a,b,c,d,e,f,h)=>(xg=g.dynCall_viffiii=U.pf)(a,b,c,d,e,f,h),yg=g.dynCall_viifiii=(a,b,c,d,e,f,\nh)=>(yg=g.dynCall_viifiii=U.qf)(a,b,c,d,e,f,h),zg=g.dynCall_viiiiidiidi=(a,b,c,d,e,f,h,k,l,m,n)=>(zg=g.dynCall_viiiiidiidi=U.rf)(a,b,c,d,e,f,h,k,l,m,n),Ag=g.dynCall_viiiiiiiiidi=(a,b,c,d,e,f,h,k,l,m,n,q)=>(Ag=g.dynCall_viiiiiiiiidi=U.sf)(a,b,c,d,e,f,h,k,l,m,n,q),Bg=g.dynCall_jiii=(a,b,c,d)=>(Bg=g.dynCall_jiii=U.tf)(a,b,c,d),Cg=g.dynCall_vjiiiiii=(a,b,c,d,e,f,h,k)=>(Cg=g.dynCall_vjiiiiii=U.uf)(a,b,c,d,e,f,h,k),Dg=g.dynCall_viiid=(a,b,c,d,e)=>(Dg=g.dynCall_viiid=U.vf)(a,b,c,d,e),Eg=g.dynCall_viiiiiiiiiji=\n(a,b,c,d,e,f,h,k,l,m,n,q)=>(Eg=g.dynCall_viiiiiiiiiji=U.wf)(a,b,c,d,e,f,h,k,l,m,n,q),Fg=g.dynCall_viji=(a,b,c,d)=>(Fg=g.dynCall_viji=U.xf)(a,b,c,d),Gg=g.dynCall_vijjjjjjjjjjjjji=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>(Gg=g.dynCall_vijjjjjjjjjjjjji=U.yf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y),Hg=g.dynCall_viiiji=(a,b,c,d,e,f)=>(Hg=g.dynCall_viiiji=U.zf)(a,b,c,d,e,f),Ig=g.dynCall_vijjjiiji=(a,b,c,d,e,f,h,k,l)=>(Ig=g.dynCall_vijjjiiji=U.Af)(a,b,c,d,e,f,h,k,l),Jg=g.dynCall_iiiji=(a,b,c,d,e)=>(Jg=g.dynCall_iiiji=\nU.Bf)(a,b,c,d,e),Kg=g.dynCall_iiijiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(Kg=g.dynCall_iiijiiiiiiiiii=U.Cf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),Lg=g.dynCall_vj=(a,b)=>(Lg=g.dynCall_vj=U.Df)(a,b),Mg=g.dynCall_jjj=(a,b,c)=>(Mg=g.dynCall_jjj=U.Ef)(a,b,c),Ng=g.dynCall_iiijiiiiii=(a,b,c,d,e,f,h,k,l,m)=>(Ng=g.dynCall_iiijiiiiii=U.Ff)(a,b,c,d,e,f,h,k,l,m),Og=g.dynCall_vfiii=(a,b,c,d,e)=>(Og=g.dynCall_vfiii=U.Gf)(a,b,c,d,e),Pg=g.dynCall_viiiiff=(a,b,c,d,e,f,h)=>(Pg=g.dynCall_viiiiff=U.Hf)(a,b,c,d,e,f,h),Qg=g.dynCall_viiiiiff=\n(a,b,c,d,e,f,h,k)=>(Qg=g.dynCall_viiiiiff=U.If)(a,b,c,d,e,f,h,k),Rg=g.dynCall_viiff=(a,b,c,d,e)=>(Rg=g.dynCall_viiff=U.Jf)(a,b,c,d,e),Sg=g.dynCall_viiiiiiiiifiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(Sg=g.dynCall_viiiiiiiiifiii=U.Kf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),Tg=g.dynCall_viiiiiiiijj=(a,b,c,d,e,f,h,k,l,m,n)=>(Tg=g.dynCall_viiiiiiiijj=U.Lf)(a,b,c,d,e,f,h,k,l,m,n),Ug=g.dynCall_iiiiiiiiiiiiiifii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)=>(Ug=g.dynCall_iiiiiiiiiiiiiifii=U.Mf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A),\nVg=g.dynCall_viiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Vg=g.dynCall_viiiiiiiiiiii=U.Nf)(a,b,c,d,e,f,h,k,l,m,n,q,r),Wg=g.dynCall_iiiiiiiiiiiiiiiiifii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)=>(Wg=g.dynCall_iiiiiiiiiiiiiiiiifii=U.Of)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D),Xg=g.dynCall_vijjiiiiii=(a,b,c,d,e,f,h,k,l,m)=>(Xg=g.dynCall_vijjiiiiii=U.Pf)(a,b,c,d,e,f,h,k,l,m),Yg=g.dynCall_iiiijjj=(a,b,c,d,e,f,h)=>(Yg=g.dynCall_iiiijjj=U.Qf)(a,b,c,d,e,f,h),Zg=g.dynCall_viiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,\nn)=>(Zg=g.dynCall_viiiiiiiiii=U.Rf)(a,b,c,d,e,f,h,k,l,m,n),$g=g.dynCall_iiijjj=(a,b,c,d,e,f)=>($g=g.dynCall_iiijjj=U.Sf)(a,b,c,d,e,f),ah=g.dynCall_fffffff=(a,b,c,d,e,f,h)=>(ah=g.dynCall_fffffff=U.Tf)(a,b,c,d,e,f,h),bh=g.dynCall_viiiij=(a,b,c,d,e,f)=>(bh=g.dynCall_viiiij=U.Uf)(a,b,c,d,e,f),ch=g.dynCall_viiiiiijiifiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(ch=g.dynCall_viiiiiijiifiii=U.Vf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),dh=g.dynCall_vjjjjjjffjifiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B)=>(dh=g.dynCall_vjjjjjjffjifiiiiii=\nU.Wf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B),eh=g.dynCall_viiiiiiffjifiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)=>(eh=g.dynCall_viiiiiiffjifiiiii=U.Xf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A),fh=g.dynCall_viiiiiiffjfiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>(fh=g.dynCall_viiiiiiffjfiiiii=U.Yf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y),gh=g.dynCall_viiiiiiffjiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>(gh=g.dynCall_viiiiiiffjiiiii=U.Zf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u),hh=g.dynCall_vjjjjjjjjfffiiifiiiii=(a,b,c,d,e,f,h,k,l,\nm,n,q,r,p,u,y,A,B,C,D,F)=>(hh=g.dynCall_vjjjjjjjjfffiiifiiiii=U._f)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F),ih=g.dynCall_vjjjjjjfffifijiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C)=>(ih=g.dynCall_vjjjjjjfffifijiiiii=U.$f)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C),jh=g.dynCall_vjjjjjjfffifiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B)=>(jh=g.dynCall_vjjjjjjfffifiiiiii=U.ag)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B),kh=g.dynCall_vjjjjjjjjfffjifiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F)=>(kh=g.dynCall_vjjjjjjjjfffjifiiiiii=\nU.bg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F),lh=g.dynCall_vijiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(lh=g.dynCall_vijiiiiiiiiii=U.cg)(a,b,c,d,e,f,h,k,l,m,n,q,r),mh=g.dynCall_vijjfffiii=(a,b,c,d,e,f,h,k,l,m)=>(mh=g.dynCall_vijjfffiii=U.dg)(a,b,c,d,e,f,h,k,l,m),nh=g.dynCall_viiiiiiijiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(nh=g.dynCall_viiiiiiijiiii=U.eg)(a,b,c,d,e,f,h,k,l,m,n,q,r),oh=g.dynCall_vijjjjjjifiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>(oh=g.dynCall_vijjjjjjifiiiii=U.fg)(a,b,c,d,e,f,h,k,l,m,n,\nq,r,p,u),ph=g.dynCall_viifi=(a,b,c,d,e)=>(ph=g.dynCall_viifi=U.gg)(a,b,c,d,e),qh=g.dynCall_vjjjjjiiii=(a,b,c,d,e,f,h,k,l,m)=>(qh=g.dynCall_vjjjjjiiii=U.hg)(a,b,c,d,e,f,h,k,l,m),rh=g.dynCall_vjjjjfiii=(a,b,c,d,e,f,h,k,l)=>(rh=g.dynCall_vjjjjfiii=U.ig)(a,b,c,d,e,f,h,k,l),sh=g.dynCall_viiiiiijiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(sh=g.dynCall_viiiiiijiiiiii=U.jg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),th=g.dynCall_vijjii=(a,b,c,d,e,f)=>(th=g.dynCall_vijjii=U.kg)(a,b,c,d,e,f),uh=g.dynCall_viiiiijjiiiii=(a,b,c,\nd,e,f,h,k,l,m,n,q,r)=>(uh=g.dynCall_viiiiijjiiiii=U.lg)(a,b,c,d,e,f,h,k,l,m,n,q,r),vh=g.dynCall_iiiiiji=(a,b,c,d,e,f,h)=>(vh=g.dynCall_iiiiiji=U.mg)(a,b,c,d,e,f,h),wh=g.dynCall_iiiiji=(a,b,c,d,e,f)=>(wh=g.dynCall_iiiiji=U.ng)(a,b,c,d,e,f),xh=g.dynCall_viiiiijiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(xh=g.dynCall_viiiiijiiiiii=U.og)(a,b,c,d,e,f,h,k,l,m,n,q,r),yh=g.dynCall_viiijiiiiii=(a,b,c,d,e,f,h,k,l,m,n)=>(yh=g.dynCall_viiijiiiiii=U.pg)(a,b,c,d,e,f,h,k,l,m,n),zh=g.dynCall_viijj=(a,b,c,d,e)=>(zh=g.dynCall_viijj=\nU.qg)(a,b,c,d,e),Ah=g.dynCall_viiiijii=(a,b,c,d,e,f,h,k)=>(Ah=g.dynCall_viiiijii=U.rg)(a,b,c,d,e,f,h,k),Bh=g.dynCall_viijjiii=(a,b,c,d,e,f,h,k)=>(Bh=g.dynCall_viijjiii=U.sg)(a,b,c,d,e,f,h,k),Ch=g.dynCall_ijii=(a,b,c,d)=>(Ch=g.dynCall_ijii=U.tg)(a,b,c,d),Dh=g.dynCall_viiiiijjji=(a,b,c,d,e,f,h,k,l,m)=>(Dh=g.dynCall_viiiiijjji=U.ug)(a,b,c,d,e,f,h,k,l,m),Eh=g.dynCall_vijjjjiij=(a,b,c,d,e,f,h,k,l)=>(Eh=g.dynCall_vijjjjiij=U.vg)(a,b,c,d,e,f,h,k,l),Fh=g.dynCall_viiiiijij=(a,b,c,d,e,f,h,k,l)=>(Fh=g.dynCall_viiiiijij=\nU.wg)(a,b,c,d,e,f,h,k,l),Gh=g.dynCall_viiiiiijij=(a,b,c,d,e,f,h,k,l,m)=>(Gh=g.dynCall_viiiiiijij=U.xg)(a,b,c,d,e,f,h,k,l,m),Hh=g.dynCall_vijiii=(a,b,c,d,e,f)=>(Hh=g.dynCall_vijiii=U.yg)(a,b,c,d,e,f),Ih=g.dynCall_viiiiiiiiifi=(a,b,c,d,e,f,h,k,l,m,n,q)=>(Ih=g.dynCall_viiiiiiiiifi=U.zg)(a,b,c,d,e,f,h,k,l,m,n,q),Jh=g.dynCall_iiijiiii=(a,b,c,d,e,f,h,k)=>(Jh=g.dynCall_iiijiiii=U.Ag)(a,b,c,d,e,f,h,k),Kh=g.dynCall_viiiiiijjiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(Kh=g.dynCall_viiiiiijjiiiii=U.Bg)(a,b,c,d,e,\nf,h,k,l,m,n,q,r,p),Lh=g.dynCall_viiiiiiijiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>(Lh=g.dynCall_viiiiiiijiiiiii=U.Cg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u),Mh=g.dynCall_vif=(a,b,c)=>(Mh=g.dynCall_vif=U.Dg)(a,b,c),Nh=g.dynCall_viif=(a,b,c,d)=>(Nh=g.dynCall_viif=U.Eg)(a,b,c,d),Oh=g.dynCall_fiii=(a,b,c,d)=>(Oh=g.dynCall_fiii=U.Fg)(a,b,c,d),Ph=g.dynCall_diii=(a,b,c,d)=>(Ph=g.dynCall_diii=U.Gg)(a,b,c,d),Qh=g.dynCall_viiiiiifii=(a,b,c,d,e,f,h,k,l,m)=>(Qh=g.dynCall_viiiiiifii=U.Hg)(a,b,c,d,e,f,h,k,l,m),Rh=g.dynCall_viiiiijiiiiiiiiiiiiiiiiiii=\n(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F,H,K,Va,Wa,Xa)=>(Rh=g.dynCall_viiiiijiiiiiiiiiiiiiiiiiii=U.Ig)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F,H,K,Va,Wa,Xa),Sh=g.dynCall_viijji=(a,b,c,d,e,f)=>(Sh=g.dynCall_viijji=U.Jg)(a,b,c,d,e,f),Th=g.dynCall_iiiiiiiiiiiji=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Th=g.dynCall_iiiiiiiiiiiji=U.Kg)(a,b,c,d,e,f,h,k,l,m,n,q,r),Uh=g.dynCall_viifiifijjjii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Uh=g.dynCall_viifiifijjjii=U.Lg)(a,b,c,d,e,f,h,k,l,m,n,q,r),Vh=g.dynCall_viiiiiiiiiiiiiiiiiiii=\n(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F)=>(Vh=g.dynCall_viiiiiiiiiiiiiiiiiiii=U.Mg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F),Wh=g.dynCall_viiiiifiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Wh=g.dynCall_viiiiifiiiiii=U.Ng)(a,b,c,d,e,f,h,k,l,m,n,q,r),Xh=g.dynCall_vijiiiiiiijjii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(Xh=g.dynCall_vijiiiiiiijjii=U.Og)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),Yh=g.dynCall_viiiiiiiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C)=>(Yh=g.dynCall_viiiiiiiiiiiiiiiiii=U.Pg)(a,b,c,d,e,f,h,k,l,\nm,n,q,r,p,u,y,A,B,C),Zh=g.dynCall_viiiiiiiiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)=>(Zh=g.dynCall_viiiiiiiiiiiiiiiiiii=U.Qg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D),$h=g.dynCall_viiiiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>($h=g.dynCall_viiiiiiiiiiiiiii=U.Rg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y),ai=g.dynCall_viiiiiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)=>(ai=g.dynCall_viiiiiiiiiiiiiiii=U.Sg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A),bi=g.dynCall_viiiijjj=(a,b,c,d,e,f,h,k)=>(bi=\ng.dynCall_viiiijjj=U.Tg)(a,b,c,d,e,f,h,k),ci=g.dynCall_iiiiid=(a,b,c,d,e,f)=>(ci=g.dynCall_iiiiid=U.Ug)(a,b,c,d,e,f),di=g.dynCall_viiiiiiijjj=(a,b,c,d,e,f,h,k,l,m,n)=>(di=g.dynCall_viiiiiiijjj=U.Vg)(a,b,c,d,e,f,h,k,l,m,n),ei=g.dynCall_iiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n)=>(ei=g.dynCall_iiiiiiiiiii=U.Wg)(a,b,c,d,e,f,h,k,l,m,n),fi=g.dynCall_iiiiiiiiiiiiiiiiiifi=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)=>(fi=g.dynCall_iiiiiiiiiiiiiiiiiifi=U.Xg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D),gi=g.dynCall_viiif=\n(a,b,c,d,e)=>(gi=g.dynCall_viiif=U.Yg)(a,b,c,d,e),hi=g.dynCall_viiijiiiii=(a,b,c,d,e,f,h,k,l,m)=>(hi=g.dynCall_viiijiiiii=U.Zg)(a,b,c,d,e,f,h,k,l,m),ii=g.dynCall_viiij=(a,b,c,d,e)=>(ii=g.dynCall_viiij=U._g)(a,b,c,d,e),ji=g.dynCall_iijjj=(a,b,c,d,e)=>(ji=g.dynCall_iijjj=U.$g)(a,b,c,d,e),ki=g.dynCall_viiiiji=(a,b,c,d,e,f,h)=>(ki=g.dynCall_viiiiji=U.ah)(a,b,c,d,e,f,h),li=g.dynCall_iijjji=(a,b,c,d,e,f)=>(li=g.dynCall_iijjji=U.bh)(a,b,c,d,e,f),mi=g.dynCall_ijijji=(a,b,c,d,e,f)=>(mi=g.dynCall_ijijji=U.ch)(a,\nb,c,d,e,f),ni=g.dynCall_viiijjiii=(a,b,c,d,e,f,h,k,l)=>(ni=g.dynCall_viiijjiii=U.dh)(a,b,c,d,e,f,h,k,l),oi=g.dynCall_iiiiijji=(a,b,c,d,e,f,h,k)=>(oi=g.dynCall_iiiiijji=U.eh)(a,b,c,d,e,f,h,k),pi=g.dynCall_iiiifi=(a,b,c,d,e,f)=>(pi=g.dynCall_iiiifi=U.fh)(a,b,c,d,e,f),qi=g.dynCall_iiijii=(a,b,c,d,e,f)=>(qi=g.dynCall_iiijii=U.gh)(a,b,c,d,e,f),ri=g.dynCall_iiiiiiiiijii=(a,b,c,d,e,f,h,k,l,m,n,q)=>(ri=g.dynCall_iiiiiiiiijii=U.hh)(a,b,c,d,e,f,h,k,l,m,n,q),si=g.dynCall_iiiijjii=(a,b,c,d,e,f,h,k)=>(si=g.dynCall_iiiijjii=\nU.ih)(a,b,c,d,e,f,h,k),ti=g.dynCall_iiiiiijjjii=(a,b,c,d,e,f,h,k,l,m,n)=>(ti=g.dynCall_iiiiiijjjii=U.jh)(a,b,c,d,e,f,h,k,l,m,n),ui=g.dynCall_iiijiii=(a,b,c,d,e,f,h)=>(ui=g.dynCall_iiijiii=U.kh)(a,b,c,d,e,f,h),vi=g.dynCall_iiiiiiiijjjfi=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(vi=g.dynCall_iiiiiiiijjjfi=U.lh)(a,b,c,d,e,f,h,k,l,m,n,q,r),wi=g.dynCall_iijiiii=(a,b,c,d,e,f,h)=>(wi=g.dynCall_iijiiii=U.mh)(a,b,c,d,e,f,h),xi=g.dynCall_iijjjii=(a,b,c,d,e,f,h)=>(xi=g.dynCall_iijjjii=U.nh)(a,b,c,d,e,f,h),yi=g.dynCall_jij=\n(a,b,c)=>(yi=g.dynCall_jij=U.oh)(a,b,c),zi=g.dynCall_iiji=(a,b,c,d)=>(zi=g.dynCall_iiji=U.ph)(a,b,c,d),Ai=g.dynCall_iiif=(a,b,c,d)=>(Ai=g.dynCall_iiif=U.qh)(a,b,c,d),Bi=g.dynCall_vidi=(a,b,c,d)=>(Bi=g.dynCall_vidi=U.rh)(a,b,c,d),Ci=g.dynCall_vjiii=(a,b,c,d,e)=>(Ci=g.dynCall_vjiii=U.sh)(a,b,c,d,e),Di=g.dynCall_diiii=(a,b,c,d,e)=>(Di=g.dynCall_diiii=U.th)(a,b,c,d,e),Ei=g.dynCall_diiiii=(a,b,c,d,e,f)=>(Ei=g.dynCall_diiiii=U.uh)(a,b,c,d,e,f),Fi=g.dynCall_viiijjiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q)=>(Fi=g.dynCall_viiijjiiiiii=\nU.vh)(a,b,c,d,e,f,h,k,l,m,n,q),Gi=g.dynCall_viijjijjjjiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Gi=g.dynCall_viijjijjjjiii=U.wh)(a,b,c,d,e,f,h,k,l,m,n,q,r),Hi=g.dynCall_iiiij=(a,b,c,d,e)=>(Hi=g.dynCall_iiiij=U.xh)(a,b,c,d,e),Ii=g.dynCall_viiijii=(a,b,c,d,e,f,h)=>(Ii=g.dynCall_viiijii=U.yh)(a,b,c,d,e,f,h),Ji=g.dynCall_viijiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Ji=g.dynCall_viijiiiiiiiii=U.zh)(a,b,c,d,e,f,h,k,l,m,n,q,r),Ki=g.dynCall_fiiii=(a,b,c,d,e)=>(Ki=g.dynCall_fiiii=U.Ah)(a,b,c,d,e),Li=g.dynCall_jfi=\n(a,b,c)=>(Li=g.dynCall_jfi=U.Bh)(a,b,c),Mi=g.dynCall_viiiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>(Mi=g.dynCall_viiiiiiiiiiiiii=U.Ch)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u),Ni=g.dynCall_jiij=(a,b,c,d)=>(Ni=g.dynCall_jiij=U.Dh)(a,b,c,d),Mb=a=>(Mb=U.Eh)(a),Bb=()=>(Bb=U.Fh)(),Lb=a=>(Lb=U.Gh)(a),Nb=()=>(Nb=U.Hh)();g.___start_em_js=1275044;g.___stop_em_js=1275205;function Dc(a,b,c,d){var e=Z();try{return Ff(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}\nfunction Bc(a,b,c){var d=Z();try{return dynCall_iii(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function Jd(a,b,c){var d=Z();try{dynCall_vii(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function yc(a,b){var c=Z();try{return Gf(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}function Fd(a,b){var c=Z();try{dynCall_vi(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}function dd(a,b,c,d){var e=Z();try{return Jf(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}\nfunction Dd(a){var b=Z();try{dynCall_v(a)}catch(c){Y(b);if(c!==c+0)throw c;X(1,0)}}function Ic(a,b,c,d,e,f,h){var k=Z();try{return Hf(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Hc(a,b,c,d,e,f){var h=Z();try{return If(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Fc(a,b,c,d,e){var f=Z();try{return Kf(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Qd(a,b,c,d){var e=Z();try{Lf(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}\nfunction Td(a,b,c,d,e){var f=Z();try{Nf(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Vd(a,b,c,d,e,f){var h=Z();try{Mf(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Zd(a,b,c,d,e,f,h){var k=Z();try{Of(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function ke(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{Qf(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function zc(a,b,c){var d=Z();try{return Sf(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}\nfunction Ac(a,b,c){var d=Z();try{return Tf(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function md(a,b,c){var d=Z();try{return Uf(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function yd(a,b,c){var d=Z();try{return Vf(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0);return 0n}}function ee(a,b,c,d,e,f,h,k,l){var m=Z();try{Xf(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}function xc(a){var b=Z();try{return Wf(a)}catch(c){Y(b);if(c!==c+0)throw c;X(1,0)}}\nfunction df(a,b,c){var d=Z();try{fg(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function We(a,b,c,d,e){var f=Z();try{Pf(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Ce(a,b,c,d,e,f,h){var k=Z();try{Yf(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function cf(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{gg(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}\nfunction Re(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{hg(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function Jc(a,b,c,d,e,f,h,k){var l=Z();try{return ig(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function de(a,b,c,d,e,f,h,k){var l=Z();try{jg(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function Nc(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{return ag(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}\nfunction fe(a,b,c,d,e,f,h,k,l,m){var n=Z();try{bg(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function me(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{lg(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}function Yc(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{return ng(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}function Kc(a,b,c,d,e,f,h,k,l){var m=Z();try{return mg(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}\nfunction nf(a,b,c,d,e,f,h,k,l){var m=Z();try{og(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}function Ve(a,b,c,d){var e=Z();try{$f(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function tc(a,b){var c=Z();try{return pg(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}function xd(a,b){var c=Z();try{return Zf(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0);return 0n}}function nc(a,b){var c=Z();try{return rg(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}\nfunction jf(a,b,c,d){var e=Z();try{tg(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function Oe(a,b,c,d,e,f,h){var k=Z();try{Ii(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Ze(a,b,c,d,e){var f=Z();try{zh(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Lc(a,b,c,d,e,f,h,k,l,m){var n=Z();try{return ug(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function Xe(a,b,c,d,e,f,h){var k=Z();try{vg(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}\nfunction Kd(a,b,c,d){var e=Z();try{wg(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function Tc(a,b,c,d,e,f,h,k,l){var m=Z();try{return kg(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}function Id(a,b,c,d,e,f,h){var k=Z();try{xg(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Ue(a,b,c,d,e,f,h,k,l){var m=Z();try{Rf(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}\nfunction Pd(a,b,c,d,e,f,h){var k=Z();try{yg(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Wd(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{zg(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}function zd(a,b,c,d){var e=Z();try{return Bg(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0);return 0n}}function uf(a,b,c,d,e,f,h,k){var l=Z();try{Cg(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}\nfunction Rd(a,b,c,d,e){var f=Z();try{Dg(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function ef(a,b,c,d){var e=Z();try{Fg(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function rf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y){var A=Z();try{Gg(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)}catch(B){Y(A);if(B!==B+0)throw B;X(1,0)}}function Ne(a,b,c,d,e,f){var h=Z();try{Hg(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}\nfunction of(a,b,c,d,e,f,h,k,l){var m=Z();try{Ig(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}function ed(a,b,c,d,e){var f=Z();try{return Jg(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function kd(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{return Kg(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}function sf(a,b){var c=Z();try{Lg(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}\nfunction Cd(a,b,c){var d=Z();try{return Mg(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0);return 0n}}function jd(a,b,c,d,e,f,h,k,l,m){var n=Z();try{return Ng(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function ie(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{Sg(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}function Ed(a,b,c,d,e){var f=Z();try{Og(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}\nfunction Ud(a,b,c,d,e,f,h){var k=Z();try{Pg(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Md(a,b,c,d,e){var f=Z();try{Rg(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Xd(a,b,c,d,e,f,h,k){var l=Z();try{Qg(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function ue(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{Tg(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}\nfunction Oc(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A){var B=Z();try{return Ug(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)}catch(C){Y(B);if(C!==C+0)throw C;X(1,0)}}function le(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{Vg(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function sd(a,b){var c=Z();try{return cg(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}function wc(a,b,c,d,e){var f=Z();try{return Ki(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}\nfunction Pc(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D){var F=Z();try{return Wg(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)}catch(H){Y(F);if(H!==H+0)throw H;X(1,0)}}function mf(a,b,c,d,e,f,h,k,l,m){var n=Z();try{Xg(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function cd(a,b,c,d,e,f,h){var k=Z();try{return Yg(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function je(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{Zg(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}\nfunction ld(a,b,c,d,e,f){var h=Z();try{return $g(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Ie(a,b,c,d,e,f){var h=Z();try{bh(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function ye(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{ch(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}function zf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B){var C=Z();try{dh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B)}catch(D){Y(C);if(D!==D+0)throw D;X(1,0)}}\nfunction ae(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A){var B=Z();try{eh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)}catch(C){Y(B);if(C!==C+0)throw C;X(1,0)}}function $d(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y){var A=Z();try{fh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)}catch(B){Y(A);if(B!==B+0)throw B;X(1,0)}}function be(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u){var y=Z();try{gh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)}catch(A){Y(y);if(A!==A+0)throw A;X(1,0)}}\nfunction Af(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F){var H=Z();try{hh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F)}catch(K){Y(H);if(K!==K+0)throw K;X(1,0)}}function yf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C){var D=Z();try{ih(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C)}catch(F){Y(D);if(F!==F+0)throw F;X(1,0)}}function xf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B){var C=Z();try{jh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B)}catch(D){Y(C);if(D!==D+0)throw D;X(1,0)}}\nfunction Bf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F){var H=Z();try{kh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F)}catch(K){Y(H);if(K!==K+0)throw K;X(1,0)}}function gf(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{lh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function kf(a,b,c,d,e,f,h,k,l,m){var n=Z();try{mh(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}\nfunction ve(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{nh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function qf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u){var y=Z();try{oh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)}catch(A){Y(y);if(A!==A+0)throw A;X(1,0)}}function wf(a,b,c,d,e,f,h,k,l,m){var n=Z();try{qh(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function vf(a,b,c,d,e,f,h,k,l){var m=Z();try{rh(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}\nfunction sc(a,b,c,d,e,f,h){var k=Z();try{return ah(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Nd(a,b,c,d,e){var f=Z();try{ph(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function wd(a,b,c){var d=Z();try{return Li(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0);return 0n}}function ze(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{sh(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}\nfunction Ge(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{uh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function Xc(a,b,c,d,e,f,h){var k=Z();try{return vh(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function ad(a,b,c,d,e,f){var h=Z();try{return wh(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function De(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{xh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}\nfunction lf(a,b,c,d,e,f){var h=Z();try{th(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Qe(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{yh(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}function Ke(a,b,c,d,e,f,h,k){var l=Z();try{Ah(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function af(a,b,c,d,e,f,h,k){var l=Z();try{Bh(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}\nfunction td(a,b,c,d){var e=Z();try{return Ch(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function He(a,b,c,d,e,f,h,k,l,m){var n=Z();try{Dh(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function pf(a,b,c,d,e,f,h,k,l){var m=Z();try{Eh(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}function Fe(a,b,c,d,e,f,h,k,l){var m=Z();try{Fh(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}\nfunction Ae(a,b,c,d,e,f,h,k,l,m){var n=Z();try{Gh(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function ff(a,b,c,d,e,f){var h=Z();try{Hh(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function he(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{Ih(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function hd(a,b,c,d,e,f,h,k){var l=Z();try{return Jh(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}\nfunction ne(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u){var y=Z();try{Mi(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)}catch(A){Y(y);if(A!==A+0)throw A;X(1,0)}}function Be(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{Kh(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}function we(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u){var y=Z();try{Lh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)}catch(A){Y(y);if(A!==A+0)throw A;X(1,0)}}function Hd(a,b,c){var d=Z();try{Mh(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}\nfunction vc(a,b,c,d){var e=Z();try{return Oh(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function pc(a,b,c,d){var e=Z();try{return Ph(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function ce(a,b,c,d,e,f,h,k,l,m){var n=Z();try{Qh(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function Ee(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F,H,K,Va,Wa,Xa){var Qi=Z();try{Rh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F,H,K,Va,Wa,Xa)}catch(Ya){Y(Qi);if(Ya!==Ya+0)throw Ya;X(1,0)}}\nfunction $e(a,b,c,d,e,f){var h=Z();try{Sh(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Rc(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{return Th(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function Od(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{Uh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}\nfunction se(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F){var H=Z();try{Vh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F)}catch(K){Y(H);if(K!==K+0)throw K;X(1,0)}}function Yd(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{Wh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function hf(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{Xh(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}\nfunction re(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D){var F=Z();try{Zh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)}catch(H){Y(F);if(H!==H+0)throw H;X(1,0)}}function pe(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A){var B=Z();try{ai(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)}catch(C){Y(B);if(C!==C+0)throw C;X(1,0)}}function qe(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C){var D=Z();try{Yh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C)}catch(F){Y(D);if(F!==F+0)throw F;X(1,0)}}\nfunction Le(a,b,c,d,e,f,h,k){var l=Z();try{bi(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function xe(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{di(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}function Mc(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{return ei(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}\nfunction Qc(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D){var F=Z();try{return fi(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)}catch(H){Y(F);if(H!==H+0)throw H;X(1,0)}}function Sd(a,b,c,d,e){var f=Z();try{gi(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function ge(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{Ag(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function Pe(a,b,c,d,e,f,h,k,l,m){var n=Z();try{hi(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}\nfunction Me(a,b,c,d,e){var f=Z();try{ii(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Ye(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{Ji(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function pd(a,b,c,d,e){var f=Z();try{return ji(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Ad(a,b,c,d){var e=Z();try{return Ni(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0);return 0n}}\nfunction Je(a,b,c,d,e,f,h){var k=Z();try{ki(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function qd(a,b,c,d,e,f){var h=Z();try{return li(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function ud(a,b,c,d,e,f){var h=Z();try{return mi(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Se(a,b,c,d,e,f,h,k,l){var m=Z();try{ni(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}\nfunction Ld(a,b,c,d){var e=Z();try{Nh(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function Zc(a,b,c,d,e,f,h,k){var l=Z();try{return oi(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function Ec(a,b,c,d,e,f){var h=Z();try{return pi(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function fd(a,b,c,d,e,f){var h=Z();try{return qi(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}\nfunction Sc(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{return ri(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function bd(a,b,c,d,e,f,h,k){var l=Z();try{return si(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function Vc(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{return ti(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}function gd(a,b,c,d,e,f,h){var k=Z();try{return ui(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}\nfunction Uc(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{return vi(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function od(a,b,c,d,e,f,h){var k=Z();try{return wi(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function rd(a,b,c,d,e,f,h){var k=Z();try{return xi(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Bd(a,b,c){var d=Z();try{return yi(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0);return 0n}}\nfunction nd(a,b,c,d){var e=Z();try{return zi(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function Gd(a,b,c,d){var e=Z();try{Bi(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function Cc(a,b,c,d){var e=Z();try{return Ai(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function tf(a,b,c,d,e){var f=Z();try{Ci(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function qc(a,b,c,d,e){var f=Z();try{return Di(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}\nfunction rc(a,b,c,d,e,f){var h=Z();try{return Ei(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Te(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{Fi(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function bf(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{Gi(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function te(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{Eg(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}\nfunction $c(a,b,c,d,e){var f=Z();try{return Hi(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function vd(a){var b=Z();try{return eg(a)}catch(c){Y(b);if(c!==c+0)throw c;X(1,0);return 0n}}function Wc(a,b,c,d,e,f){var h=Z();try{return dg(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Gc(a,b,c,d,e,f){var h=Z();try{return ci(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}\nfunction oe(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y){var A=Z();try{$h(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)}catch(B){Y(A);if(B!==B+0)throw B;X(1,0)}}function uc(a,b,c){var d=Z();try{return qg(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function oc(a,b,c){var d=Z();try{return sg(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function Df(){var a=U;a=Object.assign({},a);var b=c=>d=>c(d)>>>0;a.Fd=b(a.Fd);a.he=b(a.he);a.ne=b(a.ne);a.oe=(c=>()=>c()>>>0)(a.oe);return a}g.stackSave=()=>Z();g.stackRestore=a=>Y(a);\ng.stackAlloc=a=>Ef(a);g.UTF8ToString=J;g.stringToUTF8=(a,b,c)=>M(a,E,b,c);g.lengthBytesUTF8=bb;var Oi;Fa=function Pi(){Oi||Ri();Oi||(Fa=Pi)};function Ri(){if(!(0<Da)){if(g.preRun)for(\"function\"==typeof g.preRun&&(g.preRun=[g.preRun]);g.preRun.length;){var a=g.preRun.shift();Aa.unshift(a)}for(;0<Aa.length;)Aa.shift()(g);if(!(0<Da||Oi||(Oi=!0,g.calledRun=!0,x))){for(;0<Ba.length;)Ba.shift()(g);for(aa(g);0<Ca.length;)Ca.shift()(g)}}}Ri();\n\n\n  return readyPromise\n}\n);\n})();\nif (typeof exports === 'object' && typeof module === 'object')\n  module.exports = ortWasm;\nelse if (typeof define === 'function' && define['amd'])\n  define([], () => ortWasm);\n", "", "", "export const cpus = undefined;", "\nvar ortWasmThreaded = (() => {\n  var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;\n  if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename;\n  return (\nfunction(moduleArg = {}) {\n\nfunction d(){l.buffer!=p.buffer&&t();return p}function v(){l.buffer!=p.buffer&&t();return aa}function z(){l.buffer!=p.buffer&&t();return ba}function A(){l.buffer!=p.buffer&&t();return ca}function da(){l.buffer!=p.buffer&&t();return ea}var B=moduleArg,fa,C;B.ready=new Promise((a,b)=>{fa=a;C=b});\"use strict\";\nB.jsepInit=(a,b,c,e,f,h,k,q)=>{B.Qb=a;B.wb=b;B.yb=c;B.jb=e;B.xb=f;B.Ea=h;B.zb=k;B.Ab=q;b=(n,m,r)=>(...w)=>{const x=D,g=m?.();w=n(...w);const u=m?.();g!==u&&(n=u,r(g),m=r=null);return D!=x?ha():w};c=n=>async(...m)=>{try{if(B.bb)throw Error(\"Session already started\");const r=B.bb={Fb:m[0],errors:[]},w=await n(...m);if(B.bb!==r)throw Error(\"Session mismatch\");a.flush();const x=r.errors;if(0<x.length){let g=await Promise.all(x);g=g.filter(u=>u);if(0<g.length)throw Error(g.join(\"\\n\"));}return w}finally{B.bb=\nnull}};B._OrtRun=c(b(B._OrtRun,()=>B._OrtRun,n=>B._OrtRun=n));B._OrtRunWithBinding=c(b(B._OrtRunWithBinding,()=>B._OrtRunWithBinding,n=>B._OrtRunWithBinding=n));B._OrtBindInput=b(B._OrtBindInput,()=>B._OrtBindInput,n=>B._OrtBindInput=n);B.jsepRegisterBuffer=(n,m,r,w)=>a.registerBuffer(n,m,r,w);B.jsepUnregisterBuffers=n=>{a.unregisterBuffers(n)};B.jsepGetBuffer=n=>a.getBuffer(n);B.jsepCreateDownloader=(n,m,r)=>a.createDownloader(n,m,r)};\nvar ia=Object.assign({},B),ja=\"./this.program\",E=(a,b)=>{throw b;},ka=\"object\"==typeof window,F=\"function\"==typeof importScripts,G=\"object\"==typeof process&&\"object\"==typeof process.versions&&\"string\"==typeof process.versions.node,H=B.ENVIRONMENT_IS_PTHREAD||!1,I=\"\";function la(a){return B.locateFile?B.locateFile(a,I):I+a}var ma,J,na;\nif(G){var fs=require(\"fs\"),oa=require(\"path\");I=F?oa.dirname(I)+\"/\":__dirname+\"/\";ma=(b,c)=>{b=b.startsWith(\"file://\")?new URL(b):oa.normalize(b);return fs.readFileSync(b,c?void 0:\"utf8\")};na=b=>{b=ma(b,!0);b.buffer||(b=new Uint8Array(b));return b};J=(b,c,e,f=!0)=>{b=b.startsWith(\"file://\")?new URL(b):oa.normalize(b);fs.readFile(b,f?void 0:\"utf8\",(h,k)=>{h?e(h):c(f?k.buffer:k)})};!B.thisProgram&&1<process.argv.length&&(ja=process.argv[1].replace(/\\\\/g,\"/\"));process.argv.slice(2);E=(b,c)=>{process.exitCode=\nb;throw c;};B.inspect=()=>\"[Emscripten Module object]\";let a;try{a=require(\"worker_threads\")}catch(b){throw console.error('The \"worker_threads\" module is not supported in this node.js build - perhaps a newer version is needed?'),b;}global.Worker=a.Worker}else if(ka||F)F?I=self.location.href:\"undefined\"!=typeof document&&document.currentScript&&(I=document.currentScript.src),(typeof _scriptDir !== \"undefined\" && _scriptDir)&&(I=_scriptDir),0!==I.indexOf(\"blob:\")?I=I.substr(0,I.replace(/[?#].*/,\"\").lastIndexOf(\"/\")+1):I=\"\",G||(ma=a=>{var b=\nnew XMLHttpRequest;b.open(\"GET\",a,!1);b.send(null);return b.responseText},F&&(na=a=>{var b=new XMLHttpRequest;b.open(\"GET\",a,!1);b.responseType=\"arraybuffer\";b.send(null);return new Uint8Array(b.response)}),J=(a,b,c)=>{var e=new XMLHttpRequest;e.open(\"GET\",a,!0);e.responseType=\"arraybuffer\";e.onload=()=>{200==e.status||0==e.status&&e.response?b(e.response):c()};e.onerror=c;e.send(null)});G&&\"undefined\"==typeof performance&&(global.performance=require(\"perf_hooks\").performance);\nvar pa=console.log.bind(console),qa=console.error.bind(console);G&&(pa=(...a)=>fs.writeSync(1,a.join(\" \")+\"\\n\"),qa=(...a)=>fs.writeSync(2,a.join(\" \")+\"\\n\"));var ra=B.print||pa,K=B.printErr||qa;Object.assign(B,ia);ia=null;B.thisProgram&&(ja=B.thisProgram);B.quit&&(E=B.quit);var L;B.wasmBinary&&(L=B.wasmBinary);var noExitRuntime=B.noExitRuntime||!0;\"object\"!=typeof WebAssembly&&M(\"no native wasm support detected\");var l,N,sa,P=!1,Q,p,aa,ba,ca,ea;\nfunction t(){var a=l.buffer;B.HEAP8=p=new Int8Array(a);B.HEAP16=new Int16Array(a);B.HEAP32=ba=new Int32Array(a);B.HEAPU8=aa=new Uint8Array(a);B.HEAPU16=new Uint16Array(a);B.HEAPU32=ca=new Uint32Array(a);B.HEAPF32=new Float32Array(a);B.HEAPF64=ea=new Float64Array(a)}var ta=B.INITIAL_MEMORY||16777216;5242880<=ta||M(\"INITIAL_MEMORY should be larger than STACK_SIZE, was \"+ta+\"! (STACK_SIZE=5242880)\");\nif(H)l=B.wasmMemory;else if(B.wasmMemory)l=B.wasmMemory;else if(l=new WebAssembly.Memory({initial:ta/65536,maximum:65536,shared:!0}),!(l.buffer instanceof SharedArrayBuffer))throw K(\"requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag\"),G&&K(\"(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and/or recent version)\"),\nError(\"bad memory\");t();ta=l.buffer.byteLength;var ua=[],va=[],wa=[],xa=0;function ya(){return noExitRuntime||0<xa}var R=0,za=null,S=null;function Aa(){R++;B.monitorRunDependencies&&B.monitorRunDependencies(R)}function Ba(){R--;B.monitorRunDependencies&&B.monitorRunDependencies(R);if(0==R&&(null!==za&&(clearInterval(za),za=null),S)){var a=S;S=null;a()}}\nfunction M(a){if(B.onAbort)B.onAbort(a);a=\"Aborted(\"+a+\")\";K(a);P=!0;Q=1;a=new WebAssembly.RuntimeError(a+\". Build with -sASSERTIONS for more info.\");C(a);throw a;}function Ca(a){return a.startsWith(\"data:application/octet-stream;base64,\")}var T;T=\"ort-wasm-simd-threaded.wasm\";Ca(T)||(T=la(T));function Da(a){if(a==T&&L)return new Uint8Array(L);if(na)return na(a);throw\"both async and sync fetching of the wasm failed\";}\nfunction Ea(a){if(!L&&(ka||F)){if(\"function\"==typeof fetch&&!a.startsWith(\"file://\"))return fetch(a,{credentials:\"same-origin\"}).then(b=>{if(!b.ok)throw\"failed to load wasm binary file at '\"+a+\"'\";return b.arrayBuffer()}).catch(()=>Da(a));if(J)return new Promise((b,c)=>{J(a,e=>b(new Uint8Array(e)),c)})}return Promise.resolve().then(()=>Da(a))}function Fa(a,b,c){return Ea(a).then(e=>WebAssembly.instantiate(e,b)).then(e=>e).then(c,e=>{K(\"failed to asynchronously prepare wasm: \"+e);M(e)})}\nfunction Ga(a,b){var c=T;return L||\"function\"!=typeof WebAssembly.instantiateStreaming||Ca(c)||c.startsWith(\"file://\")||G||\"function\"!=typeof fetch?Fa(c,a,b):fetch(c,{credentials:\"same-origin\"}).then(e=>WebAssembly.instantiateStreaming(e,a).then(b,function(f){K(\"wasm streaming compile failed: \"+f);K(\"falling back to ArrayBuffer instantiation\");return Fa(c,a,b)}))}\nvar U,Ha={906828:a=>{B.Ea(\"Abs\",a,void 0)},906879:a=>{B.Ea(\"Neg\",a,void 0)},906930:a=>{B.Ea(\"Floor\",a,void 0)},906983:a=>{B.Ea(\"Ceil\",a,void 0)},907035:a=>{B.Ea(\"Reciprocal\",a,void 0)},907093:a=>{B.Ea(\"Sqrt\",a,void 0)},907145:a=>{B.Ea(\"Exp\",a,void 0)},907196:a=>{B.Ea(\"Erf\",a,void 0)},907247:a=>{B.Ea(\"Sigmoid\",a,void 0)},907302:a=>{B.Ea(\"Log\",a,void 0)},907353:a=>{B.Ea(\"Sin\",a,void 0)},907404:a=>{B.Ea(\"Cos\",a,void 0)},907455:a=>{B.Ea(\"Tan\",a,void 0)},907506:a=>{B.Ea(\"Asin\",a,void 0)},907558:a=>{B.Ea(\"Acos\",\na,void 0)},907610:a=>{B.Ea(\"Atan\",a,void 0)},907662:a=>{B.Ea(\"Sinh\",a,void 0)},907714:a=>{B.Ea(\"Cosh\",a,void 0)},907766:a=>{B.Ea(\"Asinh\",a,void 0)},907819:a=>{B.Ea(\"Acosh\",a,void 0)},907872:a=>{B.Ea(\"Atanh\",a,void 0)},907925:a=>{B.Ea(\"Tanh\",a,void 0)},907977:a=>{B.Ea(\"Not\",a,void 0)},908028:(a,b,c)=>{B.Ea(\"ClipV10\",a,{min:b,max:c})},908100:a=>{B.Ea(\"Clip\",a,void 0)},908152:(a,b)=>{B.Ea(\"Elu\",a,{alpha:b})},908210:a=>{B.Ea(\"Relu\",a,void 0)},908262:(a,b)=>{B.Ea(\"LeakyRelu\",a,{alpha:b})},908326:(a,b)=>\n{B.Ea(\"ThresholdedRelu\",a,{alpha:b})},908396:(a,b)=>{B.Ea(\"Cast\",a,{to:b})},908454:a=>{B.Ea(\"Add\",a,void 0)},908505:a=>{B.Ea(\"Sub\",a,void 0)},908556:a=>{B.Ea(\"Mul\",a,void 0)},908607:a=>{B.Ea(\"Div\",a,void 0)},908658:a=>{B.Ea(\"Pow\",a,void 0)},908709:a=>{B.Ea(\"Equal\",a,void 0)},908762:a=>{B.Ea(\"Greater\",a,void 0)},908817:a=>{B.Ea(\"GreaterOrEqual\",a,void 0)},908879:a=>{B.Ea(\"Less\",a,void 0)},908931:a=>{B.Ea(\"LessOrEqual\",a,void 0)},908990:(a,b,c,e,f)=>{B.Ea(\"ReduceMean\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,\naxes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909154:(a,b,c,e,f)=>{B.Ea(\"ReduceMax\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909317:(a,b,c,e,f)=>{B.Ea(\"ReduceMin\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909480:(a,b,c,e,f)=>{B.Ea(\"ReduceProd\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909644:(a,b,c,e,f)=>{B.Ea(\"ReduceSum\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,\naxes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909807:(a,b,c,e,f)=>{B.Ea(\"ReduceL1\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909969:(a,b,c,e,f)=>{B.Ea(\"ReduceL2\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},910131:(a,b,c,e,f)=>{B.Ea(\"ReduceLogSum\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},910297:(a,b,c,e,f)=>{B.Ea(\"ReduceSumSquare\",a,{keepDims:!!b,\nnoopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},910466:(a,b,c,e,f)=>{B.Ea(\"ReduceLogSumExp\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},910635:a=>{B.Ea(\"Where\",a,void 0)},910688:(a,b,c)=>{B.Ea(\"Transpose\",a,{perm:b?Array.from(z().subarray(c>>>0,c+b>>>0)):[]})},910801:(a,b,c,e,f,h,k,q,n,m)=>{B.Ea(\"Conv\",a,{format:n?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c],group:e,kernel_shape:[f],pads:[h,k],strides:[q],w_is_const:()=>!!d()[m>>>\n0]})},911029:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u)=>{B.Ea(\"Conv\",a,{format:g?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c,e],group:f,kernel_shape:[h,k],pads:[q,n,m,r],strides:[w,x],w_is_const:()=>!!d()[u>>>0]})},911288:(a,b,c,e,f,h,k,q,n,m)=>{B.Ea(\"Conv\",a,{format:n?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c],group:e,kernel_shape:[f],pads:[h,k],strides:[q],w_is_const:()=>!!d()[m>>>0]})},911516:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u)=>{B.Ea(\"Conv\",a,{format:g?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c,e],group:f,kernel_shape:[h,\nk],pads:[q,n,m,r],strides:[w,x],w_is_const:()=>!!d()[u>>>0]})},911775:(a,b,c,e,f,h,k,q,n,m,r,w,x,g)=>{B.Ea(\"ConvTranspose\",a,{format:n?\"NHWC\":\"NCHW\",autoPad:b,dilations:[c],group:e,kernel_shape:[f],pads:[h,k],strides:[q],wIsConst:()=>!!d()[m>>>0],outputPadding:r?Array.from(z().subarray(w>>>0,w+r>>>0)):[],outputShape:x?Array.from(z().subarray(g>>>0,g+x>>>0)):[]})},912155:(a,b,c,e,f,h,k,q,n,m,r,w,x)=>{B.Ea(\"ConvTranspose\",a,{format:q?\"NHWC\":\"NCHW\",autoPad:b,dilations:Array.from(z().subarray(c>>>0,c+\n2>>>0)),group:e,kernelShape:Array.from(z().subarray(f>>>0,f+2>>>0)),pads:Array.from(z().subarray(h>>>0,h+4>>>0)),strides:Array.from(z().subarray(k>>>0,k+2>>>0)),wIsConst:()=>!!d()[n>>>0],outputPadding:0<m?Array.from(z().subarray(r>>>0,r+m>>>0)):[],outputShape:0<w?Array.from(z().subarray(x>>>0,x+w>>>0)):[]})},912678:(a,b,c,e,f,h,k,q,n,m,r,w,x,g)=>{B.Ea(\"ConvTranspose\",a,{format:n?\"NHWC\":\"NCHW\",autoPad:b,dilations:[c],group:e,kernel_shape:[f],pads:[h,k],strides:[q],wIsConst:()=>!!d()[m>>>0],outputPadding:r?\nArray.from(z().subarray(w>>>0,w+r>>>0)):[],outputShape:x?Array.from(z().subarray(g>>>0,g+x>>>0)):[]})},913058:(a,b,c,e,f,h,k,q,n,m,r,w,x)=>{B.Ea(\"ConvTranspose\",a,{format:q?\"NHWC\":\"NCHW\",autoPad:b,dilations:Array.from(z().subarray(c>>>0,c+2>>>0)),group:e,kernelShape:Array.from(z().subarray(f>>>0,f+2>>>0)),pads:Array.from(z().subarray(h>>>0,h+4>>>0)),strides:Array.from(z().subarray(k>>>0,k+2>>>0)),wIsConst:()=>!!d()[n>>>0],outputPadding:0<m?Array.from(z().subarray(r>>>0,r+m>>>0)):[],outputShape:0<\nw?Array.from(z().subarray(x>>>0,x+w>>>0)):[]})},913581:(a,b)=>{B.Ea(\"GlobalAveragePool\",a,{format:b?\"NHWC\":\"NCHW\"})},913672:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u,y)=>{B.Ea(\"AveragePool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:e,storage_order:f,dilations:[h,k],kernel_shape:[q,n],pads:[m,r,w,x],strides:[g,u]})},913956:(a,b)=>{B.Ea(\"GlobalAveragePool\",a,{format:b?\"NHWC\":\"NCHW\"})},914047:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u,y)=>{B.Ea(\"AveragePool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,\ncount_include_pad:e,storage_order:f,dilations:[h,k],kernel_shape:[q,n],pads:[m,r,w,x],strides:[g,u]})},914331:(a,b)=>{B.Ea(\"GlobalMaxPool\",a,{format:b?\"NHWC\":\"NCHW\"})},914418:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u,y)=>{B.Ea(\"MaxPool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:e,storage_order:f,dilations:[h,k],kernel_shape:[q,n],pads:[m,r,w,x],strides:[g,u]})},914698:(a,b)=>{B.Ea(\"GlobalMaxPool\",a,{format:b?\"NHWC\":\"NCHW\"})},914785:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u,y)=>{B.Ea(\"MaxPool\",\na,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:e,storage_order:f,dilations:[h,k],kernel_shape:[q,n],pads:[m,r,w,x],strides:[g,u]})},915065:(a,b,c,e,f)=>{B.Ea(\"Gemm\",a,{alpha:b,beta:c,transA:e,transB:f})},915169:a=>{B.Ea(\"MatMul\",a,void 0)},915223:(a,b,c,e)=>{B.Ea(\"ArgMax\",a,{keepDims:!!b,selectLastIndex:!!c,axis:e})},915331:(a,b,c,e)=>{B.Ea(\"ArgMin\",a,{keepDims:!!b,selectLastIndex:!!c,axis:e})},915439:(a,b)=>{B.Ea(\"Softmax\",a,{axis:b})},915502:(a,b)=>{B.Ea(\"Concat\",a,{axis:b})},\n915562:(a,b,c,e,f)=>{B.Ea(\"Split\",a,{axis:b,numOutputs:c,splitSizes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},915707:a=>{B.Ea(\"Expand\",a,void 0)},915761:(a,b)=>{B.Ea(\"Gather\",a,{axis:Number(b)})},915832:(a,b)=>{B.Ea(\"GatherElements\",a,{axis:Number(b)})},915911:(a,b,c,e,f,h,k,q,n,m,r)=>{B.Ea(\"Resize\",a,{antialias:b,axes:c?Array.from(z().subarray(e>>>0,e+c>>>0)):[],coordinateTransformMode:V(f),cubicCoeffA:h,excludeOutside:k,extrapolationValue:q,keepAspectRatioPolicy:V(n),mode:V(m),nearestMode:V(r)})},\n916262:(a,b,c,e,f,h,k)=>{B.Ea(\"Slice\",a,{starts:b?Array.from(z().subarray(c>>>0,c+b>>>0)):[],ends:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[],axes:h?Array.from(z().subarray(k>>>0,k+h>>>0)):[]})},916493:a=>{B.Ea(\"Tile\",a,void 0)},916545:(a,b,c)=>{B.Ea(\"LayerNormalization\",a,{axis:Number(b),epsilon:Number(c)})},916652:(a,b,c)=>{B.Ea(\"InstanceNormalization\",a,{epsilon:b,format:c?\"NHWC\":\"NCHW\"})},916766:(a,b,c)=>{B.Ea(\"InstanceNormalization\",a,{epsilon:b,format:c?\"NHWC\":\"NCHW\"})},916880:a=>{B.Ea(\"Range\",\na,void 0)},916933:(a,b)=>{B.Ea(\"Einsum\",a,{equation:V(b)})},917014:(a,b,c,e,f)=>{B.Ea(\"Pad\",a,{mode:b,value:c,pads:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},917146:a=>{B.Ea(\"Gelu\",a,void 0)},917198:a=>{B.Ea(\"BiasAdd\",a,void 0)},917253:a=>{B.Ea(\"BiasSplitGelu\",a,void 0)},917314:(a,b)=>{B.Ea(\"SkipLayerNormalization\",a,{epsilon:b})},917395:a=>{B.zb(a)},917429:(a,b)=>B.Ab(a,b,B.bb.Fb,B.bb.errors),917541:a=>B.wb(a),917574:a=>B.yb(a),917606:(a,b,c)=>{B.jb(a,b,c,!0)},917645:(a,b,c)=>{B.jb(a,b,c)}};\nfunction Ia(a){this.name=\"ExitStatus\";this.message=`Program terminated with exit(${a})`;this.status=a}function Ja(a){a.terminate();a.onmessage=()=>{}}function Ka(a){(a=W.Qa[a])||M();W.Eb(a)}function La(a){var b=W.tb();if(!b)return 6;W.Ya.push(b);W.Qa[a.Xa]=b;b.Xa=a.Xa;var c={cmd:\"run\",start_routine:a.Gb,arg:a.rb,pthread_ptr:a.Xa};G&&b.unref();b.postMessage(c,a.Mb);return 0}\nvar Ma=\"undefined\"!=typeof TextDecoder?new TextDecoder(\"utf8\"):void 0,Na=(a,b,c)=>{b>>>=0;var e=b+c;for(c=b;a[c]&&!(c>=e);)++c;if(16<c-b&&a.buffer&&Ma)return Ma.decode(a.buffer instanceof SharedArrayBuffer?a.slice(b,c):a.subarray(b,c));for(e=\"\";b<c;){var f=a[b++];if(f&128){var h=a[b++]&63;if(192==(f&224))e+=String.fromCharCode((f&31)<<6|h);else{var k=a[b++]&63;f=224==(f&240)?(f&15)<<12|h<<6|k:(f&7)<<18|h<<12|k<<6|a[b++]&63;65536>f?e+=String.fromCharCode(f):(f-=65536,e+=String.fromCharCode(55296|f>>\n10,56320|f&1023))}}else e+=String.fromCharCode(f)}return e},V=(a,b)=>(a>>>=0)?Na(v(),a,b):\"\";function Oa(a){if(H)return X(1,1,a);Q=a;if(!ya()){W.Hb();if(B.onExit)B.onExit(a);P=!0}E(a,new Ia(a))}\nvar Qa=a=>{Q=a;if(H)throw Pa(a),\"unwind\";Oa(a)},W={ab:[],Ya:[],mb:[],Qa:{},gb:function(){H?W.vb():W.ub()},ub:function(){ua.unshift(()=>{Aa();W.Bb(()=>Ba())})},vb:function(){W.receiveObjectTransfer=W.Db;W.threadInitTLS=W.lb;W.setExitStatus=W.kb;noExitRuntime=!1},kb:function(a){Q=a},Sb:[\"$terminateWorker\"],Hb:function(){for(var a of W.Ya)Ja(a);for(a of W.ab)Ja(a);W.ab=[];W.Ya=[];W.Qa=[]},Eb:function(a){var b=a.Xa;delete W.Qa[b];W.ab.push(a);W.Ya.splice(W.Ya.indexOf(a),1);a.Xa=0;Ra(b)},Db:function(){},\nlb:function(){W.mb.forEach(a=>a())},Cb:a=>new Promise(b=>{a.onmessage=h=>{h=h.data;var k=h.cmd;if(h.targetThread&&h.targetThread!=Sa()){var q=W.Qa[h.Rb];q?q.postMessage(h,h.transferList):K('Internal error! Worker sent a message \"'+k+'\" to target pthread '+h.targetThread+\", but that thread no longer exists!\")}else if(\"checkMailbox\"===k)Ta();else if(\"spawnThread\"===k)La(h);else if(\"cleanupThread\"===k)Ka(h.thread);else if(\"killThread\"===k)h=h.thread,k=W.Qa[h],delete W.Qa[h],Ja(k),Ra(h),W.Ya.splice(W.Ya.indexOf(k),\n1),k.Xa=0;else if(\"cancelThread\"===k)W.Qa[h.thread].postMessage({cmd:\"cancel\"});else if(\"loaded\"===k)a.loaded=!0,b(a);else if(\"alert\"===k)alert(\"Thread \"+h.threadId+\": \"+h.text);else if(\"setimmediate\"===h.target)a.postMessage(h);else if(\"callHandler\"===k)B[h.handler](...h.args);else k&&K(\"worker sent an unknown command \"+k)};a.onerror=h=>{K(\"worker sent an error! \"+h.filename+\":\"+h.lineno+\": \"+h.message);throw h;};G&&(a.on(\"message\",function(h){a.onmessage({data:h})}),a.on(\"error\",function(h){a.onerror(h)}));\nvar c=[],e=[\"onExit\",\"onAbort\",\"print\",\"printErr\"],f;for(f of e)B.hasOwnProperty(f)&&c.push(f);a.postMessage({cmd:\"load\",handlers:c,urlOrBlob:B.mainScriptUrlOrBlob||_scriptDir,wasmMemory:l,wasmModule:sa})}),Bb:function(a){a()},qb:function(){var a=la(\"ort-wasm-simd-threaded.worker.js\");a=new Worker(a);W.ab.push(a)},tb:function(){0==W.ab.length&&(W.qb(),W.Cb(W.ab[0]));return W.ab.pop()}};B.PThread=W;var Ua=a=>{for(;0<a.length;)a.shift()(B)};\nB.establishStackSpace=function(){var a=Sa(),b=z()[a+52>>2>>>0];a=z()[a+56>>2>>>0];Va(b,b-a);Wa(b)};function Pa(a){if(H)return X(2,0,a);Qa(a)}B.invokeEntryPoint=function(a,b){a=Xa.apply(null,[a,b]);ya()?W.kb(a):Ya(a)};function Za(a){this.fb=a-24;this.pb=function(b){A()[this.fb+4>>2>>>0]=b};this.ob=function(b){A()[this.fb+8>>2>>>0]=b};this.gb=function(b,c){this.nb();this.pb(b);this.ob(c)};this.nb=function(){A()[this.fb+16>>2>>>0]=0}}var $a=0,ab=0;\nfunction bb(a,b,c,e){return H?X(3,1,a,b,c,e):cb(a,b,c,e)}function cb(a,b,c,e){a>>>=0;b>>>=0;c>>>=0;e>>>=0;if(\"undefined\"==typeof SharedArrayBuffer)return K(\"Current environment does not support SharedArrayBuffer, pthreads are not available!\"),6;var f=[];if(H&&0===f.length)return bb(a,b,c,e);a={Gb:c,Xa:a,rb:e,Mb:f};return H?(a.Ob=\"spawnThread\",postMessage(a,f),0):La(a)}function db(a,b,c){return H?X(4,1,a,b,c):0}function eb(a,b){if(H)return X(5,1,a,b)}\nvar fb=a=>{for(var b=0,c=0;c<a.length;++c){var e=a.charCodeAt(c);127>=e?b++:2047>=e?b+=2:55296<=e&&57343>=e?(b+=4,++c):b+=3}return b},gb=(a,b,c,e)=>{c>>>=0;if(!(0<e))return 0;var f=c;e=c+e-1;for(var h=0;h<a.length;++h){var k=a.charCodeAt(h);if(55296<=k&&57343>=k){var q=a.charCodeAt(++h);k=65536+((k&1023)<<10)|q&1023}if(127>=k){if(c>=e)break;b[c++>>>0]=k}else{if(2047>=k){if(c+1>=e)break;b[c++>>>0]=192|k>>6}else{if(65535>=k){if(c+2>=e)break;b[c++>>>0]=224|k>>12}else{if(c+3>=e)break;b[c++>>>0]=240|k>>\n18;b[c++>>>0]=128|k>>12&63}b[c++>>>0]=128|k>>6&63}b[c++>>>0]=128|k&63}}b[c>>>0]=0;return c-f},hb=(a,b,c)=>gb(a,v(),b,c);function ib(a,b){if(H)return X(6,1,a,b)}function jb(a,b,c){if(H)return X(7,1,a,b,c)}function kb(a,b,c){return H?X(8,1,a,b,c):0}function lb(a,b){if(H)return X(9,1,a,b)}function mb(a,b,c){if(H)return X(10,1,a,b,c)}function nb(a,b,c,e){if(H)return X(11,1,a,b,c,e)}function ob(a,b,c,e){if(H)return X(12,1,a,b,c,e)}function pb(a,b,c,e){if(H)return X(13,1,a,b,c,e)}\nfunction qb(a){if(H)return X(14,1,a)}function rb(a,b){if(H)return X(15,1,a,b)}function sb(a,b,c){if(H)return X(16,1,a,b,c)}var tb=a=>{if(!P)try{if(a(),!ya())try{H?Ya(Q):Qa(Q)}catch(b){b instanceof Ia||\"unwind\"==b||E(1,b)}}catch(b){b instanceof Ia||\"unwind\"==b||E(1,b)}};function ub(a){a>>>=0;\"function\"===typeof Atomics.Nb&&(Atomics.Nb(z(),a>>2,a).value.then(Ta),a+=128,Atomics.store(z(),a>>2,1))}B.__emscripten_thread_mailbox_await=ub;function Ta(){var a=Sa();a&&(ub(a),tb(()=>vb()))}B.checkMailbox=Ta;\nvar Y=a=>0===a%4&&(0!==a%100||0===a%400),wb=[0,31,60,91,121,152,182,213,244,274,305,335],xb=[0,31,59,90,120,151,181,212,243,273,304,334];function yb(a,b,c,e,f,h,k,q){return H?X(17,1,a,b,c,e,f,h,k,q):-52}function zb(a,b,c,e,f,h,k){if(H)return X(18,1,a,b,c,e,f,h,k)}var Bb=a=>{var b=fb(a)+1,c=Ab(b);c&&hb(a,c,b);return c},Cb=[],Db=(a,b)=>{Cb.length=0;var c;for(b>>=2;c=v()[a++>>>0];)b+=105!=c&b,Cb.push(105==c?z()[b>>>0]:da()[b++>>>1]),++b;return Cb},Fb=a=>{var b=Eb();a=a();Wa(b);return a};\nfunction X(a,b){var c=arguments.length-2,e=arguments;return Fb(()=>{for(var f=Gb(8*c),h=f>>3,k=0;k<c;k++){var q=e[2+k];da()[h+k>>>0]=q}return Hb(a,c,f,b)})}\nvar Ib=[],Jb={},Lb=()=>{if(!Kb){var a={USER:\"web_user\",LOGNAME:\"web_user\",PATH:\"/\",PWD:\"/\",HOME:\"/home/web_user\",LANG:(\"object\"==typeof navigator&&navigator.languages&&navigator.languages[0]||\"C\").replace(\"-\",\"_\")+\".UTF-8\",_:ja||\"./this.program\"},b;for(b in Jb)void 0===Jb[b]?delete a[b]:a[b]=Jb[b];var c=[];for(b in a)c.push(`${b}=${a[b]}`);Kb=c}return Kb},Kb;\nfunction Mb(a,b){if(H)return X(19,1,a,b);a>>>=0;b>>>=0;var c=0;Lb().forEach(function(e,f){var h=b+c;f=A()[a+4*f>>2>>>0]=h;for(h=0;h<e.length;++h)d()[f++>>0>>>0]=e.charCodeAt(h);d()[f>>0>>>0]=0;c+=e.length+1});return 0}function Nb(a,b){if(H)return X(20,1,a,b);a>>>=0;b>>>=0;var c=Lb();A()[a>>2>>>0]=c.length;var e=0;c.forEach(function(f){e+=f.length+1});A()[b>>2>>>0]=e;return 0}function Ob(a){return H?X(21,1,a):52}function Pb(a,b,c,e){return H?X(22,1,a,b,c,e):52}\nfunction Qb(a,b,c,e,f){return H?X(23,1,a,b,c,e,f):70}var Rb=[null,[],[]];function Tb(a,b,c,e){if(H)return X(24,1,a,b,c,e);b>>>=0;c>>>=0;e>>>=0;for(var f=0,h=0;h<c;h++){var k=A()[b>>2>>>0],q=A()[b+4>>2>>>0];b+=8;for(var n=0;n<q;n++){var m=v()[k+n>>>0],r=Rb[a];0===m||10===m?((1===a?ra:K)(Na(r,0)),r.length=0):r.push(m)}f+=q}A()[e>>2>>>0]=f;return 0}var Ub=[31,29,31,30,31,30,31,31,30,31,30,31],Vb=[31,28,31,30,31,30,31,31,30,31,30,31];function Wb(a){var b=Array(fb(a)+1);gb(a,b,0,b.length);return b}\nvar Xb=(a,b)=>{d().set(a,b>>>0)};\nfunction Yb(a,b,c,e){function f(g,u,y){for(g=\"number\"==typeof g?g.toString():g||\"\";g.length<u;)g=y[0]+g;return g}function h(g,u){return f(g,u,\"0\")}function k(g,u){function y(Sb){return 0>Sb?-1:0<Sb?1:0}var O;0===(O=y(g.getFullYear()-u.getFullYear()))&&0===(O=y(g.getMonth()-u.getMonth()))&&(O=y(g.getDate()-u.getDate()));return O}function q(g){switch(g.getDay()){case 0:return new Date(g.getFullYear()-1,11,29);case 1:return g;case 2:return new Date(g.getFullYear(),0,3);case 3:return new Date(g.getFullYear(),\n0,2);case 4:return new Date(g.getFullYear(),0,1);case 5:return new Date(g.getFullYear()-1,11,31);case 6:return new Date(g.getFullYear()-1,11,30)}}function n(g){var u=g.Za;for(g=new Date((new Date(g.$a+1900,0,1)).getTime());0<u;){var y=g.getMonth(),O=(Y(g.getFullYear())?Ub:Vb)[y];if(u>O-g.getDate())u-=O-g.getDate()+1,g.setDate(1),11>y?g.setMonth(y+1):(g.setMonth(0),g.setFullYear(g.getFullYear()+1));else{g.setDate(g.getDate()+u);break}}y=new Date(g.getFullYear()+1,0,4);u=q(new Date(g.getFullYear(),\n0,4));y=q(y);return 0>=k(u,g)?0>=k(y,g)?g.getFullYear()+1:g.getFullYear():g.getFullYear()-1}a>>>=0;b>>>=0;c>>>=0;e>>>=0;var m=z()[e+40>>2>>>0];e={Kb:z()[e>>2>>>0],Jb:z()[e+4>>2>>>0],cb:z()[e+8>>2>>>0],ib:z()[e+12>>2>>>0],eb:z()[e+16>>2>>>0],$a:z()[e+20>>2>>>0],Wa:z()[e+24>>2>>>0],Za:z()[e+28>>2>>>0],Tb:z()[e+32>>2>>>0],Ib:z()[e+36>>2>>>0],Lb:m?V(m):\"\"};c=V(c);m={\"%c\":\"%a %b %d %H:%M:%S %Y\",\"%D\":\"%m/%d/%y\",\"%F\":\"%Y-%m-%d\",\"%h\":\"%b\",\"%r\":\"%I:%M:%S %p\",\"%R\":\"%H:%M\",\"%T\":\"%H:%M:%S\",\"%x\":\"%m/%d/%y\",\"%X\":\"%H:%M:%S\",\n\"%Ec\":\"%c\",\"%EC\":\"%C\",\"%Ex\":\"%m/%d/%y\",\"%EX\":\"%H:%M:%S\",\"%Ey\":\"%y\",\"%EY\":\"%Y\",\"%Od\":\"%d\",\"%Oe\":\"%e\",\"%OH\":\"%H\",\"%OI\":\"%I\",\"%Om\":\"%m\",\"%OM\":\"%M\",\"%OS\":\"%S\",\"%Ou\":\"%u\",\"%OU\":\"%U\",\"%OV\":\"%V\",\"%Ow\":\"%w\",\"%OW\":\"%W\",\"%Oy\":\"%y\"};for(var r in m)c=c.replace(new RegExp(r,\"g\"),m[r]);var w=\"Sunday Monday Tuesday Wednesday Thursday Friday Saturday\".split(\" \"),x=\"January February March April May June July August September October November December\".split(\" \");m={\"%a\":g=>w[g.Wa].substring(0,3),\"%A\":g=>w[g.Wa],\"%b\":g=>\nx[g.eb].substring(0,3),\"%B\":g=>x[g.eb],\"%C\":g=>h((g.$a+1900)/100|0,2),\"%d\":g=>h(g.ib,2),\"%e\":g=>f(g.ib,2,\" \"),\"%g\":g=>n(g).toString().substring(2),\"%G\":g=>n(g),\"%H\":g=>h(g.cb,2),\"%I\":g=>{g=g.cb;0==g?g=12:12<g&&(g-=12);return h(g,2)},\"%j\":g=>{for(var u=0,y=0;y<=g.eb-1;u+=(Y(g.$a+1900)?Ub:Vb)[y++]);return h(g.ib+u,3)},\"%m\":g=>h(g.eb+1,2),\"%M\":g=>h(g.Jb,2),\"%n\":()=>\"\\n\",\"%p\":g=>0<=g.cb&&12>g.cb?\"AM\":\"PM\",\"%S\":g=>h(g.Kb,2),\"%t\":()=>\"\\t\",\"%u\":g=>g.Wa||7,\"%U\":g=>h(Math.floor((g.Za+7-g.Wa)/7),2),\"%V\":g=>\n{var u=Math.floor((g.Za+7-(g.Wa+6)%7)/7);2>=(g.Wa+371-g.Za-2)%7&&u++;if(u)53==u&&(y=(g.Wa+371-g.Za)%7,4==y||3==y&&Y(g.$a)||(u=1));else{u=52;var y=(g.Wa+7-g.Za-1)%7;(4==y||5==y&&Y(g.$a%400-1))&&u++}return h(u,2)},\"%w\":g=>g.Wa,\"%W\":g=>h(Math.floor((g.Za+7-(g.Wa+6)%7)/7),2),\"%y\":g=>(g.$a+1900).toString().substring(2),\"%Y\":g=>g.$a+1900,\"%z\":g=>{g=g.Ib;var u=0<=g;g=Math.abs(g)/60;return(u?\"+\":\"-\")+String(\"0000\"+(g/60*100+g%60)).slice(-4)},\"%Z\":g=>g.Lb,\"%%\":()=>\"%\"};c=c.replace(/%%/g,\"\\x00\\x00\");for(r in m)c.includes(r)&&\n(c=c.replace(new RegExp(r,\"g\"),m[r](e)));c=c.replace(/\\0\\0/g,\"%\");r=Wb(c);if(r.length>b)return 0;Xb(r,a);return r.length-1}function Zb(a){try{a()}catch(b){M(b)}}function $b(a){var b={},c;for(c in a)(function(e){var f=a[e];b[e]=\"function\"==typeof f?function(){ac.push(e);try{return f.apply(null,arguments)}finally{P||(ac.pop()===e||M(),D&&1===Z&&0===ac.length&&(Z=0,xa+=1,Zb(bc),\"undefined\"!=typeof Fibers&&Fibers.Ub()))}}:f})(c);return b}var Z=0,D=null,cc=0,ac=[],dc={},ec={},fc=0,gc=null,hc=[];\nfunction ha(){return new Promise((a,b)=>{gc={resolve:a,reject:b}})}function ic(){var a=Ab(65548),b=a+12;A()[a>>2>>>0]=b;A()[a+4>>2>>>0]=b+65536;b=ac[0];var c=dc[b];void 0===c&&(c=fc++,dc[b]=c,ec[c]=b);b=c;z()[a+8>>2>>>0]=b;return a}function jc(){var a=z()[D+8>>2>>>0];a=N[ec[a]];--xa;return a()}\nfunction kc(a){if(!P){if(0===Z){var b=!1,c=!1;a((e=0)=>{if(!P&&(cc=e,b=!0,c)){Z=2;Zb(()=>lc(D));\"undefined\"!=typeof Browser&&Browser.hb.sb&&Browser.hb.resume();e=!1;try{var f=jc()}catch(q){f=q,e=!0}var h=!1;if(!D){var k=gc;k&&(gc=null,(e?k.reject:k.resolve)(f),h=!0)}if(e&&!h)throw f;}});c=!0;b||(Z=1,D=ic(),\"undefined\"!=typeof Browser&&Browser.hb.sb&&Browser.hb.pause(),Zb(()=>mc(D)))}else 2===Z?(Z=0,Zb(nc),oc(D),D=null,hc.forEach(e=>tb(e))):M(`invalid state: ${Z}`);return cc}}\nfunction pc(a){return kc(b=>{a().then(b)})}W.gb();\nvar qc=[null,Oa,Pa,bb,db,eb,ib,jb,kb,lb,mb,nb,ob,pb,qb,rb,sb,yb,zb,Mb,Nb,Ob,Pb,Qb,Tb],tc={r:function(a,b,c){return pc(async()=>{await B.xb(a,b,c)})},b:function(a,b,c){a>>>=0;(new Za(a)).gb(b>>>0,c>>>0);$a=a;ab++;throw $a;},O:function(a){rc(a>>>0,!F,1,!ka,131072,!1);W.lb()},l:function(a){a>>>=0;H?postMessage({cmd:\"cleanupThread\",thread:a}):Ka(a)},I:cb,i:db,U:eb,E:ib,G:jb,V:kb,S:lb,K:mb,R:nb,p:ob,F:pb,C:qb,T:rb,D:sb,q:()=>!0,A:function(a,b){a>>>=0;a==b>>>0?setTimeout(()=>Ta()):H?postMessage({targetThread:a,\ncmd:\"checkMailbox\"}):(a=W.Qa[a])&&a.postMessage({cmd:\"checkMailbox\"})},M:function(){return-1},N:ub,X:function(a){G&&W.Qa[a>>>0].ref()},u:function(a,b,c){a=b+2097152>>>0<4194305-!!a?(a>>>0)+4294967296*b:NaN;c>>>=0;a=new Date(1E3*a);z()[c>>2>>>0]=a.getUTCSeconds();z()[c+4>>2>>>0]=a.getUTCMinutes();z()[c+8>>2>>>0]=a.getUTCHours();z()[c+12>>2>>>0]=a.getUTCDate();z()[c+16>>2>>>0]=a.getUTCMonth();z()[c+20>>2>>>0]=a.getUTCFullYear()-1900;z()[c+24>>2>>>0]=a.getUTCDay();a=(a.getTime()-Date.UTC(a.getUTCFullYear(),\n0,1,0,0,0,0))/864E5|0;z()[c+28>>2>>>0]=a},v:function(a,b,c){a=b+2097152>>>0<4194305-!!a?(a>>>0)+4294967296*b:NaN;c>>>=0;a=new Date(1E3*a);z()[c>>2>>>0]=a.getSeconds();z()[c+4>>2>>>0]=a.getMinutes();z()[c+8>>2>>>0]=a.getHours();z()[c+12>>2>>>0]=a.getDate();z()[c+16>>2>>>0]=a.getMonth();z()[c+20>>2>>>0]=a.getFullYear()-1900;z()[c+24>>2>>>0]=a.getDay();b=(Y(a.getFullYear())?wb:xb)[a.getMonth()]+a.getDate()-1|0;z()[c+28>>2>>>0]=b;z()[c+36>>2>>>0]=-(60*a.getTimezoneOffset());b=(new Date(a.getFullYear(),\n6,1)).getTimezoneOffset();var e=(new Date(a.getFullYear(),0,1)).getTimezoneOffset();a=(b!=e&&a.getTimezoneOffset()==Math.min(e,b))|0;z()[c+32>>2>>>0]=a},w:function(a){a>>>=0;var b=new Date(z()[a+20>>2>>>0]+1900,z()[a+16>>2>>>0],z()[a+12>>2>>>0],z()[a+8>>2>>>0],z()[a+4>>2>>>0],z()[a>>2>>>0],0),c=z()[a+32>>2>>>0],e=b.getTimezoneOffset(),f=(new Date(b.getFullYear(),6,1)).getTimezoneOffset(),h=(new Date(b.getFullYear(),0,1)).getTimezoneOffset(),k=Math.min(h,f);0>c?z()[a+32>>2>>>0]=Number(f!=h&&k==e):\n0<c!=(k==e)&&(f=Math.max(h,f),b.setTime(b.getTime()+6E4*((0<c?k:f)-e)));z()[a+24>>2>>>0]=b.getDay();c=(Y(b.getFullYear())?wb:xb)[b.getMonth()]+b.getDate()-1|0;z()[a+28>>2>>>0]=c;z()[a>>2>>>0]=b.getSeconds();z()[a+4>>2>>>0]=b.getMinutes();z()[a+8>>2>>>0]=b.getHours();z()[a+12>>2>>>0]=b.getDate();z()[a+16>>2>>>0]=b.getMonth();z()[a+20>>2>>>0]=b.getYear();a=b.getTime()/1E3;return sc((U=a,1<=+Math.abs(U)?0<U?+Math.floor(U/4294967296)>>>0:~~+Math.ceil((U-+(~~U>>>0))/4294967296)>>>0:0)),a>>>0},s:yb,t:zb,\nz:function(a,b,c){function e(m){return(m=m.toTimeString().match(/\\(([A-Za-z ]+)\\)$/))?m[1]:\"GMT\"}a>>>=0;b>>>=0;c>>>=0;var f=(new Date).getFullYear(),h=new Date(f,0,1),k=new Date(f,6,1);f=h.getTimezoneOffset();var q=k.getTimezoneOffset(),n=Math.max(f,q);A()[a>>2>>>0]=60*n;z()[b>>2>>>0]=Number(f!=q);a=e(h);b=e(k);a=Bb(a);b=Bb(b);q<f?(A()[c>>2>>>0]=a,A()[c+4>>2>>>0]=b):(A()[c>>2>>>0]=b,A()[c+4>>2>>>0]=a)},d:()=>{M(\"\")},c:function(a,b,c){a>>>=0;b=Db(b>>>0,c>>>0);return Ha[a].apply(null,b)},k:function(a,\nb,c){a>>>=0;b=Db(b>>>0,c>>>0);return Ha[a].apply(null,b)},m:function(){},j:function(){return Date.now()},W:()=>{xa+=1;throw\"unwind\";},B:function(){return 4294901760},f:()=>performance.timeOrigin+performance.now(),g:function(){return G?require(\"os\").cpus().length:navigator.hardwareConcurrency},L:function(a,b,c,e){W.Pb=b>>>0;Ib.length=c;b=e>>>0>>3;for(e=0;e<c;e++)Ib[e]=da()[b+e>>>0];return(0>a?Ha[-a-1]:qc[a]).apply(null,Ib)},y:function(a){a>>>=0;var b=v().length;if(a<=b||4294901760<a)return!1;for(var c=\n1;4>=c;c*=2){var e=b*(1+.2/c);e=Math.min(e,a+100663296);var f=Math;e=Math.max(a,e);a:{f=f.min.call(f,4294901760,e+(65536-e%65536)%65536)-l.buffer.byteLength+65535>>>16;try{l.grow(f);t();var h=1;break a}catch(k){}h=void 0}if(h)return!0}return!1},P:Mb,Q:Nb,H:Qa,h:Ob,o:Pb,x:Qb,n:Tb,a:l||B.wasmMemory,J:Yb,e:function(a,b,c,e){return Yb(a>>>0,b>>>0,c>>>0,e>>>0)}};\n(function(){function a(c,e){c=c.exports;c=$b(c);N=c=uc(c);W.mb.push(N.Da);va.unshift(N.Y);sa=e;Ba();return c}var b={a:tc};Aa();if(B.instantiateWasm)try{return B.instantiateWasm(b,a)}catch(c){K(\"Module.instantiateWasm callback failed with error: \"+c),C(c)}Ga(b,function(c){a(c.instance,c.module)}).catch(C);return{}})();B._OrtInit=(a,b)=>(B._OrtInit=N.Z)(a,b);B._OrtGetLastError=(a,b)=>(B._OrtGetLastError=N._)(a,b);\nB._OrtCreateSessionOptions=(a,b,c,e,f,h,k,q,n,m)=>(B._OrtCreateSessionOptions=N.$)(a,b,c,e,f,h,k,q,n,m);B._OrtAppendExecutionProvider=(a,b)=>(B._OrtAppendExecutionProvider=N.aa)(a,b);B._OrtAddFreeDimensionOverride=(a,b,c)=>(B._OrtAddFreeDimensionOverride=N.ba)(a,b,c);B._OrtAddSessionConfigEntry=(a,b,c)=>(B._OrtAddSessionConfigEntry=N.ca)(a,b,c);B._OrtReleaseSessionOptions=a=>(B._OrtReleaseSessionOptions=N.da)(a);B._OrtCreateSession=(a,b,c)=>(B._OrtCreateSession=N.ea)(a,b,c);\nB._OrtReleaseSession=a=>(B._OrtReleaseSession=N.fa)(a);B._OrtGetInputOutputCount=(a,b,c)=>(B._OrtGetInputOutputCount=N.ga)(a,b,c);B._OrtGetInputName=(a,b)=>(B._OrtGetInputName=N.ha)(a,b);B._OrtGetOutputName=(a,b)=>(B._OrtGetOutputName=N.ia)(a,b);B._OrtFree=a=>(B._OrtFree=N.ja)(a);B._OrtCreateTensor=(a,b,c,e,f,h)=>(B._OrtCreateTensor=N.ka)(a,b,c,e,f,h);B._OrtGetTensorData=(a,b,c,e,f)=>(B._OrtGetTensorData=N.la)(a,b,c,e,f);B._OrtReleaseTensor=a=>(B._OrtReleaseTensor=N.ma)(a);\nB._OrtCreateRunOptions=(a,b,c,e)=>(B._OrtCreateRunOptions=N.na)(a,b,c,e);B._OrtAddRunConfigEntry=(a,b,c)=>(B._OrtAddRunConfigEntry=N.oa)(a,b,c);B._OrtReleaseRunOptions=a=>(B._OrtReleaseRunOptions=N.pa)(a);B._OrtCreateBinding=a=>(B._OrtCreateBinding=N.qa)(a);B._OrtBindInput=(a,b,c)=>(B._OrtBindInput=N.ra)(a,b,c);B._OrtBindOutput=(a,b,c,e)=>(B._OrtBindOutput=N.sa)(a,b,c,e);B._OrtClearBoundOutputs=a=>(B._OrtClearBoundOutputs=N.ta)(a);B._OrtReleaseBinding=a=>(B._OrtReleaseBinding=N.ua)(a);\nB._OrtRunWithBinding=(a,b,c,e,f)=>(B._OrtRunWithBinding=N.va)(a,b,c,e,f);B._OrtRun=(a,b,c,e,f,h,k,q)=>(B._OrtRun=N.wa)(a,b,c,e,f,h,k,q);B._OrtEndProfiling=a=>(B._OrtEndProfiling=N.xa)(a);B._JsepOutput=(a,b,c)=>(B._JsepOutput=N.ya)(a,b,c);B._JsepGetNodeName=a=>(B._JsepGetNodeName=N.za)(a);var Sa=B._pthread_self=()=>(Sa=B._pthread_self=N.Aa)(),Ab=B._malloc=a=>(Ab=B._malloc=N.Ba)(a),oc=B._free=a=>(oc=B._free=N.Ca)(a);B.__emscripten_tls_init=()=>(B.__emscripten_tls_init=N.Da)();\nvar rc=B.__emscripten_thread_init=(a,b,c,e,f,h)=>(rc=B.__emscripten_thread_init=N.Fa)(a,b,c,e,f,h);B.__emscripten_thread_crashed=()=>(B.__emscripten_thread_crashed=N.Ga)();\nvar Hb=(a,b,c,e)=>(Hb=N.Ha)(a,b,c,e),Ra=a=>(Ra=N.Ia)(a),Ya=B.__emscripten_thread_exit=a=>(Ya=B.__emscripten_thread_exit=N.Ja)(a),vb=B.__emscripten_check_mailbox=()=>(vb=B.__emscripten_check_mailbox=N.Ka)(),sc=a=>(sc=N.La)(a),Va=(a,b)=>(Va=N.Ma)(a,b),Eb=()=>(Eb=N.Na)(),Wa=a=>(Wa=N.Oa)(a),Gb=a=>(Gb=N.Pa)(a),Xa=B.dynCall_ii=(a,b)=>(Xa=B.dynCall_ii=N.Ra)(a,b),mc=a=>(mc=N.Sa)(a),bc=()=>(bc=N.Ta)(),lc=a=>(lc=N.Ua)(a),nc=()=>(nc=N.Va)();B.___start_em_js=917678;B.___stop_em_js=917839;\nfunction uc(a){a=Object.assign({},a);var b=e=>()=>e()>>>0,c=e=>f=>e(f)>>>0;a.__errno_location=b(a.__errno_location);a.pthread_self=b(a.pthread_self);a.malloc=c(a.malloc);a.stackSave=b(a.stackSave);a.stackAlloc=c(a.stackAlloc);return a}B.keepRuntimeAlive=ya;B.wasmMemory=l;B.stackAlloc=Gb;B.stackSave=Eb;B.stackRestore=Wa;B.UTF8ToString=V;B.stringToUTF8=hb;B.lengthBytesUTF8=fb;B.ExitStatus=Ia;B.PThread=W;var vc;S=function wc(){vc||xc();vc||(S=wc)};\nfunction xc(){function a(){if(!vc&&(vc=!0,B.calledRun=!0,!P)){H||Ua(va);fa(B);if(B.onRuntimeInitialized)B.onRuntimeInitialized();if(!H){if(B.postRun)for(\"function\"==typeof B.postRun&&(B.postRun=[B.postRun]);B.postRun.length;){var b=B.postRun.shift();wa.unshift(b)}Ua(wa)}}}if(!(0<R))if(H)fa(B),H||Ua(va),startWorker(B);else{if(B.preRun)for(\"function\"==typeof B.preRun&&(B.preRun=[B.preRun]);B.preRun.length;)ua.unshift(B.preRun.shift());Ua(ua);0<R||(B.setStatus?(B.setStatus(\"Running...\"),setTimeout(function(){setTimeout(function(){B.setStatus(\"\")},\n1);a()},1)):a())}}if(B.preInit)for(\"function\"==typeof B.preInit&&(B.preInit=[B.preInit]);0<B.preInit.length;)B.preInit.pop()();xc();\n\n\n  return moduleArg.ready\n}\n\n);\n})();\nif (typeof exports === 'object' && typeof module === 'object')\n  module.exports = ortWasmThreaded;\nelse if (typeof define === 'function' && define['amd'])\n  define([], () => ortWasmThreaded);\n", "\"use strict\";var Module={};var ENVIRONMENT_IS_NODE=typeof process==\"object\"&&typeof process.versions==\"object\"&&typeof process.versions.node==\"string\";if(ENVIRONMENT_IS_NODE){var nodeWorkerThreads=require(\"worker_threads\");var parentPort=nodeWorkerThreads.parentPort;parentPort.on(\"message\",data=>onmessage({data:data}));var fs=require(\"fs\");Object.assign(global,{self:global,require:require,Module:Module,location:{href:__filename},Worker:nodeWorkerThreads.Worker,importScripts:f=>(0,eval)(fs.readFileSync(f,\"utf8\")+\"//# sourceURL=\"+f),postMessage:msg=>parentPort.postMessage(msg),performance:global.performance||{now:Date.now}})}var initializedJS=false;function threadPrintErr(){var text=Array.prototype.slice.call(arguments).join(\" \");if(ENVIRONMENT_IS_NODE){fs.writeSync(2,text+\"\\n\");return}console.error(text)}function threadAlert(){var text=Array.prototype.slice.call(arguments).join(\" \");postMessage({cmd:\"alert\",text:text,threadId:Module[\"_pthread_self\"]()})}var err=threadPrintErr;self.alert=threadAlert;Module[\"instantiateWasm\"]=(info,receiveInstance)=>{var module=Module[\"wasmModule\"];Module[\"wasmModule\"]=null;var instance=new WebAssembly.Instance(module,info);return receiveInstance(instance)};self.onunhandledrejection=e=>{throw e.reason??e};function handleMessage(e){try{if(e.data.cmd===\"load\"){let messageQueue=[];self.onmessage=e=>messageQueue.push(e);self.startWorker=instance=>{Module=instance;postMessage({\"cmd\":\"loaded\"});for(let msg of messageQueue){handleMessage(msg)}self.onmessage=handleMessage};Module[\"wasmModule\"]=e.data.wasmModule;for(const handler of e.data.handlers){Module[handler]=(...args)=>{postMessage({cmd:\"callHandler\",handler:handler,args:args})}}Module[\"wasmMemory\"]=e.data.wasmMemory;Module[\"buffer\"]=Module[\"wasmMemory\"].buffer;Module[\"ENVIRONMENT_IS_PTHREAD\"]=true;if(typeof e.data.urlOrBlob==\"string\"){importScripts(e.data.urlOrBlob)}else{var objectUrl=URL.createObjectURL(e.data.urlOrBlob);importScripts(objectUrl);URL.revokeObjectURL(objectUrl)}ortWasmThreaded(Module)}else if(e.data.cmd===\"run\"){Module[\"__emscripten_thread_init\"](e.data.pthread_ptr,/*isMainBrowserThread=*/0,/*isMainRuntimeThread=*/0,/*canBlock=*/1);Module[\"__emscripten_thread_mailbox_await\"](e.data.pthread_ptr);Module[\"establishStackSpace\"]();Module[\"PThread\"].receiveObjectTransfer(e.data);Module[\"PThread\"].threadInitTLS();if(!initializedJS){initializedJS=true}try{Module[\"invokeEntryPoint\"](e.data.start_routine,e.data.arg)}catch(ex){if(ex!=\"unwind\"){throw ex}}}else if(e.data.cmd===\"cancel\"){if(Module[\"_pthread_self\"]()){Module[\"__emscripten_thread_exit\"](-1)}}else if(e.data.target===\"setimmediate\"){}else if(e.data.cmd===\"checkMailbox\"){if(initializedJS){Module[\"checkMailbox\"]()}}else if(e.data.cmd){err(\"worker.js received unknown command \"+e.data.cmd);err(e.data)}}catch(ex){if(Module[\"__emscripten_thread_crashed\"]){Module[\"__emscripten_thread_crashed\"]()}throw ex}}self.onmessage=handleMessage;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport * as path from 'node:path';\nimport {Env} from 'onnxruntime-common';\n\nimport {OrtWasmModule} from './binding/ort-wasm';\nimport {OrtWasmThreadedModule} from './binding/ort-wasm-threaded';\n\n/* eslint-disable @typescript-eslint/no-require-imports */\nlet ortWasmFactory: EmscriptenModuleFactory<OrtWasmModule>;\n\nif (!BUILD_DEFS.DISABLE_TRAINING) {\n  ortWasmFactory = require('./binding/ort-training-wasm-simd.js');\n} else {\n  ortWasmFactory =\n      BUILD_DEFS.DISABLE_WEBGPU ? require('./binding/ort-wasm.js') : require('./binding/ort-wasm-simd.jsep.js');\n}\n\nconst ortWasmFactoryThreaded: EmscriptenModuleFactory<OrtWasmModule> = !BUILD_DEFS.DISABLE_WASM_THREAD ?\n    (BUILD_DEFS.DISABLE_WEBGPU ? require('./binding/ort-wasm-threaded.js') :\n                                 require('./binding/ort-wasm-simd-threaded.jsep.js')) :\n    ortWasmFactory;\n/* eslint-enable @typescript-eslint/no-require-imports */\n\nlet wasm: OrtWasmModule|undefined;\nlet initialized = false;\nlet initializing = false;\nlet aborted = false;\n\nconst isMultiThreadSupported = (numThreads: number): boolean => {\n  // WebAssembly threads are set to 1 (single thread).\n  if (numThreads === 1) {\n    return false;\n  }\n\n  // If 'SharedArrayBuffer' is not available, WebAssembly threads will not work.\n  if (typeof SharedArrayBuffer === 'undefined') {\n    if (typeof self !== 'undefined' && !self.crossOriginIsolated) {\n      // eslint-disable-next-line no-console\n      console.warn(\n          'env.wasm.numThreads is set to ' + numThreads +\n          ', but this will not work unless you enable crossOriginIsolated mode. ' +\n          'See https://web.dev/cross-origin-isolation-guide/ for more info.');\n    }\n    return false;\n  }\n\n  // onnxruntime-web does not support multi-threads in Node.js.\n  if (typeof process !== 'undefined' && process.versions && process.versions.node) {\n    // eslint-disable-next-line no-console\n    console.warn(\n        'env.wasm.numThreads is set to ' + numThreads +\n        ', however, currently onnxruntime-web does not support multi-threads in Node.js. ' +\n        'Please consider using onnxruntime-node for performance critical scenarios.');\n  }\n\n  try {\n    // Test for transferability of SABs (for browsers. needed for Firefox)\n    // https://groups.google.com/forum/#!msg/mozilla.dev.platform/IHkBZlHETpA/dwsMNchWEQAJ\n    if (typeof MessageChannel !== 'undefined') {\n      new MessageChannel().port1.postMessage(new SharedArrayBuffer(1));\n    }\n\n    // Test for WebAssembly threads capability (for both browsers and Node.js)\n    // This typed array is a WebAssembly program containing threaded instructions.\n    return WebAssembly.validate(new Uint8Array([\n      0, 97, 115, 109, 1, 0,  0,  0, 1, 4, 1,  96, 0,   0,  3, 2, 1,  0, 5,\n      4, 1,  3,   1,   1, 10, 11, 1, 9, 0, 65, 0,  254, 16, 2, 0, 26, 11\n    ]));\n  } catch (e) {\n    return false;\n  }\n};\n\nconst isSimdSupported = (): boolean => {\n  try {\n    // Test for WebAssembly SIMD capability (for both browsers and Node.js)\n    // This typed array is a WebAssembly program containing SIMD instructions.\n\n    // The binary data is generated from the following code by wat2wasm:\n    //\n    // (module\n    //   (type $t0 (func))\n    //   (func $f0 (type $t0)\n    //     (drop\n    //       (i32x4.dot_i16x8_s\n    //         (i8x16.splat\n    //           (i32.const 0))\n    //         (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)))))\n\n    return WebAssembly.validate(new Uint8Array([\n      0,   97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 30, 1,   28,  0, 65, 0,\n      253, 15, 253, 12,  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0,  0,  253, 186, 1, 26, 11\n    ]));\n  } catch (e) {\n    return false;\n  }\n};\n\nconst getWasmFileName = (useSimd: boolean, useThreads: boolean) => {\n  if (useSimd) {\n    if (!BUILD_DEFS.DISABLE_TRAINING) {\n      return 'ort-training-wasm-simd.wasm';\n    }\n    return useThreads ? 'ort-wasm-simd-threaded.wasm' : 'ort-wasm-simd.wasm';\n  } else {\n    return useThreads ? 'ort-wasm-threaded.wasm' : 'ort-wasm.wasm';\n  }\n};\n\nexport const initializeWebAssembly = async(flags: Env.WebAssemblyFlags): Promise<void> => {\n  if (initialized) {\n    return Promise.resolve();\n  }\n  if (initializing) {\n    throw new Error('multiple calls to \\'initializeWebAssembly()\\' detected.');\n  }\n  if (aborted) {\n    throw new Error('previous call to \\'initializeWebAssembly()\\' failed.');\n  }\n\n  initializing = true;\n\n  // wasm flags are already initialized\n  const timeout = flags.initTimeout!;\n  const numThreads = flags.numThreads!;\n  const simd = flags.simd!;\n\n  const useThreads = isMultiThreadSupported(numThreads);\n  const useSimd = simd && isSimdSupported();\n\n  const wasmPaths = flags.wasmPaths;\n  const wasmPrefixOverride = typeof wasmPaths === 'string' ? wasmPaths : undefined;\n  const wasmFileName = getWasmFileName(useSimd, useThreads);\n  const wasmPathOverride = typeof wasmPaths === 'object' ? wasmPaths[wasmFileName] : undefined;\n\n  let isTimeout = false;\n\n  const tasks: Array<Promise<void>> = [];\n\n  // promise for timeout\n  if (timeout > 0) {\n    tasks.push(new Promise((resolve) => {\n      setTimeout(() => {\n        isTimeout = true;\n        resolve();\n      }, timeout);\n    }));\n  }\n\n  // promise for module initialization\n  tasks.push(new Promise((resolve, reject) => {\n    const factory = useThreads ? ortWasmFactoryThreaded : ortWasmFactory;\n    const config: Partial<OrtWasmModule> = {\n      locateFile: (fileName: string, scriptDirectory: string) => {\n        if (!BUILD_DEFS.DISABLE_WASM_THREAD && useThreads && fileName.endsWith('.worker.js') &&\n            typeof Blob !== 'undefined') {\n          return URL.createObjectURL(new Blob(\n              [\n                // This require() function is handled by esbuild plugin to load file content as string.\n                // eslint-disable-next-line @typescript-eslint/no-require-imports\n                require('./binding/ort-wasm-threaded.worker.js')\n              ],\n              {type: 'text/javascript'}));\n        }\n\n        if (fileName.endsWith('.wasm')) {\n          if (wasmPathOverride) {\n            return wasmPathOverride;\n          }\n\n          const prefix = wasmPrefixOverride ?? scriptDirectory;\n\n          if (!BUILD_DEFS.DISABLE_WEBGPU) {\n            if (wasmFileName === 'ort-wasm-simd.wasm') {\n              return prefix + 'ort-wasm-simd.jsep.wasm';\n            } else if (wasmFileName === 'ort-wasm-simd-threaded.wasm') {\n              return prefix + 'ort-wasm-simd-threaded.jsep.wasm';\n            }\n          }\n\n          return prefix + wasmFileName;\n        }\n\n        return scriptDirectory + fileName;\n      }\n    };\n\n    if (!BUILD_DEFS.DISABLE_WASM_THREAD && useThreads) {\n      config.numThreads = numThreads;\n      if (typeof Blob === 'undefined') {\n        config.mainScriptUrlOrBlob = path.join(__dirname, 'ort-wasm-threaded.js');\n      } else {\n        const scriptSourceCode = `var ortWasmThreaded=${factory.toString()};`;\n        config.mainScriptUrlOrBlob = new Blob([scriptSourceCode], {type: 'text/javascript'});\n      }\n    }\n\n    factory(config).then(\n        // wasm module initialized successfully\n        module => {\n          initializing = false;\n          initialized = true;\n          wasm = module;\n          resolve();\n        },\n        // wasm module failed to initialize\n        (what) => {\n          initializing = false;\n          aborted = true;\n          reject(what);\n        });\n  }));\n\n  await Promise.race(tasks);\n\n  if (isTimeout) {\n    throw new Error(`WebAssembly backend initializing failed due to timeout: ${timeout}ms`);\n  }\n};\n\nexport const getInstance = (): OrtWasmModule => {\n  if (initialized && wasm) {\n    return wasm;\n  }\n\n  throw new Error('WebAssembly is not initialized yet.');\n};\n\nexport const dispose = (): void => {\n  if (initialized && !initializing && !aborted) {\n    initializing = true;\n\n    (wasm as OrtWasmThreadedModule).PThread?.terminateAllThreads();\n    wasm = undefined;\n\n    initializing = false;\n    initialized = false;\n    aborted = true;\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {getInstance} from './wasm-factory';\n\nexport const allocWasmString = (data: string, allocs: number[]): number => {\n  const wasm = getInstance();\n\n  const dataLength = wasm.lengthBytesUTF8(data) + 1;\n  const dataOffset = wasm._malloc(dataLength);\n  wasm.stringToUTF8(data, dataOffset, dataLength);\n  allocs.push(dataOffset);\n\n  return dataOffset;\n};\n\ninterface ExtraOptionsHandler {\n  (name: string, value: string): void;\n}\n\nexport const iterateExtraOptions =\n    (options: Record<string, unknown>, prefix: string, seen: WeakSet<Record<string, unknown>>,\n     handler: ExtraOptionsHandler): void => {\n      if (typeof options == 'object' && options !== null) {\n        if (seen.has(options)) {\n          throw new Error('Circular reference in options');\n        } else {\n          seen.add(options);\n        }\n      }\n\n      Object.entries(options).forEach(([key, value]) => {\n        const name = (prefix) ? prefix + key : key;\n        if (typeof value === 'object') {\n          iterateExtraOptions(value as Record<string, unknown>, name + '.', seen, handler);\n        } else if (typeof value === 'string' || typeof value === 'number') {\n          handler(name, value.toString());\n        } else if (typeof value === 'boolean') {\n          handler(name, (value) ? '1' : '0');\n        } else {\n          throw new Error(`Can't handle extra config type: ${typeof value}`);\n        }\n      });\n    };\n\n/**\n * check web assembly API's last error and throw error if any error occurred.\n * @param message a message used when an error occurred.\n */\nexport const checkLastError = (message: string): void => {\n  const wasm = getInstance();\n\n  const stack = wasm.stackSave();\n  try {\n    const paramsOffset = wasm.stackAlloc(8);\n    wasm._OrtGetLastError(paramsOffset, paramsOffset + 4);\n    const errorCode = wasm.HEAP32[paramsOffset / 4];\n    const errorMessagePointer = wasm.HEAPU32[paramsOffset / 4 + 1];\n    const errorMessage = errorMessagePointer ? wasm.UTF8ToString(errorMessagePointer) : '';\n    throw new Error(`${message} ERROR_CODE: ${errorCode}, ERROR_MESSAGE: ${errorMessage}`);\n  } finally {\n    wasm.stackRestore(stack);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {InferenceSession} from 'onnxruntime-common';\n\nimport {getInstance} from './wasm-factory';\nimport {allocWasmString, checkLastError, iterateExtraOptions} from './wasm-utils';\n\nexport const setRunOptions = (options: InferenceSession.RunOptions): [number, number[]] => {\n  const wasm = getInstance();\n  let runOptionsHandle = 0;\n  const allocs: number[] = [];\n\n  const runOptions: InferenceSession.RunOptions = options || {};\n\n  try {\n    if (options?.logSeverityLevel === undefined) {\n      runOptions.logSeverityLevel = 2;  // Default to warning\n    } else if (\n        typeof options.logSeverityLevel !== 'number' || !Number.isInteger(options.logSeverityLevel) ||\n        options.logSeverityLevel < 0 || options.logSeverityLevel > 4) {\n      throw new Error(`log serverity level is not valid: ${options.logSeverityLevel}`);\n    }\n\n    if (options?.logVerbosityLevel === undefined) {\n      runOptions.logVerbosityLevel = 0;  // Default to 0\n    } else if (typeof options.logVerbosityLevel !== 'number' || !Number.isInteger(options.logVerbosityLevel)) {\n      throw new Error(`log verbosity level is not valid: ${options.logVerbosityLevel}`);\n    }\n\n    if (options?.terminate === undefined) {\n      runOptions.terminate = false;\n    }\n\n    let tagDataOffset = 0;\n    if (options?.tag !== undefined) {\n      tagDataOffset = allocWasmString(options.tag, allocs);\n    }\n\n    runOptionsHandle = wasm._OrtCreateRunOptions(\n        runOptions.logSeverityLevel!, runOptions.logVerbosityLevel!, !!runOptions.terminate!, tagDataOffset);\n    if (runOptionsHandle === 0) {\n      checkLastError('Can\\'t create run options.');\n    }\n\n    if (options?.extra !== undefined) {\n      iterateExtraOptions(options.extra, '', new WeakSet<Record<string, unknown>>(), (key, value) => {\n        const keyDataOffset = allocWasmString(key, allocs);\n        const valueDataOffset = allocWasmString(value, allocs);\n\n        if (wasm._OrtAddRunConfigEntry(runOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n          checkLastError(`Can't set a run config entry: ${key} - ${value}.`);\n        }\n      });\n    }\n\n    return [runOptionsHandle, allocs];\n  } catch (e) {\n    if (runOptionsHandle !== 0) {\n      wasm._OrtReleaseRunOptions(runOptionsHandle);\n    }\n    allocs.forEach(alloc => wasm._free(alloc));\n    throw e;\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {InferenceSession} from 'onnxruntime-common';\n\nimport {getInstance} from './wasm-factory';\nimport {allocWasmString, checkLastError, iterateExtraOptions} from './wasm-utils';\n\nconst getGraphOptimzationLevel = (graphOptimizationLevel: string|unknown): number => {\n  switch (graphOptimizationLevel) {\n    case 'disabled':\n      return 0;\n    case 'basic':\n      return 1;\n    case 'extended':\n      return 2;\n    case 'all':\n      return 99;\n    default:\n      throw new Error(`unsupported graph optimization level: ${graphOptimizationLevel}`);\n  }\n};\n\nconst getExecutionMode = (executionMode: 'sequential'|'parallel'): number => {\n  switch (executionMode) {\n    case 'sequential':\n      return 0;\n    case 'parallel':\n      return 1;\n    default:\n      throw new Error(`unsupported execution mode: ${executionMode}`);\n  }\n};\n\nconst appendDefaultOptions = (options: InferenceSession.SessionOptions): void => {\n  if (!options.extra) {\n    options.extra = {};\n  }\n  if (!options.extra.session) {\n    options.extra.session = {};\n  }\n  const session = options.extra.session as Record<string, string>;\n  if (!session.use_ort_model_bytes_directly) {\n    // eslint-disable-next-line camelcase\n    session.use_ort_model_bytes_directly = '1';\n  }\n\n  // if using JSEP with WebGPU, always disable memory pattern\n  if (options.executionProviders &&\n      options.executionProviders.some(ep => (typeof ep === 'string' ? ep : ep.name) === 'webgpu')) {\n    options.enableMemPattern = false;\n  }\n};\n\nconst setExecutionProviders =\n    (sessionOptionsHandle: number, executionProviders: readonly InferenceSession.ExecutionProviderConfig[],\n     allocs: number[]): void => {\n      for (const ep of executionProviders) {\n        let epName = typeof ep === 'string' ? ep : ep.name;\n\n        // check EP name\n        switch (epName) {\n          case 'webnn':\n            epName = 'WEBNN';\n            if (typeof ep !== 'string') {\n              const webnnOptions = ep as InferenceSession.WebNNExecutionProviderOption;\n              if (webnnOptions?.deviceType) {\n                const keyDataOffset = allocWasmString('deviceType', allocs);\n                const valueDataOffset = allocWasmString(webnnOptions.deviceType, allocs);\n                if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !==\n                    0) {\n                  checkLastError(`Can't set a session config entry: 'deviceType' - ${webnnOptions.deviceType}.`);\n                }\n              }\n              if (webnnOptions?.numThreads) {\n                let numThreads = webnnOptions.numThreads;\n                // Just ignore invalid webnnOptions.numThreads.\n                if (typeof numThreads != 'number' || !Number.isInteger(numThreads) || numThreads < 0) {\n                  numThreads = 0;\n                }\n                const keyDataOffset = allocWasmString('numThreads', allocs);\n                const valueDataOffset = allocWasmString(numThreads.toString(), allocs);\n                if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !==\n                    0) {\n                  checkLastError(`Can't set a session config entry: 'numThreads' - ${webnnOptions.numThreads}.`);\n                }\n              }\n              if (webnnOptions?.powerPreference) {\n                const keyDataOffset = allocWasmString('powerPreference', allocs);\n                const valueDataOffset = allocWasmString(webnnOptions.powerPreference, allocs);\n                if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !==\n                    0) {\n                  checkLastError(\n                      `Can't set a session config entry: 'powerPreference' - ${webnnOptions.powerPreference}.`);\n                }\n              }\n            }\n            break;\n          case 'webgpu':\n            epName = 'JS';\n            if (typeof ep !== 'string') {\n              const webgpuOptions = ep as InferenceSession.WebGpuExecutionProviderOption;\n              if (webgpuOptions?.preferredLayout) {\n                if (webgpuOptions.preferredLayout !== 'NCHW' && webgpuOptions.preferredLayout !== 'NHWC') {\n                  throw new Error(`preferredLayout must be either 'NCHW' or 'NHWC': ${webgpuOptions.preferredLayout}`);\n                }\n                const keyDataOffset = allocWasmString('preferredLayout', allocs);\n                const valueDataOffset = allocWasmString(webgpuOptions.preferredLayout, allocs);\n                if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !==\n                    0) {\n                  checkLastError(\n                      `Can't set a session config entry: 'preferredLayout' - ${webgpuOptions.preferredLayout}.`);\n                }\n              }\n            }\n            break;\n          case 'wasm':\n          case 'cpu':\n            continue;\n          default:\n            throw new Error(`not supported execution provider: ${epName}`);\n        }\n\n        const epNameDataOffset = allocWasmString(epName, allocs);\n        if (getInstance()._OrtAppendExecutionProvider(sessionOptionsHandle, epNameDataOffset) !== 0) {\n          checkLastError(`Can't append execution provider: ${epName}.`);\n        }\n      }\n    };\n\nexport const setSessionOptions = (options?: InferenceSession.SessionOptions): [number, number[]] => {\n  const wasm = getInstance();\n  let sessionOptionsHandle = 0;\n  const allocs: number[] = [];\n\n  const sessionOptions: InferenceSession.SessionOptions = options || {};\n  appendDefaultOptions(sessionOptions);\n\n  try {\n    const graphOptimizationLevel = getGraphOptimzationLevel(sessionOptions.graphOptimizationLevel ?? 'all');\n    const executionMode = getExecutionMode(sessionOptions.executionMode ?? 'sequential');\n    const logIdDataOffset =\n        typeof sessionOptions.logId === 'string' ? allocWasmString(sessionOptions.logId, allocs) : 0;\n\n    const logSeverityLevel = sessionOptions.logSeverityLevel ?? 2;  // Default to 2 - warning\n    if (!Number.isInteger(logSeverityLevel) || logSeverityLevel < 0 || logSeverityLevel > 4) {\n      throw new Error(`log serverity level is not valid: ${logSeverityLevel}`);\n    }\n\n    const logVerbosityLevel = sessionOptions.logVerbosityLevel ?? 0;  // Default to 0 - verbose\n    if (!Number.isInteger(logVerbosityLevel) || logVerbosityLevel < 0 || logVerbosityLevel > 4) {\n      throw new Error(`log verbosity level is not valid: ${logVerbosityLevel}`);\n    }\n\n    const optimizedModelFilePathOffset = typeof sessionOptions.optimizedModelFilePath === 'string' ?\n        allocWasmString(sessionOptions.optimizedModelFilePath, allocs) :\n        0;\n\n    sessionOptionsHandle = wasm._OrtCreateSessionOptions(\n        graphOptimizationLevel, !!sessionOptions.enableCpuMemArena, !!sessionOptions.enableMemPattern, executionMode,\n        !!sessionOptions.enableProfiling, 0, logIdDataOffset, logSeverityLevel, logVerbosityLevel,\n        optimizedModelFilePathOffset);\n    if (sessionOptionsHandle === 0) {\n      checkLastError('Can\\'t create session options.');\n    }\n\n    if (sessionOptions.executionProviders) {\n      setExecutionProviders(sessionOptionsHandle, sessionOptions.executionProviders, allocs);\n    }\n\n    if (sessionOptions.enableGraphCapture !== undefined) {\n      if (typeof sessionOptions.enableGraphCapture !== 'boolean') {\n        throw new Error(`enableGraphCapture must be a boolean value: ${sessionOptions.enableGraphCapture}`);\n      }\n      const keyDataOffset = allocWasmString('enableGraphCapture', allocs);\n      const valueDataOffset = allocWasmString(sessionOptions.enableGraphCapture.toString(), allocs);\n      if (wasm._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n        checkLastError(\n            `Can't set a session config entry: 'enableGraphCapture' - ${sessionOptions.enableGraphCapture}.`);\n      }\n    }\n\n    if (sessionOptions.freeDimensionOverrides) {\n      for (const [name, value] of Object.entries(sessionOptions.freeDimensionOverrides)) {\n        if (typeof name !== 'string') {\n          throw new Error(`free dimension override name must be a string: ${name}`);\n        }\n        if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {\n          throw new Error(`free dimension override value must be a non-negative integer: ${value}`);\n        }\n        const nameOffset = allocWasmString(name, allocs);\n        if (wasm._OrtAddFreeDimensionOverride(sessionOptionsHandle, nameOffset, value) !== 0) {\n          checkLastError(`Can't set a free dimension override: ${name} - ${value}.`);\n        }\n      }\n    }\n\n    if (sessionOptions.extra !== undefined) {\n      iterateExtraOptions(sessionOptions.extra, '', new WeakSet<Record<string, unknown>>(), (key, value) => {\n        const keyDataOffset = allocWasmString(key, allocs);\n        const valueDataOffset = allocWasmString(value, allocs);\n\n        if (wasm._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n          checkLastError(`Can't set a session config entry: ${key} - ${value}.`);\n        }\n      });\n    }\n\n    return [sessionOptionsHandle, allocs];\n  } catch (e) {\n    if (sessionOptionsHandle !== 0) {\n      wasm._OrtReleaseSessionOptions(sessionOptionsHandle);\n    }\n    allocs.forEach(alloc => wasm._free(alloc));\n    throw e;\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Tensor} from 'onnxruntime-common';\n\n// a dummy type declaration for Float16Array in case any polyfill is available.\ndeclare global {\n  // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any\n  const Float16Array: any;\n}\n\n// This file includes common definitions. They do NOT have dependency on the WebAssembly instance.\n\n/**\n * Copied from ONNX definition. Use this to drop dependency 'onnx_proto' to decrease compiled .js file size.\n */\nexport const enum DataType {\n  undefined = 0,\n  float = 1,\n  uint8 = 2,\n  int8 = 3,\n  uint16 = 4,\n  int16 = 5,\n  int32 = 6,\n  int64 = 7,\n  string = 8,\n  bool = 9,\n  float16 = 10,\n  double = 11,\n  uint32 = 12,\n  uint64 = 13,\n  complex64 = 14,\n  complex128 = 15,\n  bfloat16 = 16\n}\n\n/**\n * Map string tensor data to enum value\n */\nexport const tensorDataTypeStringToEnum = (type: string): DataType => {\n  switch (type) {\n    case 'int8':\n      return DataType.int8;\n    case 'uint8':\n      return DataType.uint8;\n    case 'bool':\n      return DataType.bool;\n    case 'int16':\n      return DataType.int16;\n    case 'uint16':\n      return DataType.uint16;\n    case 'int32':\n      return DataType.int32;\n    case 'uint32':\n      return DataType.uint32;\n    case 'float16':\n      return DataType.float16;\n    case 'float32':\n      return DataType.float;\n    case 'float64':\n      return DataType.double;\n    case 'string':\n      return DataType.string;\n    case 'int64':\n      return DataType.int64;\n    case 'uint64':\n      return DataType.uint64;\n\n    default:\n      throw new Error(`unsupported data type: ${type}`);\n  }\n};\n\n/**\n * Map enum value to string tensor data\n */\nexport const tensorDataTypeEnumToString = (typeProto: DataType): Tensor.Type => {\n  switch (typeProto) {\n    case DataType.int8:\n      return 'int8';\n    case DataType.uint8:\n      return 'uint8';\n    case DataType.bool:\n      return 'bool';\n    case DataType.int16:\n      return 'int16';\n    case DataType.uint16:\n      return 'uint16';\n    case DataType.int32:\n      return 'int32';\n    case DataType.uint32:\n      return 'uint32';\n    case DataType.float16:\n      return 'float16';\n    case DataType.float:\n      return 'float32';\n    case DataType.double:\n      return 'float64';\n    case DataType.string:\n      return 'string';\n    case DataType.int64:\n      return 'int64';\n    case DataType.uint64:\n      return 'uint64';\n\n    default:\n      throw new Error(`unsupported data type: ${typeProto}`);\n  }\n};\n\n/**\n * get tensor element size in bytes by the given data type\n * @returns size in integer or undefined if the data type is not supported\n */\nexport const getTensorElementSize = (dateType: number): number|\n    undefined => [undefined, 4, 1, 1, 2, 2, 4, 8, undefined, 1, 2, 8, 4, 8, undefined, undefined, undefined][dateType];\n\n/**\n * get typed array constructor by the given tensor type\n */\nexport const tensorTypeToTypedArrayConstructor = (type: Tensor.Type): Float32ArrayConstructor|Uint8ArrayConstructor|\n    Int8ArrayConstructor|Uint16ArrayConstructor|Int16ArrayConstructor|Int32ArrayConstructor|BigInt64ArrayConstructor|\n    Uint8ArrayConstructor|Float64ArrayConstructor|Uint32ArrayConstructor|BigUint64ArrayConstructor => {\n      switch (type) {\n        case 'float16':\n          // allow Float16Array polyfill.\n          return typeof Float16Array !== 'undefined' && Float16Array.from ? Float16Array : Uint16Array;\n        case 'float32':\n          return Float32Array;\n        case 'uint8':\n          return Uint8Array;\n        case 'int8':\n          return Int8Array;\n        case 'uint16':\n          return Uint16Array;\n        case 'int16':\n          return Int16Array;\n        case 'int32':\n          return Int32Array;\n        case 'bool':\n          return Uint8Array;\n        case 'float64':\n          return Float64Array;\n        case 'uint32':\n          return Uint32Array;\n        case 'int64':\n          return BigInt64Array;\n        case 'uint64':\n          return BigUint64Array;\n        default:\n          throw new Error(`unsupported type: ${type}`);\n      }\n    };\n\n/**\n * Map string log level to integer value\n */\nexport const logLevelStringToEnum = (logLevel?: 'verbose'|'info'|'warning'|'error'|'fatal'): number => {\n  switch (logLevel) {\n    case 'verbose':\n      return 0;\n    case 'info':\n      return 1;\n    case 'warning':\n      return 2;\n    case 'error':\n      return 3;\n    case 'fatal':\n      return 4;\n    default:\n      throw new Error(`unsupported logging level: ${logLevel}`);\n  }\n};\n\n/**\n * Check whether the given tensor type is supported by GPU buffer\n */\nexport const isGpuBufferSupportedType = (type: Tensor.Type): type is Tensor.GpuBufferDataTypes => type === 'float32' ||\n    type === 'float16' || type === 'int32' || type === 'int64' || type === 'uint32' || type === 'uint8' ||\n    type === 'bool';\n\n/**\n * Map string data location to integer value\n */\nexport const dataLocationStringToEnum = (location: Tensor.DataLocation): number => {\n  switch (location) {\n    case 'none':\n      return 0;\n    case 'cpu':\n      return 1;\n    case 'cpu-pinned':\n      return 2;\n    case 'texture':\n      return 3;\n    case 'gpu-buffer':\n      return 4;\n    default:\n      throw new Error(`unsupported data location: ${location}`);\n  }\n};\n\n/**\n * Map integer data location to string value\n */\nexport const dataLocationEnumToString = (location: number): Tensor.DataLocation|undefined =>\n    (['none', 'cpu', 'cpu-pinned', 'texture', 'gpu-buffer'] as const)[location];\n", "export const readFile = undefined;export const readFileSync = undefined;export const createReadStream = undefined;", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport * as fs from 'fs';\nimport {readFile} from 'node:fs/promises';\n\n/**\n * Load a file into a Uint8Array.\n *\n * @param file - the file to load. Can be a URL/path, a Blob, an ArrayBuffer, or a Uint8Array.\n * @returns a Uint8Array containing the file data.\n */\nexport const loadFile = async(file: string|Blob|ArrayBufferLike|Uint8Array): Promise<Uint8Array> => {\n  if (typeof file === 'string') {\n    if (typeof process !== 'undefined' && process.versions && process.versions.node) {\n      // load file into ArrayBuffer in Node.js\n      try {\n        return new Uint8Array(await readFile(file));\n      } catch (e) {\n        if (e.code === 'ERR_FS_FILE_TOO_LARGE') {\n          // file is too large, use fs.createReadStream instead\n          const stream = fs.createReadStream(file);\n          const chunks: Uint8Array[] = [];\n          for await (const chunk of stream) {\n            chunks.push(chunk);\n          }\n          return new Uint8Array(Buffer.concat(chunks));\n        }\n        throw e;\n      }\n    } else {\n      // load file into ArrayBuffer in browsers\n      const response = await fetch(file);\n      if (!response.ok) {\n        throw new Error(`failed to load external data file: ${file}`);\n      }\n      const contentLengthHeader = response.headers.get('Content-Length');\n      const fileSize = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;\n      if (fileSize < 1073741824 /* 1GB */) {\n        // when Content-Length header is not set, we cannot determine the file size. We assume it is small enough to\n        // load into memory.\n        return new Uint8Array(await response.arrayBuffer());\n      } else {\n        // file is too large, use stream instead\n        if (!response.body) {\n          throw new Error(`failed to load external data file: ${file}, no response body.`);\n        }\n        const reader = response.body.getReader();\n\n        let buffer;\n        try {\n          // try to create ArrayBuffer directly\n          buffer = new ArrayBuffer(fileSize);\n        } catch (e) {\n          if (e instanceof RangeError) {\n            // use WebAssembly Memory to allocate larger ArrayBuffer\n            const pages = Math.ceil(fileSize / 65536);\n            buffer = new WebAssembly.Memory({initial: pages, maximum: pages}).buffer;\n          } else {\n            throw e;\n          }\n        }\n\n        let offset = 0;\n        // eslint-disable-next-line no-constant-condition\n        while (true) {\n          const {done, value} = await reader.read();\n          if (done) {\n            break;\n          }\n          const chunkSize = value.byteLength;\n          const chunk = new Uint8Array(buffer, offset, chunkSize);\n          chunk.set(value);\n          offset += chunkSize;\n        }\n        return new Uint8Array(buffer, 0, fileSize);\n      }\n    }\n\n  } else if (file instanceof Blob) {\n    return new Uint8Array(await file.arrayBuffer());\n  } else if (file instanceof Uint8Array) {\n    return file;\n  } else {\n    return new Uint8Array(file);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Env} from 'onnxruntime-common';\n\nimport {logLevelStringToEnum} from '../wasm-common';\n\ntype LogLevel = NonNullable<Env['logLevel']>;\ntype MessageString = string;\ntype MessageFunction = () => string;\ntype Message = MessageString|MessageFunction;\n\nconst logLevelPrefix = ['V', 'I', 'W', 'E', 'F'];\n\nconst doLog = (level: number, message: string): void => {\n  // eslint-disable-next-line no-console\n  console.log(`[${logLevelPrefix[level]},${new Date().toISOString()}]${message}`);\n};\n\nlet configLogLevel: LogLevel|undefined;\nlet debug: boolean|undefined;\n\nexport const configureLogger = ($configLogLevel: LogLevel, $debug: boolean): void => {\n  configLogLevel = $configLogLevel;\n  debug = $debug;\n};\n\n/**\n * A simple logging utility to log messages to the console.\n */\nexport const LOG = (logLevel: LogLevel, msg: Message): void => {\n  const messageLevel = logLevelStringToEnum(logLevel);\n  const configLevel = logLevelStringToEnum(configLogLevel);\n  if (messageLevel >= configLevel) {\n    doLog(messageLevel, typeof msg === 'function' ? msg() : msg);\n  }\n};\n\n/**\n * A simple logging utility to log messages to the console. Only logs when debug is enabled.\n */\nexport const LOG_DEBUG: typeof LOG = (...args: Parameters<typeof LOG>) => {\n  if (debug) {\n    LOG(...args);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Tensor} from 'onnxruntime-common';\n\nimport {tensorTypeToTypedArrayConstructor} from '../wasm-common';\n\nexport const createView = (dataBuffer: ArrayBuffer, type: Tensor.Type): Int32Array|Uint32Array|BigInt64Array|\n    BigUint64Array|Uint8Array|Float32Array|Float64Array|Int8Array|Int16Array|Uint16Array =>\n        new (tensorTypeToTypedArrayConstructor(type))(dataBuffer);\n\n/**\n * a TensorView does not own the data.\n */\nexport interface TensorView {\n  readonly data: number;\n  readonly dataType: number;\n  readonly dims: readonly number[];\n\n  /**\n   * get a Float32Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getFloat32Array(): Float32Array;\n\n  /**\n   * get a BigInt64Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getBigInt64Array(): BigInt64Array;\n\n  /**\n   * get a Int32Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getInt32Array(): Int32Array;\n\n  /**\n   * create a new tensor view with the same data but different dimensions.\n   */\n  reshape(newDims: readonly number[]): TensorView;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../wasm-common';\nimport {TensorView} from '../tensor-view';\n\nimport {ShaderHelper} from './ops/common';\n\nexport type SessionState = 'default'|'capturing'|'replaying';\n\nexport enum GpuDataType {\n  default = 0,\n  upload = 1,\n  profile = 2\n}\nexport type GpuDataId = number;\n\nexport type GpuArchitecture = 'ampere';\nexport type GpuVendor = 'amd'|'intel'|'nvidia';\nexport interface AdapterInfo {\n  isArchitecture: (architecture: GpuArchitecture) => boolean;\n  isVendor: (vendor: GpuVendor) => boolean;\n}\n\nexport interface GpuData {\n  type: GpuDataType;\n  id: GpuDataId;\n  buffer: GPUBuffer;\n}\n\nexport interface TensorInfo {\n  dims: readonly number[];\n  dataType: number;\n}\n\nexport interface ProgramUniform {\n  type: DataType;\n  data: number|readonly number[];\n}\n\nexport type ProgramUniformVariableInfo = [type: DataType, length: number];\n\n/**\n * Represent the dependency of a program on a specific input tensor.\n *\n * - 'none': the shader/uniform does not depend on this input's info\n * - 'type': the shader/uniform depends on data type of this input\n * - 'rank': the shader/uniform depends on data type and the rank of this input\n * - 'dims': the shader/uniform depends on data type and the dims of this input\n * - 'data': the shader/uniform depends on data type, the dims and the data of this input\n */\nexport type ProgramInputTensorInfoDependency = 'none'|'type'|'rank'|'dims'|'data';\n\n/**\n * Represent information about a program's cache for shader.\n */\nexport interface ProgramShaderCacheInfo {\n  /**\n   * an optional string as a cache hint in the artifact cache. If this is not specified, the cache hint will be empty.\n   *\n   * This hint string should only contains initializing-time information, such as the attributes or any information of\n   * initializers. It should NOT contain any runtime information, such as the shape of inputs.\n   */\n  hint?: string;\n\n  /**\n   * an optional list of dependencies of the program on the input tensors. If this is not specified, the program depends\n   * on 'dims' of all inputs.\n   */\n  inputDependencies?: ProgramInputTensorInfoDependency[];\n}\n\n/**\n * Represent information about a program's cache for uniform.\n */\nexport interface ProgramUniformCacheInfo {\n  /**\n   * an optional string as a cache hint in the uniform cache. If this is not specified, the cache hint will be empty.\n   *\n   * This hint string should only contains runtime information, such as the shape of inputs.\n   */\n  hint?: string;\n\n  /**\n   * an optional list of dependencies of the program on the input tensors. If this is not specified, the program depends\n   * on 'none' of all inputs.\n   */\n  inputDependencies?: ProgramInputTensorInfoDependency[];\n}\n\n\n/**\n * A set of data that represent a shader program\n */\nexport interface ProgramInfo {\n  /**\n   * the name of the program. used for debugging and profiling\n   */\n  name: string;\n\n  /**\n   * an optional object describing the cache information of the program shader.\n   *\n   * If this is not specified, assume hint is empty and inputDependencies are ['dims'] for all inputs.\n   */\n  shaderCache?: ProgramShaderCacheInfo;\n\n  /**\n   * the shader's processing source code.\n   *\n   * This function will be called when shader cache missed.\n   */\n  getShaderSource: (shaderHelper: ShaderHelper) => string;\n\n  /**\n   * A function to get run data required to run the program.\n   *\n   * This function will be called every time the program is executed. Should keep this function as simple as possible.\n   */\n  getRunData: (inputs: readonly TensorView[]) => {\n    outputs: readonly TensorInfo[];\n    dispatchGroup: {x: number; y?: number; z?: number};\n    programUniforms?: readonly ProgramUniform[];\n  };\n}\n\nexport interface Artifact {\n  programInfo: ProgramInfo;\n  computePipeline: GPUComputePipeline;\n  uniformVariablesInfo: readonly ProgramUniformVariableInfo[]|undefined;\n}\n\nexport interface ComputeContextInputsOutputsMapping {\n  /**\n   * specify the mapping to the program's inputs. the value can be a number or a tensor view.\n   * - if it's a number, it's the index of the kernel's input\n   * - if it's a tensor view, it's an existing tensor view that will be used as the input\n   *\n   * if inputs is not specified, the mapping will be the kernel's inputs in order.\n   */\n  readonly inputs?: ReadonlyArray<TensorView|number>;\n  /**\n   * specify the mapping to the program's outputs. the value must be a number.\n   * - if it's a non-negative number, it's the index of the kernel's output\n   * - if it's -1, it's an output that will be created as a temporary value. this value will be released after\n   * the kernel is executed.\n   * - if it's -2, it's an output that will be created as a persistent value. this value will be released when the\n   * kernel is released.\n   *\n   * if outputs is not specified, the mapping will be the kernel's outputs in order.\n   */\n  readonly outputs?: readonly number[];\n}\n\n/**\n * A ComputeContext instance carries the states that representing the current running of a kernel.\n */\nexport interface ComputeContext {\n  /**\n   * gpu adapter info\n   */\n  readonly adapterInfo: AdapterInfo;\n\n  /**\n   * stores the pointer to OpKernelContext\n   */\n  readonly opKernelContext: number;\n\n  /**\n   * a list of inputs, each input is an instance of TensorView\n   */\n  readonly inputs: readonly TensorView[];\n\n  /**\n   * a custom data object that can be used to store any data that is needed by the kernel\n   */\n  readonly kernelCustomData: {[key: string]: unknown};\n\n  /**\n   * a buffer that can be used to access custom data created each time the kernel is executed\n   */\n  readonly customDataBuffer: Uint8Array;\n\n  /**\n   * a number of outputs for the node\n   */\n  readonly outputCount: number;\n\n  compute(program: ProgramInfo, inputsOutputsMapping?: ComputeContextInputsOutputsMapping): TensorView[];\n  output(index: number, dims: readonly number[]): number;\n  getMaxComputeWorkgroupSizes(): [number, number, number];\n  getMaxComputeWorkgroupStoragesize(): number;\n}\n\nexport type TimestampQuery = 'none'|'inside-passes'|'at-passes';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {WebGpuBackend} from '../backend-webgpu';\nimport {LOG_DEBUG} from '../log';\n\nimport {GpuData, GpuDataId, GpuDataType} from './types';\n\n/**\n * manages GpuDataId -> GpuBuffer\n */\nexport interface GpuDataManager {\n  /**\n   * copy data from CPU to GPU.\n   */\n  upload(id: GpuDataId, data: Uint8Array): void;\n  /**\n   * copy data from GPU to GPU.\n   */\n  memcpy(sourceId: GpuDataId, destinationId: GpuDataId): void;\n  /**\n   * create new data on GPU.\n   */\n  create(size: number, usage?: number): GpuData;\n  /**\n   * get GPU data by ID.\n   */\n  get(id: GpuDataId): GpuData|undefined;\n  /**\n   * release the data on GPU by ID.\n   *\n   * @return size of the data released\n   */\n  release(id: GpuDataId): number;\n  /**\n   * copy data from GPU to CPU.\n   */\n  download(id: GpuDataId, getTargetBuffer: () => Uint8Array): Promise<void>;\n\n  /**\n   * refresh the buffers that marked for release.\n   *\n   * when release() is called, the buffer is not released immediately. this is because we need to wait for the commands\n   * to be submitted to the GPU. this function is called after the commands are submitted so that the buffers can be\n   * actually released.\n   */\n  refreshPendingBuffers(): void;\n\n  /**\n   * register an external buffer for IO Binding. If the buffer is already registered, return the existing GPU data ID.\n   *\n   * GPU data manager only manages a mapping between the buffer and the GPU data ID. It will not manage the lifecycle of\n   * the external buffer.\n   */\n  registerExternalBuffer(buffer: GPUBuffer, originalSize: number, previousBuffer?: GPUBuffer): number;\n\n  /**\n   * unregister an external buffer for IO Binding.\n   */\n  unregisterExternalBuffer(buffer: GPUBuffer): void;\n\n  /**\n   * destroy all gpu buffers.\n   */\n  dispose(): void;\n\n  /**\n   * release session related data.\n   * @param sessionId - specify the session ID.\n   */\n  onReleaseSession(sessionId: number): void;\n}\n\ninterface StorageCacheValue {\n  gpuData: GpuData;\n  originalSize: number;\n}\n\nconst bucketFreelist: Map<number, number> = new Map([\n  [64, 250],\n  [128, 200],\n  [256, 200],\n  [512, 200],\n  [2048, 230],\n  [4096, 200],\n  [8192, 50],\n  [16384, 50],\n  [32768, 50],\n  [65536, 50],\n  [131072, 50],\n  [262144, 50],\n  [524288, 50],\n  [1048576, 50],\n  [2097152, 30],\n  [4194304, 20],\n  [8388608, 10],\n  [12582912, 10],\n  [16777216, 10],\n  [26214400, 15],\n  [33554432, 22],\n  [44236800, 2],\n  [58982400, 6],\n  // we don't want to cache the bucket sizes below but not caching them\n  // results in some major performance hits for models like sd-turbo.\n  [67108864, 6],\n  [134217728, 6],\n  [167772160, 6],\n]);\n\nconst bucketArr: number[] = [];\n\n/**\n * normalize the buffer size so that it fits the 128-bits (16 bytes) alignment.\n */\nconst calcNormalizedBufferSize = (size: number) => Math.ceil(size / 16) * 16;\n\n/**\n * calculate the buffer size so that it fits into buckets.\n */\nconst calcBucketBufferSize = (size: number) => {\n  for (let idx = 0; idx < bucketArr.length; idx++) {\n    const sizeForBucket = bucketArr[idx];\n    if (size <= sizeForBucket) {\n      return sizeForBucket;\n    }\n  }\n  // not in bucket list -> caller will not cache, round up to 16.\n  return Math.ceil(size / 16) * 16;\n};\n\nlet guid = 1;\nconst createNewGpuDataId = () => guid++;\n\n/**\n * exported standard download function. This function is used by the session to download the data from GPU, and also by\n * factory to create GPU tensors with the capacity of downloading data from GPU.\n *\n * @param backend - the WebGPU backend\n * @param gpuBuffer - the GPU buffer to download\n * @param originalSize - the original size of the data\n * @param getTargetBuffer - optional. If provided, the data will be copied to the target buffer. Otherwise, a new buffer\n * will be created and returned.\n */\nexport const downloadGpuData =\n    async(backend: WebGpuBackend, gpuBuffer: GPUBuffer, originalSize: number, getTargetBuffer?: () => Uint8Array):\n        Promise<Uint8Array> => {\n          const bufferSize = calcNormalizedBufferSize(originalSize);\n          const gpuReadBuffer = backend.device.createBuffer(\n              // eslint-disable-next-line no-bitwise\n              {size: bufferSize, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});\n          try {\n            const commandEncoder = backend.getCommandEncoder();\n            backend.endComputePass();\n            commandEncoder.copyBufferToBuffer(\n                gpuBuffer /* source buffer */, 0 /* source offset */, gpuReadBuffer /* destination buffer */,\n                0 /* destination offset */, bufferSize /* size */\n            );\n            backend.flush();\n\n            await gpuReadBuffer.mapAsync(GPUMapMode.READ);\n\n            const arrayBuffer = gpuReadBuffer.getMappedRange();\n            if (getTargetBuffer) {\n              // if we already have a CPU buffer to accept the data, no need to clone the ArrayBuffer.\n              const targetBuffer = getTargetBuffer();\n              targetBuffer.set(new Uint8Array(arrayBuffer, 0, originalSize));\n              return targetBuffer;\n            } else {\n              // the mapped ArrayBuffer will be released when the GPU buffer is destroyed. Need to clone the\n              // ArrayBuffer.\n              return new Uint8Array(arrayBuffer.slice(0, originalSize));\n            }\n          } finally {\n            gpuReadBuffer.destroy();\n          }\n        };\n\nclass GpuDataManagerImpl implements GpuDataManager {\n  // GPU Data ID => GPU Data ( storage buffer )\n  private storageCache: Map<GpuDataId, StorageCacheValue>;\n\n  // pending buffers for uploading ( data is unmapped )\n  private buffersForUploadingPending: GPUBuffer[];\n  // pending buffers for computing\n  private buffersPending: GPUBuffer[];\n\n  // The reusable storage buffers for computing.\n  private freeBuffers: Map<number, GPUBuffer[]>;\n  // The reusable uniform buffers\n  private freeUniformBuffers: Map<number, GPUBuffer[]>;\n\n  // The external buffers registered users for IO Binding.\n  private externalBuffers: Map<GPUBuffer, GpuDataId>;\n\n  // The pendingBuffers for capture graph.\n  // a SessionID -> GPUBuffer[] mapping.\n  private capturedPendingBuffers: Map<number, GPUBuffer[]>;\n\n  constructor(private backend: WebGpuBackend) {\n    this.storageCache = new Map();\n    this.freeBuffers = new Map();\n    this.freeUniformBuffers = new Map();\n    this.buffersForUploadingPending = [];\n    this.buffersPending = [];\n    this.externalBuffers = new Map();\n    this.capturedPendingBuffers = new Map();\n\n    for (const [key, ] of bucketFreelist) {\n      bucketArr.push(key);\n      this.freeBuffers.set(key, []);\n      this.freeUniformBuffers.set(key, []);\n    }\n  }\n\n  upload(id: GpuDataId, data: Uint8Array): void {\n    const srcArrayBuffer = data.buffer;\n    const srcOffset = data.byteOffset;\n    const srcLength = data.byteLength;\n    const size = calcNormalizedBufferSize(srcLength);\n\n    // get destination gpu buffer\n    const gpuDataCache = this.storageCache.get(id);\n    if (!gpuDataCache) {\n      throw new Error('gpu data for uploading does not exist');\n    }\n    if (gpuDataCache.originalSize !== srcLength) {\n      throw new Error(`inconsistent data size. gpu data size=${gpuDataCache.originalSize}, data size=${srcLength}`);\n    }\n\n    // create gpu buffer\n    const gpuBufferForUploading = this.backend.device.createBuffer(\n        // eslint-disable-next-line no-bitwise\n        {mappedAtCreation: true, size, usage: GPUBufferUsage.MAP_WRITE | GPUBufferUsage.COPY_SRC});\n\n    // copy (upload) data\n    const arrayBuffer = gpuBufferForUploading.getMappedRange();\n    new Uint8Array(arrayBuffer).set(new Uint8Array(srcArrayBuffer, srcOffset, srcLength));\n    gpuBufferForUploading.unmap();\n\n\n    // GPU copy\n    const commandEncoder = this.backend.getCommandEncoder();\n    this.backend.endComputePass();\n    commandEncoder.copyBufferToBuffer(gpuBufferForUploading, 0, gpuDataCache.gpuData.buffer, 0, size);\n\n    LOG_DEBUG('verbose', () => `[WebGPU] GpuDataManager.upload(id=${id})`);\n\n    this.buffersForUploadingPending.push(gpuBufferForUploading);\n  }\n\n  memcpy(sourceId: GpuDataId, destinationId: GpuDataId): void {\n    // get source gpu buffer\n    const sourceGpuDataCache = this.storageCache.get(sourceId);\n    if (!sourceGpuDataCache) {\n      throw new Error('source gpu data for memcpy does not exist');\n    }\n    // get destination gpu buffer\n    const destinationGpuDataCache = this.storageCache.get(destinationId);\n    if (!destinationGpuDataCache) {\n      throw new Error('destination gpu data for memcpy does not exist');\n    }\n    if (sourceGpuDataCache.originalSize !== destinationGpuDataCache.originalSize) {\n      throw new Error('inconsistent source and destination gpu data size');\n    }\n\n    const size = calcNormalizedBufferSize(sourceGpuDataCache.originalSize);\n\n    // GPU copy\n    const commandEncoder = this.backend.getCommandEncoder();\n    this.backend.endComputePass();\n    commandEncoder.copyBufferToBuffer(\n        sourceGpuDataCache.gpuData.buffer, 0, destinationGpuDataCache.gpuData.buffer, 0, size);\n  }\n\n  registerExternalBuffer(buffer: GPUBuffer, originalSize: number, previousBuffer?: GPUBuffer): number {\n    let id: number|undefined;\n    if (previousBuffer) {\n      id = this.externalBuffers.get(previousBuffer);\n      if (id === undefined) {\n        throw new Error('previous buffer is not registered');\n      }\n      if (buffer === previousBuffer) {\n        LOG_DEBUG(\n            'verbose',\n            () => `[WebGPU] GpuDataManager.registerExternalBuffer(size=${originalSize}) => id=${\n                id}, buffer is the same, skip.`);\n        return id;\n      } else if (this.backend.capturedCommandList.has(this.backend.currentSessionId!)) {\n        throw new Error(`Registering a different external buffer under graph capture mode is not supported yet.\n             Please use the previous external buffer!`);\n      }\n      this.externalBuffers.delete(previousBuffer);\n    } else {\n      id = createNewGpuDataId();\n    }\n\n    this.storageCache.set(id, {gpuData: {id, type: GpuDataType.default, buffer}, originalSize});\n    this.externalBuffers.set(buffer, id);\n    LOG_DEBUG(\n        'verbose',\n        () => `[WebGPU] GpuDataManager.registerExternalBuffer(size=${originalSize}) => id=${id}, registered.`);\n    return id;\n  }\n\n  unregisterExternalBuffer(buffer: GPUBuffer): void {\n    const id = this.externalBuffers.get(buffer);\n    if (id !== undefined) {\n      this.storageCache.delete(id);\n      this.externalBuffers.delete(buffer);\n      LOG_DEBUG('verbose', () => `[WebGPU] GpuDataManager.unregisterExternalBuffer() => id=${id}`);\n    }\n  }\n\n  // eslint-disable-next-line no-bitwise\n  create(size: number, usage = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST): GpuData {\n    const bufferSize = calcBucketBufferSize(size);\n\n    let gpuBuffer;\n    // Currently, only storage buffers are reused.\n    // eslint-disable-next-line no-bitwise\n    const isStorage = (usage & GPUBufferUsage.STORAGE) === GPUBufferUsage.STORAGE;\n    // eslint-disable-next-line no-bitwise\n    const isUniform = (usage & GPUBufferUsage.UNIFORM) === GPUBufferUsage.UNIFORM;\n    if (isStorage || isUniform) {\n      const freeBuffers = isStorage ? this.freeBuffers : this.freeUniformBuffers;\n      const buffers = freeBuffers.get(bufferSize);\n      if (!buffers) {\n        // no such bucket/freelist - create gpu buffer\n        gpuBuffer = this.backend.device.createBuffer({size: bufferSize, usage});\n      } else {\n        if (buffers.length > 0) {\n          // in freelist, use it\n          gpuBuffer = buffers.pop() as GPUBuffer;\n        } else {\n          // bucket empty, create gpu buffer\n          gpuBuffer = this.backend.device.createBuffer({size: bufferSize, usage});\n        }\n      }\n    } else {\n      // create gpu buffer\n      gpuBuffer = this.backend.device.createBuffer({size: bufferSize, usage});\n    }\n\n    const gpuData = {id: createNewGpuDataId(), type: GpuDataType.default, buffer: gpuBuffer};\n    this.storageCache.set(gpuData.id, {gpuData, originalSize: size});\n\n    LOG_DEBUG('verbose', () => `[WebGPU] GpuDataManager.create(size=${size}) => id=${gpuData.id}`);\n    return gpuData;\n  }\n\n  get(id: GpuDataId): GpuData|undefined {\n    return this.storageCache.get(id)?.gpuData;\n  }\n\n  release(id: GpuDataId): number {\n    const cachedData = this.storageCache.get(id);\n    if (!cachedData) {\n      throw new Error('releasing data does not exist');\n    }\n\n    LOG_DEBUG('verbose', () => `[WebGPU] GpuDataManager.release(id=${id}), gpuDataId=${cachedData.gpuData.id}`);\n\n    this.storageCache.delete(id);\n    this.buffersPending.push(cachedData.gpuData.buffer);\n    // cachedData.gpuData.buffer.destroy();\n\n    return cachedData.originalSize;\n  }\n\n  async download(id: GpuDataId, getTargetBuffer: () => Uint8Array): Promise<void> {\n    const cachedData = this.storageCache.get(id);\n    if (!cachedData) {\n      throw new Error('data does not exist');\n    }\n    await downloadGpuData(this.backend, cachedData.gpuData.buffer, cachedData.originalSize, getTargetBuffer);\n  }\n\n  refreshPendingBuffers(): void {\n    for (const buffer of this.buffersForUploadingPending) {\n      // upload buffer is only useful in the session creation time. So we don't need to reuse them in session running.\n      buffer.destroy();\n    }\n    this.buffersForUploadingPending = [];\n\n    if (this.buffersPending.length === 0) {\n      return;\n    }\n\n    if (this.backend.sessionStatus === 'default') {\n      for (const buffer of this.buffersPending) {\n        const maxInFreeList = bucketFreelist.get(buffer.size);\n\n        // eslint-disable-next-line no-bitwise\n        if ((buffer.usage & GPUBufferUsage.STORAGE) === GPUBufferUsage.STORAGE) {\n          // Put the pending buffer to freeBuffers list instead of really destroying it for buffer reusing.\n          const freelist = this.freeBuffers.get(buffer.size) || [];\n          if (maxInFreeList === undefined || freelist.length >= maxInFreeList) {\n            buffer.destroy();\n          } else {\n            freelist.push(buffer);\n          }\n          // eslint-disable-next-line no-bitwise\n        } else if ((buffer.usage & GPUBufferUsage.UNIFORM) === GPUBufferUsage.UNIFORM) {\n          // Put the pending buffer to freeUniformBuffers list instead of really destroying it for buffer reusing.\n          const freelist = this.freeUniformBuffers.get(buffer.size) || [];\n          if (maxInFreeList === undefined || freelist.length >= maxInFreeList) {\n            buffer.destroy();\n          } else {\n            freelist.push(buffer);\n          }\n        } else {\n          buffer.destroy();\n        }\n      }\n      this.buffersPending = [];\n    } else {\n      // Don't release intermediate tensors in non-default mode.\n      // TODO: reuse the storage buffers in non-default mode.\n      let capturedBuffers = this.capturedPendingBuffers.get(this.backend.currentSessionId!);\n      if (!capturedBuffers) {\n        capturedBuffers = [];\n        this.capturedPendingBuffers.set(this.backend.currentSessionId!, capturedBuffers);\n      }\n      for (const buffer of this.buffersPending) {\n        capturedBuffers.push(buffer);\n      }\n      this.buffersPending = [];\n    }\n  }\n\n  dispose() {\n    this.freeBuffers.forEach((buffers) => {\n      buffers.forEach(buffer => {\n        buffer.destroy();\n      });\n    });\n    this.freeUniformBuffers.forEach((buffers) => {\n      buffers.forEach(buffer => {\n        buffer.destroy();\n      });\n    });\n\n    this.storageCache.forEach((storage) => {\n      storage.gpuData.buffer.destroy();\n    });\n\n    this.capturedPendingBuffers.forEach((buffers) => {\n      buffers.forEach(buffer => {\n        buffer.destroy();\n      });\n    });\n    this.storageCache = new Map();\n    this.freeBuffers = new Map();\n    this.freeUniformBuffers = new Map();\n    this.capturedPendingBuffers = new Map();\n  }\n\n  onReleaseSession(sessionId: number) {\n    // release the captured pending buffers.\n    const pendingBuffers = this.capturedPendingBuffers.get(sessionId);\n    if (pendingBuffers) {\n      pendingBuffers.forEach(buffer => {\n        buffer.destroy();\n      });\n      this.capturedPendingBuffers.delete(sessionId);\n    }\n  }\n}\n\nexport const createGpuDataManager = (...args: ConstructorParameters<typeof GpuDataManagerImpl>): GpuDataManager =>\n    new GpuDataManagerImpl(...args);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nclass AttributeWithCacheKeyImpl {\n  constructor(attribute: Record<string, unknown>) {\n    Object.assign(this, attribute);\n  }\n\n  private key: string;\n  public get cacheKey(): string {\n    if (!this.key) {\n      this.key =\n          Object.getOwnPropertyNames(this).sort().map(name => `${(this as Record<string, unknown>)[name]}`).join(';');\n    }\n    return this.key;\n  }\n}\n\nexport interface AttributeWithCacheKey {\n  readonly cacheKey: string;\n}\n\n/**\n * create a new object from the given attribute, and add a cacheKey property to it\n */\nexport const createAttributeWithCacheKey = <T extends Record<string, unknown>>(attribute: T): T&AttributeWithCacheKey =>\n    new AttributeWithCacheKeyImpl(attribute) as unknown as T & AttributeWithCacheKey;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/* eslint-disable no-param-reassign */\n\nexport class MatMulUtil {\n  /**\n   * Calculate the expected shape when matrix multiplication\n   * @param a The shape of tensor A. Should be a tuple of 2 positive integers\n   * @param b The shape of tensor B. Should be a tuple of 2 positive integers\n   * @returns The expected shape of the result, or undefined if N/A\n   */\n  static calcMatMulShape(a: [number, number], b: [number, number]): [number, number]|undefined {\n    return (a[1] !== b[0]) ? undefined : [a[0], b[1]];\n  }\n}\n\n\nexport class BroadcastUtil {\n  /**\n   * Calculate the expected shape when broadcasting 2 tensors\n   * @param a The shape of tensor A. Should be an array of positive integers\n   * @param b The shape of tensor B. Should be an array of positive integers\n   * @param isMatMul Whether the operation is MatMul\n   * @returns The expected shape of the result, or undefined if N/A\n   */\n  static calcShape(adims: readonly number[], bdims: readonly number[], isMatMul = false): readonly number[]|undefined {\n    const arank = adims.length;\n    const brank = bdims.length;\n    if (arank === 0) {\n      return bdims;\n    }\n    if (brank === 0) {\n      return adims;\n    }\n    const crank = Math.max(adims.length, bdims.length);\n    const cdims = new Array<number>(crank);\n\n    // calculate the last 2 dimension if it is MatMul\n    if (isMatMul) {\n      if (arank < 2 || brank < 2) {\n        return undefined;\n      }\n      const cShapeMatMul =\n          MatMulUtil.calcMatMulShape([adims[arank - 2], adims[arank - 1]], [bdims[brank - 2], bdims[brank - 1]]);\n      if (cShapeMatMul === undefined) {\n        return undefined;\n      }\n      [cdims[crank - 2], cdims[crank - 1]] = cShapeMatMul;\n    }\n\n    for (let i = isMatMul ? 3 : 1; i <= crank; i++) {\n      const aLen = arank - i < 0 ? 1 : adims[arank - i];\n      const bLen = brank - i < 0 ? 1 : bdims[brank - i];\n\n      if (aLen !== bLen && aLen > 1 && bLen > 1) {\n        return undefined;\n      }\n      const max = Math.max(aLen, bLen);\n      if (aLen && bLen) {\n        cdims[crank - i] = Math.max(aLen, bLen);\n      } else {\n        // when either aLen or bLen is 0, the other should be either 0 or 1, otherwise it is not broadcastable.\n        if (max > 1) {\n          return undefined;\n        }\n        cdims[crank - i] = 0;\n      }\n    }\n\n    return cdims;\n  }\n\n  /**\n   * Determine if a shape is unidirectional broadcastable to another shape\n   * @param shape The input shape\n   * @param finalShape The desired shape after broadcasting\n   */\n  static isValidBroadcast(shape: readonly number[], finalShape: readonly number[]): boolean {\n    // align shape to the right\n    const inputRank = shape.length;\n    const finalRank = finalShape.length;\n    if (inputRank > finalRank) {\n      return false;\n    }\n    for (let i = 1; i <= inputRank; i++) {\n      if (shape[inputRank - i] !== 1 && shape[inputRank - i] !== finalShape[finalRank - i]) {\n        return false;\n      }\n    }\n    return true;\n  }\n}\n\n\nexport class ShapeUtil {\n  /**\n   * calculate the size (number of elements)\n   */\n  static size(dims: readonly number[]): number {\n    return ShapeUtil.getSizeFromDimensionRange(dims, 0, dims.length);\n  }\n\n  /**\n   * convert dims corresponding to type change to pack. ex. uint8 data to uint32\n   */\n  static convertShape(dims: readonly number[], size = 4): readonly number[] {\n    const rank = dims.length;\n    if (rank === 0) {\n      return [];\n    }\n    const newDims = new Array(rank);\n    let i = rank - 1;\n    while (i >= 0) {\n      if (dims[i] % size === 0) {\n        newDims[i] = dims[i] / size;\n        break;\n      }\n      if (size % dims[i] !== 0) {\n        throw new Error('cannot convert shape');\n      }\n      newDims[i] = 1;\n      size /= dims[i];\n      i--;\n    }\n    for (i--; i >= 0; i--) {\n      newDims[i] = dims[i];\n    }\n    return newDims;\n  }\n\n  /**\n   * calculate the size (number of elements) from the given axis (inclusive)\n   */\n  static sizeFromDimension(dims: readonly number[], axis: number): number {\n    if (axis < 0 || axis > dims.length) {\n      throw new Error(`invalid dimension of ${axis} for sizeFromDimension as Tensor has ${dims.length} dimensions.`);\n    }\n    return ShapeUtil.getSizeFromDimensionRange(dims, axis, dims.length);\n  }\n\n  /**\n   * calculate the size (number of elements) to the given axis (exclusive)\n   */\n  static sizeToDimension(dims: readonly number[], axis: number): number {\n    if (axis < 0 || axis > dims.length) {\n      throw new Error(`invalid dimension of ${axis} for sizeToDimension as Tensor has ${dims.length} dimensions.`);\n    }\n    return ShapeUtil.getSizeFromDimensionRange(dims, 0, axis);\n  }\n\n  /**\n   * calculate the size (number of elements) from and to the given axis [start, end)\n   */\n  static getSizeFromDimensionRange(dims: readonly number[], start: number, end: number): number {\n    let size = 1;\n    for (let i = start; i < end; i++) {\n      // safety check as this method is called by multiple other methods requiring size.\n      // size cannot be negative.\n      if (dims[i] < 0) {\n        throw new Error(\n            // eslint-disable-next-line max-len\n            'cannot get valid size from specified dimension range. Most likely the range contains negative values in them.');\n      }\n      size *= dims[i];\n    }\n    return size;\n  }\n\n  static computeStrides(dims: readonly number[]): readonly number[] {\n    const rank = dims.length;\n    if (rank === 0) {\n      return [];\n    } else if (rank === 1) {\n      return [1];\n    }\n    const strides = new Array(rank);\n    strides[rank - 1] = 1;\n    strides[rank - 2] = dims[rank - 1];\n    for (let i = rank - 3; i >= 0; --i) {\n      strides[i] = strides[i + 1] * dims[i + 1];\n    }\n    return strides;\n  }\n\n  /**\n   * normailze axis of range [-r, r) into [0, r).\n   */\n  static normalizeAxis(axis: number, tensorRank: number): number {\n    if (axis < -tensorRank && axis >= tensorRank) {\n      throw new Error('unsupported axis for this operation.');\n    }\n    return axis < 0 ? axis + tensorRank : axis;\n  }\n\n  static normalizeAxes(axes: readonly number[], tensorRank?: number): number[] {\n    return axes.map(x => this.normalizeAxis(x, tensorRank ?? axes.length));\n  }\n\n  /**\n   * Sorts a given array based on the indices in the Perm array\n   * Used in Transpose\n   * @param a Array to be sorted such as dims or strides\n   * @param perm Perm given; if null a will be reversed\n   */\n  static sortBasedOnPerm(a: readonly number[], perm?: readonly number[]): readonly number[] {\n    if (perm) {\n      return perm.map((v) => a[v]);\n    } else {\n      return a.slice().reverse();\n    }\n  }\n\n  /**\n   * Pads a given shape according to the padding values\n   * @param dims shape of the Tensor to be padded\n   * @param pad pad values\n   */\n  static padShape(dims: readonly number[], pad: readonly number[]): readonly number[] {\n    const rank = dims.length;\n    return dims.map((v, i) => v + pad[i] + pad[i + rank]);\n  }\n\n  /**\n   * Determines if the two shapes are identical\n   * @param shape1\n   * @param shape2\n   */\n  static areEqual(shape1: readonly number[], shape2: readonly number[]): boolean {\n    if (shape1.length !== shape2.length) {\n      return false;\n    }\n    return shape1.every((v, i) => v === shape2[i]);\n  }\n}\n\nexport class PoolConvUtil {\n  /**\n   * Adjust the kernel, strides, pads to correct rank. Set to default value if not present\n   * @param isGlobalOperator If true, perform global pooling.\n   * @param inputDims The input tensor dimension.\n   * @param kernelShape The size of the kernel along each axis.\n   * @param strides Stride along each axis.\n   * @param dilations Dilation along each axis.\n   * @param pads Padding for the beginning and ending along each axis.\n   */\n  static adjustPoolAttributes(\n      isGlobalOperator: boolean, inputDims: readonly number[], kernelShape: number[], strides: number[],\n      dilations: number[], pads: number[]): void {\n    if (!isGlobalOperator && kernelShape.length !== inputDims.length - 2) {\n      throw new Error('length of specified kernel shapes should be 2 less than length of input dimensions');\n    }\n\n    if (isGlobalOperator) {\n      // adjust kernel shape to cover the input dims\n      for (let dim = 0; dim < inputDims.length - 2; dim++) {\n        if (dim >= kernelShape.length) {\n          kernelShape.push(inputDims[dim + 2]);\n        } else {\n          kernelShape[dim] = inputDims[dim + 2];\n        }\n      }\n    }\n\n    // adjust strides length to match kernel shape length\n    for (let dim = 0; dim < kernelShape.length; dim++) {\n      if (dim < strides.length) {\n        if (strides[dim] < 0) {\n          throw new Error('strides should be greater than or equal to 1');\n        }\n      } else {\n        strides.push(1);\n      }\n    }\n\n    // adjust dilation value\n    for (let dim = 0; dim < kernelShape.length; dim++) {\n      if (dim < dilations.length) {\n        if (dilations[dim] < 0) {\n          throw new Error('dilations should be greater than or equal to 1');\n        }\n      } else {\n        dilations.push(1);\n      }\n    }\n\n    // adjust pads length to match 2 * kernel shape length\n    for (let dim = 0; dim < kernelShape.length * 2; dim++) {\n      if (dim < pads.length) {\n        if (pads[dim] < 0) {\n          throw new Error('pad should be greater than or equal to 1');\n        }\n      } else {\n        pads.push(0);\n      }\n    }\n\n    // sanity checks for values in kernel shapes and pads\n    for (let dim = 0; dim < kernelShape.length; dim++) {\n      if (kernelShape[dim] <= 0) {\n        throw new Error('kernel shapes need to be greater than 0');\n      }\n\n      if (pads[dim] >= kernelShape[dim] || pads[dim + kernelShape.length] >= kernelShape[dim]) {\n        throw new Error('pads should be smaller than kernel');\n      }\n    }\n  }\n\n  // adjust pad values based on 'autoPad' attribute\n  static adjustPadsBasedOnAutoPad(\n      inputDims: readonly number[], strides: readonly number[], dilations: readonly number[],\n      kernelShape: readonly number[], pads: number[], isChannelLast: boolean, autoPad?: string): void {\n    if (!autoPad) {\n      return;\n    }\n\n    if (pads.length !== 2 * (inputDims.length - 2)) {\n      throw new Error('length of pads should be twice the length of data dimensions');\n    }\n\n    if (strides.length !== (inputDims.length - 2)) {\n      throw new Error('length of strides should be the length of data dimensions');\n    }\n\n    if (kernelShape.length !== (inputDims.length - 2)) {\n      throw new Error('length of kernel shapes should be the length of data dimensions');\n    }\n\n    for (let dim = 0; dim < inputDims.length - 2; dim++) {\n      PoolConvUtil.adjustPadAndReturnShape(\n          inputDims[dim + (isChannelLast ? 1 : 2)], strides[dim], dilations[dim], kernelShape[dim], pads, dim,\n          dim + inputDims.length - 2, autoPad);\n    }\n  }\n\n  /**\n   * Calculate the output shape for Pool ops based on input attributes. (Should be used only for Pool ops)\n   * @param isGlobalOperator If true, perform global pooling.\n   * @param inputDims The input tensor dimension. (inputs[0].dims)\n   * @param strides Stride along each axis.\n   * @param dilations Dilation along each axis.\n   * @param kernelShape The size of the kernel along each axis.\n   * @param pads Padding for the beginning and ending along each axis.\n   * @param autoPad DEPRECATED attribute supported for legacy models. Specifies how to implicitly calculate pads in each\n   *     dimension. Can take values NOTSET, SAME_UPPER, SAME_LOWER, or VALID.\n   */\n  static computePoolOutputShape(\n      isGlobalOperator: boolean, inputDims: readonly number[], strides: number[], dilations: number[],\n      kernelShape: number[], pads: number[], autoPad?: string): number[] {\n    if (inputDims.length <= 0) {\n      throw new Error('input shape must be of size greater than 0');\n    }\n\n    // Add batch size and number of channels of output\n    const outputDims = [inputDims[0], inputDims[1]];\n\n    PoolConvUtil.computeShapeHelper(\n        isGlobalOperator, inputDims, outputDims, strides, dilations, kernelShape, pads, autoPad);\n    return outputDims;\n  }\n\n  /**\n   * Calculate the output shape for Conv op based on input attributes. (Should be used only for Conv op)\n   * @param inputDims The input tensor dimension. (inputs[0].dims)\n   * @param filterDims The filter tensor dimension. (inputs[1].dims)\n   * @param strides Stride along each axis.\n   * @param kernelShape The size of the kernel along each axis.\n   * @param pads Padding for the beginning and ending along each axis.\n   * @param autoPad DEPRECATED attribute supported for legacy models. Specifies how to implicitly calculate pads in each\n   *     dimension. Can take values NOTSET, SAME_UPPER, SAME_LOWER, or VALID.\n   */\n  static computeConvOutputShape(\n      inputDims: readonly number[], filterDims: readonly number[], strides: number[], dilations: number[],\n      kernelShape: number[], pads: number[], autoPad?: string): number[] {\n    if (inputDims.length <= 0 || filterDims.length <= 0) {\n      throw new Error('invalid input tensor dims or invalid filter tensor dims');\n    }\n\n    // Add batch size and number of channels of output\n    const outputDims = [inputDims[0], filterDims[0]];\n\n    PoolConvUtil.computeShapeHelper(false, inputDims, outputDims, strides, dilations, kernelShape, pads, autoPad);\n    return outputDims;\n  }\n\n  // will compute output shapes for data dimensions ONLY (i.e.) no batch size and channels\n  // called by computePoolOutputShape() and computeConvOutputShape()\n  // adjust pads based on 'autoPad' attribute prior to shape computation\n  private static computeShapeHelper(\n      isGlobalOperator: boolean, inputDims: readonly number[], outputDims: number[], strides: readonly number[],\n      dilations: readonly number[], kernelShape: readonly number[], pads: number[], autoPad?: string) {\n    if (isGlobalOperator) {\n      for (let dim = 0; dim < inputDims.length - 2; dim++) {\n        outputDims.push(1);\n      }\n    } else {\n      for (let dim = 0; dim < inputDims.length - 2; dim++) {\n        outputDims.push(PoolConvUtil.adjustPadAndReturnShape(\n            inputDims[dim + 2], strides[dim], dilations[dim], kernelShape[dim], pads, dim, dim + inputDims.length - 2,\n            autoPad));\n      }\n    }\n  }\n\n  // helper for computeShapeHelper() and adjustPadsBasedOnAutoPad()\n  // adjusts pad value for given 'autoPad' string and computes output shape along a particular dimension\n  private static adjustPadAndReturnShape(\n      inSize: number, stride: number, dilation: number, kernel: number, pads: number[], padHeadIndex: number,\n      padTailIndex: number, autoPad?: string): number {\n    const dkernel = dilation * (kernel - 1) + 1;\n    if (autoPad && autoPad !== 'NOTSET') {\n      switch (autoPad) {\n        case 'VALID':\n          pads[padHeadIndex] = 0;\n          pads[padTailIndex] = 0;\n          return Math.floor(((inSize - dkernel) / stride) + 1);\n        case 'SAME_LOWER':\n        case 'SAME_UPPER':\n          if (dilation !== 1) {\n            throw new Error('Dilation not supported for SAME_UPPER or SAME_LOWER');\n          } else {\n            const legacyTargetSize = (inSize + stride - 1) / stride;\n            const padNeeded = (legacyTargetSize - 1) * stride + kernel - inSize;\n            pads[padHeadIndex] =\n                (autoPad === 'SAME_LOWER') ? Math.floor((padNeeded + 1) / 2) : Math.floor(padNeeded / 2);\n            pads[padTailIndex] = padNeeded - pads[padHeadIndex];\n            return Math.floor(((inSize + padNeeded - kernel) / stride) + 1);\n          }\n        default:\n          throw new Error('Unsupported AutoPad type');\n      }\n    } else {\n      return Math.floor(((inSize + pads[padHeadIndex] + pads[padTailIndex] - dkernel) / stride) + 1);\n    }\n  }\n}\n\nexport class GemmUtil {\n  // will make sure input shapes are compatible for this op\n  // and return back the shape of the output in the form of a tuple\n  // will throw exception if the input shapes are not compatible\n  static getShapeOfGemmResult(\n      leftShape: readonly number[], transLeft: boolean, rightShape: readonly number[], transRight: boolean,\n      biasShape?: readonly number[]): readonly number[] {\n    if (leftShape.length !== 2 || rightShape.length !== 2) {\n      throw new Error('shape need to be of size 2');\n    }\n\n    let M: number;\n    let K: number;\n    let N: number;\n\n    if (transLeft) {\n      M = leftShape[1];\n      K = leftShape[0];\n    } else {\n      M = leftShape[0];\n      K = leftShape[1];\n    }\n\n    let kDim = -1;\n\n    if (transRight) {\n      N = rightShape[0];\n      kDim = 1;\n    } else {\n      N = rightShape[1];\n      kDim = 0;\n    }\n\n    if (rightShape[kDim] !== K) {\n      throw new Error('dimension mismatch');\n    }\n\n    if (M <= 0 || N <= 0 || K <= 0) {\n      throw new Error('invalid shape specified');\n    }\n\n    if (biasShape && !BroadcastUtil.isValidBroadcast(biasShape, [M, N])) {\n      throw new Error('gemm: invalid bias shape for broadcast');\n    }\n\n    return [M, N, K];\n  }\n}\n\n\nexport const MIN_CLIP = -3.4028234663852886e+38;\nexport const MAX_CLIP = 3.4028234663852886e+38;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {ShapeUtil} from '../../util';\nimport {ProgramUniform, ProgramUniformVariableInfo} from '../types';\n\n/**\n * constant value for a workgroup size.\n *\n * We definitely can do further optimization in future, but for now we use 64.\n *\n * rule of thumb: Use [a workgroup size of] 64 unless you know what GPU you are targeting or that your workload\n *                needs something different.\n *\n * from: https://surma.dev/things/webgpu/\n **/\nexport const WORKGROUP_SIZE = 64;\n\ninterface IndicesHelperTypes {\n  /**\n   * WGSL type of indices expression\n   */\n  readonly indices: string;\n\n  /**\n   * WGSL type of a value\n   */\n  readonly value: string;\n\n  /**\n   * WGSL type of storage type representing a value\n   *\n   * This is usually the same to `value`, but for some type (eg. bool), we need to use `u32` as storage type for\n   * value type `vec4<bool>`\n   */\n  readonly storage: string;\n\n  /**\n   * tensor type as represented in TensorView\n   */\n  readonly tensor: number;\n}\n\n/**\n * A helper class for generating WGSL code for manipulating indices and data for a shader's input or output.\n *\n * This class is designed to offer a unified way to generate WGSL code for manipulating indices and data for a shader's\n * input or output.\n *\n * The following is a list of terminologies used in this class:\n * - `offset`: a uint32 value representing the offset of an element in the data buffer.\n * - `indices`: an abstraction of a multi-dimensional array's indices representing the data's index on each dimension.\n * - `value`: a value of a data element.\n *\n * Users are expected to create an instance of this class for each shader's input or output, and use the instance to\n * generate WGSL code for manipulating indices and data. The following 2 exported functions are for users to call to\n * create an instance of an indices helper:\n * - `inputVariable()`: create an indices helper instance for an input.\n * - `outputVariable()`: create an indices helper instance for an output.\n * - `internalVariable()`: create an indices helper instance for an internal variable.\n *\n * An indices helper instance contains helper functions for the following operations:\n * - access readonly basic information, including: `name`(the name of the input or output), `usage`(whether it's an\n * input, an output or an internal variable) and `shape`(the passed in shape).\n * - `type`: access readonly type information, including: `indices`(the type of indices), `value`(the type of value at\n * runtime), `storage`(the type of value at storage) and `tensor`(the tensor type as represented in TensorView).\n * - generate WGSL code for getting indices from offset. Use `offsetToIndices()` for WGSL code snippet to calculate\n * indices from offset, and use `indicesToOffset()` for WGSL code snippet to calculate offset from indices.\n * - to manipulate an instance of indices, use `setIndices()` and `getIndices()` to set and get the indices on an\n * indices variable.\n * - to manipulate data, use `set()`/`get()` to access data at the given indices from parameter list, use\n * `setByIndices()`/`getByIndices()` to access data at the given indices from an indices variable, and use\n * `setByOffset()`/`getByOffset()` to access data at the given offset.\n * - `impl`: get WGSL code of function implementation for the util functions mentioned above.\n */\nexport interface IndicesHelper {\n  /**\n   * get WGSL code of function implementation for the util functions.\n   *\n   */\n  readonly impl: () => string;\n\n  /**\n   * get type info\n   */\n  readonly type: IndicesHelperTypes;\n\n  /**\n   * WGSL code of a expression for getting indices from offset.\n   *\n   * @param varOffset - a u32 expression representing the offset.\n   *\n   * @returns an `type.indices` expression\n   */\n  readonly offsetToIndices: (varOffset: string) => string;\n\n  /**\n   * WGSL code of an `u32` expression for getting offset from indices.\n   *\n   * @param varIndices - a `type.indices` expression representing the indices.\n   *\n   * @returns an `u32` expression\n   */\n  readonly indicesToOffset: (varIndices: string) => string;\n\n  /**\n   * WGSL code of an `u32` expression for getting original offset from broadcasted indices.\n   *\n   * @param varIndices - a `type.indices` expression representing the output indices.\n   * @param output - output IndicesHelper.\n   *\n   * @returns an `u32` expression\n   */\n  readonly broadcastedIndicesToOffset: (varIndices: string, output: IndicesHelper) => string;\n\n  /**\n   * WGSL code of generating an indices literal\n   *\n   * @param init - initial value.\n   */\n  readonly indices: (...init: ReadonlyArray<number|string>) => string;\n\n  /**\n   * WGSL code of a statement for setting indices.\n   *\n   * @param varIndices - a variable name for the indices.\n   * @param idx - the index of the indices to set. can be a number or a string (WGSL `u32` expression).\n   * @param value - the value to set. can be a number or a string (WGSL `u32` expression).\n   *\n   * @returns a WGSL statement\n   */\n  readonly indicesSet: (varIndices: string, idx: number|string, value: number|string) => void;\n\n  /**\n   * WGSL code of an `u32` expression for getting indices.\n   *\n   * @param varIndices - a variable name for the indices.\n   * @param idx - the index of the indices to get. can be a number or a string (WGSL `u32` expression).\n   *\n   * @returns an `u32` expression\n   */\n  readonly indicesGet: (varIndices: string, idx: number|string) => string;\n\n  /**\n   * WGSL code for a statement for setting data at the given indices.\n   *\n   * @param indicesAndValue - an array of numbers or strings (WGSL `u32` expression) representing the indices, followed\n   *     by the value to set. This array should have exactly `shape.length + 1` elements.\n   */\n  readonly set: (...indicesAndValue: ReadonlyArray<number|string>) => string;\n\n  /**\n   * WGSL code for a statement for setting data at the given indices variable.\n   *\n   * @param varIndices - a variable name for the indices.\n   * @param value - the value to set. should be a WGSL expression.\n   */\n  readonly setByIndices: (varIndices: string, value: string) => string;\n\n  /**\n   * WGSL code for a statement for setting data at the given offset.\n   *\n   * @param offset - a number or a string (WGSL `u32` expression) representing the offset.\n   * @param value - the value to set. should be a WGSL expression.\n   */\n  readonly setByOffset: (offset: number|string, value: string) => string;\n\n  /**\n   * WGSL code for an expression for getting data at the given indices.\n   *\n   * @param indices - an array of numbers or strings (WGSL `u32` expression) representing the indices.\n   */\n  readonly get: (...indices: ReadonlyArray<number|string>) => string;\n\n  /**\n   * WGSL code for an expression for getting data at the given indices variable.\n   *\n   * @param varIndices - a variable name for the indices.\n   */\n  readonly getByIndices: (varIndices: string) => string;\n\n  /**\n   * WGSL code for an expression for getting data at the given offset.\n   *\n   * @param offset - a number or a string (WGSL `u32` expression) representing the offset.\n   */\n  readonly getByOffset: (offset: number|string) => string;\n\n  /**\n   * name of the data variable\n   */\n  readonly name: string;\n\n  /**\n   * whether the helper is for an input, an output or an internal variable.\n   */\n  readonly usage: 'input'|'output'|'internal';\n\n  /**\n   * the rank of the input or output.\n   */\n  readonly rank: number;\n\n  /**\n   * a string representing the variable name for the shape of the input or output.\n   */\n  readonly shape: string;\n\n  /**\n   * a string representing the variable name for the strides of the input or output.\n   */\n  readonly strides: string;\n}\n\nconst getWgslMappedType = (type: number, components: 1|2|3|4): string|[string, string] => {\n  if (components === 3) {\n    throw new Error('vec3 has same alignment as vec4, use vec4 instead');\n  }\n\n  // return type is [ storage type, runtime type ] or a single string for both\n  switch (type) {\n    case DataType.float16:\n      return components > 1 ? `vec${components}<f16>` : 'f16';\n    case DataType.float:\n      return components > 1 ? `vec${components}<f32>` : 'f32';\n    case DataType.int32:\n      return components > 1 ? `vec${components}<i32>` : 'i32';\n    case DataType.uint32:\n      return components > 1 ? `vec${components}<u32>` : 'u32';\n    case DataType.int64:\n      if (components > 1) {\n        throw new Error('currently not supported vecX of uint64 yet');\n      }\n      return ['vec2<u32>', 'i32'];\n    case DataType.uint64:\n      if (components > 1) {\n        throw new Error('currently not supported vecX of uint64 yet');\n      }\n      return ['vec2<u32>', 'u32'];\n    case DataType.bool:\n      if (components !== 4) {\n        throw new Error('bool must be vec4');\n      }\n      return ['u32', 'vec4<bool>'];\n\n    default:\n      throw new Error(`Unknown data type: ${type}`);\n  }\n};\n\nexport const tensorTypeToWsglStorageType = (type: DataType, components: 1|2|3|4 = 1) => {\n  const mappedType = getWgslMappedType(type, components);\n  return typeof mappedType === 'string' ? mappedType : mappedType[0];\n};\n\nexport const tensorTypeToWsglValueType = (type: DataType, components: 1|2|3|4 = 1) => {\n  const mappedType = getWgslMappedType(type, components);\n  return typeof mappedType === 'string' ? mappedType : mappedType[1];\n};\n\nexport const createTensorShapeVariables = (...dims: ReadonlyArray<readonly number[]>): ProgramUniform[] => {\n  const programUniforms: ProgramUniform[] = [];\n  dims.forEach(dim => {\n    if (dim.length !== 0) {\n      programUniforms.push(\n          {type: DataType.uint32, data: dim}, {type: DataType.uint32, data: ShapeUtil.computeStrides(dim)});\n    }\n  });\n  return programUniforms;\n};\n\n/**\n * A helper function to get maximum vector size for specified data length\n * @param size\n */\nexport const getMaxComponents = (size: number) => {\n  // we cannot use vec3 type since it has alignment of 16 bytes\n  if (size % 4 === 0) {\n    return 4;\n  } else if (size % 2 === 0) {\n    return 2;\n  }\n\n  return 1;\n};\n\n/**\n * A helper function that initializes variable as a scalar or vector. e.g. f32(0) or vec4f(0,0,0,0)\n * @param dataType\n * @param components\n * @param value\n */\nexport const fillVector = (dataType = 'f32', components?: number, value = '0') => {\n  if (!components || components === 1) {\n    return `${dataType}(${value})`;\n  }\n\n  return `vec${components}<${dataType}>(${value})`;\n};\n\n/**\n * A helper function that casts value or vector to f32\n * @param dataType\n * @param components\n * @param value\n */\nexport const castToF32 = (dataType: string, components: number, value: string) => {\n  if (dataType === 'f32') {\n    return value;\n  }\n  if (components === 1) {\n    return `f32(${value})`;\n  }\n\n  return `vec${components}<f32>(${value})`;\n};\n\n/**\n * A helper function that returns scalar or sums all components of a vector\n * @param name\n * @param components\n */\nexport const sumVector = (name: string, components: number) => {\n  if (components === 4) {\n    return `(${name}.x + ${name}.y + ${name}.z + ${name}.w)`;\n  } else if (components === 2) {\n    return `(${name}.x + ${name}.y)`;\n  } else if (components === 3) {\n    return `(${name}.x + ${name}.y + ${name}.z)`;\n  }\n\n  return name;\n};\n\n/**\n * A helper function that returns variable element at index.\n * @param name - the name of variable.\n * @param index - the index of variable element.\n * @param length - the length of variable.\n * @param type - the type of variable, optional.\n */\nexport const getElementAt =\n    (name: string, index: number|string, length: number, type?: UniformDataElementType): string => {\n      if (name.startsWith('uniforms.') && length > 4) {\n        if (typeof (index) === 'string') {\n          if (type === 'f16') {\n            return `${name}[(${index}) / 8][(${index}) % 8 / 4][(${index}) % 8 % 4]`;\n          } else {\n            return `${name}[(${index}) / 4][(${index}) % 4]`;\n          }\n        } else {\n          if (type === 'f16') {\n            return `${name}[${Math.floor(index / 8)}][${Math.floor(index % 8 / 4)}][${index % 8 % 4}]`;\n          } else {\n            return `${name}[${Math.floor(index / 4)}][${index % 4}]`;\n          }\n        }\n      } else {\n        return length > 1 ? `${name}[${index}]` : name;\n      }\n    };\n\n/**\n * A helper function to get a IndicesHelper for a given input or output.\n *\n * @param name - the name of the input or output.\n * @param tensorType - the tensor type of the input or output.\n * @param shapeOrRank - the tensor shape or the rank of the input or output.\n * @param usage - the usage of the indices helper.\n * @param components - indicates the number of components of each element. 1 for scalar, 2 for vec2, 3 for vec3, 4 for\n *    vec4.\n */\nconst createIndicesHelper =\n    (name: string, tensorType: number, shapeOrRank: number|readonly number[], usage: IndicesHelper['usage'],\n     components: 1|2|3|4): IndicesHelper => {\n      const useUniform = typeof shapeOrRank === 'number';\n      const rank = useUniform ? shapeOrRank : shapeOrRank.length;\n      const rankIdentity = [...new Array(rank).keys()];\n      const indicesType = rank < 2 ? 'u32' : rank <= 4 ? `vec${rank}<u32>` : `array<u32, ${rank}>`;\n      const mappedType = getWgslMappedType(tensorType, components);\n      const valueType = typeof mappedType === 'string' ? mappedType : mappedType[1];\n      const storageType = typeof mappedType === 'string' ? mappedType : mappedType[0];\n      const type = {indices: indicesType, value: valueType, storage: storageType, tensor: tensorType};\n\n      const normalizeDim = (dim: number|string): string => typeof dim === 'string' ? dim : `${dim}u`;\n\n      const implementationUsed = {\n        offsetToIndices: false,\n        indicesToOffset: false,\n        broadcastedIndicesToOffset: false,\n        set: false,\n        setByIndices: false,\n        get: false,\n        getByIndices: false,\n      };\n\n      const uniformPrefix = useUniform ? 'uniforms.' : '';\n      const shape = `${uniformPrefix}${name}_shape`;\n      const strides = `${uniformPrefix}${name}_strides`;\n\n      let o2iSnippet = '';\n      for (let i = 0; i < rank - 1; i++) {\n        o2iSnippet += `\n    let dim${i} = current / ${getElementAt(strides, i, rank)};\n    let rest${i} = current % ${getElementAt(strides, i, rank)};\n    indices[${i}] = dim${i};\n    current = rest${i};\n    `;\n      }\n      o2iSnippet += `indices[${rank - 1}] = current;`;\n\n      const offsetToIndicesImplementation = rank < 2 ? '' : `\n  fn o2i_${name}(offset: u32) -> ${type.indices} {\n    var indices: ${type.indices};\n    var current = offset;\n    ${o2iSnippet}\n    return indices;\n  }`;\n\n      const offsetToIndices = (varOffset: string) => {\n        implementationUsed.offsetToIndices = true;\n        return rank < 2 ? varOffset : `o2i_${name}(${varOffset})`;\n      };\n\n      const offsets: string[] = [];\n      if (rank >= 2) {\n        for (let i = rank - 1; i >= 0; i--) {\n          offsets.push(`${getElementAt(strides, i, rank)} * (indices[${i}])`);\n        }\n      }\n\n      const indicesToOffsetImplementation = rank < 2 ? '' : `\n  fn i2o_${name}(indices: ${type.indices}) -> u32 {\n    return ${offsets.join('+')};\n  }`;\n\n      const indicesToOffset = (varIndices: string) => {\n        implementationUsed.indicesToOffset = true;\n        return rank < 2 ? varIndices : `i2o_${name}(${varIndices})`;\n      };\n\n      const indices = (...init: ReadonlyArray<number|string>) =>\n          rank === 0 ? '0u' : `${type.indices}(${init.map(normalizeDim).join(',')})`;\n\n      const indicesGet = (varIndices: string, idx: number|string) => {\n        if (rank < 2) {\n          return `${varIndices}`;\n        } else {\n          return `${getElementAt(varIndices, idx, rank)}`;\n        }\n      };\n\n      const indicesSet = (varIndices: string, idx: number|string, value: string) => {\n        if (rank < 2) {\n          return `${varIndices}=${value};`;\n        } else {\n          return `${getElementAt(varIndices, idx, rank)}=${value};`;\n        }\n      };\n\n      const broadcastedIndicesToOffsetImplementation: {[key: string]: string} = {};\n      const broadcastedIndicesToOffset = (varIndices: string, output: IndicesHelper) => {\n        implementationUsed.broadcastedIndicesToOffset = true;\n        const implKey = `${output.name}broadcastedIndicesTo${name}Offset`;\n        if (implKey in broadcastedIndicesToOffsetImplementation) {\n          return `${implKey}(${varIndices})`;\n        }\n        const offsets = [];\n        for (let i = rank - 1; i >= 0; i--) {\n          const idx = output.indicesGet('outputIndices', i + output.rank - rank);\n          offsets.push(`${indicesGet(strides, i)} * (${idx} % ${indicesGet(shape, i)})`);\n        }\n        broadcastedIndicesToOffsetImplementation[implKey] =\n            `fn ${implKey}(outputIndices: ${output.type.indices}) -> u32 {\n             return ${offsets.length > 0 ? offsets.join('+') : '0u'};\n           }`;\n\n        return `${implKey}(${varIndices})`;\n      };\n\n      const setByOffset = (offset: number|string, value: string) => (() => {\n        if (type.storage === type.value) {\n          return `${name}[${offset}]=${value};`;\n        } else if (type.storage === 'vec2<u32>' && type.value === 'i32') {\n          // int64, components === 1\n          return `${name}[${offset}]=vec2<u32>(u32(${value}), select(0u, 0xFFFFFFFFu, ${value} < 0));`;\n        } else if (type.storage === 'vec2<u32>' && type.value === 'u32') {\n          // uint64, components === 1\n          return `${name}[${offset}]=vec2<u32>(u32(${value}), 0u);`;\n        } else if (type.storage === 'u32' && type.value === 'vec4<bool>') {\n          // bool, components === 4\n          return `${name}[${offset}]=dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(${value}));`;\n        } else {\n          throw new Error(`not supported combination of storage type ${type.storage} and value type ${type.value} yet`);\n        }\n      })();\n\n      const getByOffset = (offset: number|string) => (() => {\n        if (type.storage === type.value) {\n          return `${name}[${offset}]`;\n        } else if (type.storage === 'vec2<u32>' && type.value === 'i32') {\n          // int64, components === 1\n          return `i32(${name}[${offset}].x)`;\n        } else if (type.storage === 'vec2<u32>' && type.value === 'u32') {\n          // uint64, components === 1\n          return `u32(${name}[${offset}].x)`;\n        } else if (type.storage === 'u32' && type.value === 'vec4<bool>') {\n          // bool, components === 4\n          return `vec4<bool>(bool(${name}[${offset}] & 0xFFu), bool(${name}[${offset}] & 0xFF00u), bool(${name}[${\n              offset}] & 0xFF0000u), bool(${name}[${offset}] & 0xFF000000u))`;\n        } else {\n          throw new Error(`not supported combination of storage type ${type.storage} and value type ${type.value} yet`);\n        }\n      })();\n\n      const getByIndicesImplementation = rank < 2 ? '' : `\n  fn get_${name}ByIndices(indices: ${type.indices}) -> ${valueType} {\n    return ${getByOffset(`i2o_${name}(indices)`)};\n  }`;\n\n      const getImplementation = rank < 2 ? '' : (() => {\n        const functionParams = rankIdentity.map(i => `d${i}: u32`).join(', ');\n        const dimsParams = rankIdentity.map(i => `d${i}`).join(', ');\n        return `\n  fn get_${name}(${functionParams}) -> ${valueType} {\n    return get_${name}ByIndices(${indices(dimsParams)});\n  }`;\n      })();\n\n      const get = (...indices: ReadonlyArray<number|string>) => {\n        if (indices.length !== rank) {\n          throw new Error(`indices length must be ${rank}`);\n        }\n\n        const normalizedIndices = indices.map(normalizeDim).join(',');\n\n        if (rank === 0) {\n          return getByOffset('0u');\n        } else if (rank === 1) {\n          return getByOffset(normalizedIndices[0]);\n        } else {\n          implementationUsed.get = true;\n          implementationUsed.getByIndices = true;\n          implementationUsed.indicesToOffset = true;\n          return `get_${name}(${normalizedIndices})`;\n        }\n      };\n\n      const getByIndices = (varIndices: string) => {\n        if (rank < 2) {\n          return getByOffset(varIndices);\n        } else {\n          implementationUsed.getByIndices = true;\n          implementationUsed.indicesToOffset = true;\n          return `get_${name}ByIndices(${varIndices})`;\n        }\n      };\n\n      const setByIndicesImplementation = rank < 2 ? '' : `\n  fn set_${name}ByIndices(indices: ${type.indices}, value: ${valueType}) {\n    ${setByOffset(`i2o_${name}(indices)`, 'value')}\n  }`;\n\n      const setImplementation = rank < 2 ? '' : (() => {\n        const functionParams = rankIdentity.map(i => `d${i}: u32`).join(', ');\n        const dimsParams = rankIdentity.map(i => `d${i}`).join(', ');\n        return `\n  fn set_${name}(${functionParams}, value: ${valueType}) {\n    set_${name}ByIndices(${indices(dimsParams)}, value);\n  }`;\n      })();\n\n      const set = (...indicesAndValue: ReadonlyArray<number|string>) => {\n        if (indicesAndValue.length !== rank + 1) {\n          throw new Error(`indices length must be ${rank}`);\n        }\n        const value = indicesAndValue[rank];\n        if (typeof value !== 'string') {\n          throw new Error('value must be string');\n        }\n\n        const normalizedIndices = indicesAndValue.slice(0, rank).map(normalizeDim).join(',');\n\n        if (rank === 0) {\n          return setByOffset('0u', value);\n        } else if (rank === 1) {\n          return setByOffset(normalizedIndices[0], value);\n        } else {\n          implementationUsed.set = true;\n          implementationUsed.setByIndices = true;\n          implementationUsed.indicesToOffset = true;\n          return `set_${name}(${normalizedIndices}, ${value})`;\n        }\n      };\n\n      const setByIndices = (varIndices: string, value: string) => {\n        if (rank < 2) {\n          return setByOffset(varIndices, value);\n        } else {\n          implementationUsed.setByIndices = true;\n          implementationUsed.indicesToOffset = true;\n          return `set_${name}ByIndices(${varIndices}, ${value});`;\n        }\n      };\n\n      const impl = () => {\n        const impls = [];\n        let needShapeStrides = false;\n        if (implementationUsed.offsetToIndices) {\n          impls.push(offsetToIndicesImplementation);\n          needShapeStrides = true;\n        }\n        if (implementationUsed.indicesToOffset) {\n          impls.push(indicesToOffsetImplementation);\n          needShapeStrides = true;\n        }\n        if (implementationUsed.broadcastedIndicesToOffset) {\n          Object.values(broadcastedIndicesToOffsetImplementation).forEach(impl => impls.push(impl));\n          needShapeStrides = true;\n        }\n        if (implementationUsed.set) {\n          impls.push(setImplementation);\n          needShapeStrides = true;\n        }\n        if (implementationUsed.setByIndices) {\n          impls.push(setByIndicesImplementation);\n          needShapeStrides = true;\n        }\n        if (implementationUsed.get) {\n          impls.push(getImplementation);\n          needShapeStrides = true;\n        }\n        if (implementationUsed.getByIndices) {\n          impls.push(getByIndicesImplementation);\n          needShapeStrides = true;\n        }\n        if (!useUniform && needShapeStrides) {\n          impls.unshift(\n              `const ${shape} = ${type.indices}(${shapeOrRank.join(',')});`,\n              `const ${strides} = ${type.indices}(${ShapeUtil.computeStrides(shapeOrRank).join(',')});`);\n        }\n        return impls.join('\\n');\n      };\n\n      return {\n        impl,\n        type,\n        offsetToIndices,\n        indicesToOffset,\n        broadcastedIndicesToOffset,\n        indices,\n        indicesGet,\n        indicesSet,\n        set,\n        setByOffset,\n        setByIndices,\n        get,\n        getByOffset,\n        getByIndices,\n        // isVec4,\n        usage,\n        name,\n        strides,\n        shape,\n        rank\n      };\n    };\n\n/**\n * Create a IndicesHelper for an input.\n *\n * @param name - the name of the input.\n * @param type - the tensor type of the input.\n * @param shapeOrRank - the tensor shape or the rank of the input.\n * @param components - the number of components of the input. available values are 1, 2, 3, 4. default is 1.\n * @returns an IndicesHelper for the input.\n */\nexport const inputVariable =\n    (name: string, type: number, shapeOrRank: number|readonly number[], components: 1|2|3|4 = 1): IndicesHelper =>\n        createIndicesHelper(name, type, shapeOrRank, 'input', components);\n\n/**\n * Create a IndicesHelper for an output.\n *\n * @param name - the name of the output.\n * @param type - the tensor type of the output.\n * @param shapeOrRank - the tensor shape or the rank of the output.\n * @param components - the number of components of the output. available values are 1, 2, 3, 4. default is 1.\n * @returns an IndicesHelper for the output.\n */\nexport const outputVariable =\n    (name: string, type: number, shapeOrRank: number|readonly number[], components: 1|2|3|4 = 1): IndicesHelper =>\n        createIndicesHelper(name, type, shapeOrRank, 'output', components);\n\n/**\n * Create a IndicesHelper for an internal variable.\n *\n * @param name - the name of the variable.\n * @param type - the tensor type of the variable.\n * @param shapeOrRank - the tensor shape or the rank of the variable.\n * @param components - the number of components of the variable. available values are 1, 2, 3, 4. default is 1.\n * @returns an IndicesHelper for the variable.\n */\nexport const internalVariable =\n    (name: string, type: number, shapeOrRank: number|readonly number[], components: 1|2|3|4 = 1): IndicesHelper =>\n        createIndicesHelper(name, type, shapeOrRank, 'internal', components);\n\nexport type UniformDataElementType = 'u32'|'f16'|'f32'|'i32';\nexport type UniformsArrayType = Array<{name: string; type: UniformDataElementType; length?: number}>;\n\n/**\n * A ShaderHelper is a helper class for generating WGSL code.\n */\nexport interface ShaderHelper {\n  /**\n   * A helper function to generate the start of main function in WGSL source code.\n   *\n   * @example\n   * const getShaderSource = (shaderHelper: ShaderHelper) => `\n   *  ...\n   *\n   *  ${shaderHelper.mainStart()}\n   *    // your code here inside main() function\n   *    ...\n   *  }\n   * `;\n   *\n   * @param workgroupSize - an optional workgroup size. default is WORKGROUP_SIZE.\n   */\n  mainStart(workgroupSize?: number|[number, number, number]): string;\n\n  /**\n   * A helper function to generate the code snippet for guarding against out-of-bounds size.\n   *\n   * @example\n   * const getShaderSource = (shaderHelper: ShaderHelper) => `\n   *  ...\n   *\n   *  ${shaderHelper.mainStart()}\n   *    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}\n   *\n   *    // your code here inside main() function\n   *    ...\n   *  }\n   * `;\n   *\n   * @param size - the size of the data to guard against. can be a number or a string (WGSL `u32` expression).\n   */\n  guardAgainstOutOfBoundsWorkgroupSizes(size: unknown): string;\n\n  /**\n   * A helper function to generate the code snippet for declaring multiple inputs or outputs.\n   *\n   * @param variables - an array of IndicesHelper for the variables.\n   */\n  declareVariables(...variables: IndicesHelper[]): string;\n\n  /**\n   * A helper function to register one uniform. Can be called multiple times to register multiple uniforms.\n   *\n   * @param name - the name of the uniform.\n   * @param type - the type of the uniform.\n   * @param length - the length of the uniform, default to 1 when it is not provided.\n   */\n  registerUniform(name: string, type: string, length?: number): ShaderHelper;\n\n  /**\n   * A helper function to register multiple uniforms. Can be called multiple times to register multiple uniforms.\n   *\n   * @param uniforms - an array of uniforms. Each element of the array is an object with 2 properties: `name` and\n   *     `type`.\n   */\n  registerUniforms(uniforms: UniformsArrayType): ShaderHelper;\n\n  /**\n   * A helper function to register multiple internal variables. Can be called multiple times to register multiple\n   * internal variables.\n   *\n   * @param variables - an array of IndicesHelper for the variables.\n   */\n  registerInternalVariables(...variables: IndicesHelper[]): ShaderHelper;\n}\n\nclass ShaderHelperImpl implements ShaderHelper {\n  constructor(private normalizedDispatchGroup: [number, number, number], private limits: GPUSupportedLimits) {}\n\n  guardAgainstOutOfBoundsWorkgroupSizes(size: number|string): string {\n    // Guard against out-of-bounds work group sizes\n    const sizeInCode = typeof size === 'number' ? `${size}u` : size;\n    return `if (global_idx >= ${sizeInCode}) { return; }`;\n  }\n\n  mainStart(workgroupSize: number|[number, number, number] = WORKGROUP_SIZE) {\n    const workgroupSizeX = typeof workgroupSize === 'number' ? workgroupSize : workgroupSize[0];\n    const workgroupSizeY = typeof workgroupSize === 'number' ? 1 : workgroupSize[1];\n    const workgroupSizeZ = typeof workgroupSize === 'number' ? 1 : workgroupSize[2];\n\n    if (workgroupSizeX > this.limits.maxComputeWorkgroupSizeX ||\n        workgroupSizeY > this.limits.maxComputeWorkgroupSizeY ||\n        workgroupSizeZ > this.limits.maxComputeWorkgroupSizeZ) {\n      throw new Error(`workgroup size [${workgroupSizeX}, ${workgroupSizeY}, ${\n          workgroupSizeZ}] exceeds the maximum workgroup size [${this.limits.maxComputeWorkgroupSizeX}, ${\n          this.limits.maxComputeWorkgroupSizeY}, ${this.limits.maxComputeWorkgroupSizeZ}].`);\n    }\n\n    if (workgroupSizeX * workgroupSizeY * workgroupSizeZ > this.limits.maxComputeInvocationsPerWorkgroup) {\n      throw new Error(`workgroup size [${workgroupSizeX}, ${workgroupSizeY}, ${\n          workgroupSizeZ}] exceeds the maximum workgroup invocations ${\n          this.limits.maxComputeInvocationsPerWorkgroup}.`);\n    }\n\n    const is1DimensionDispatch = this.normalizedDispatchGroup[1] === 1 && this.normalizedDispatchGroup[2] === 1;\n    const paramList = is1DimensionDispatch ? `@builtin(global_invocation_id) global_id : vec3<u32>,\n    @builtin(workgroup_id) workgroup_id : vec3<u32>,\n    @builtin(local_invocation_id) local_id : vec3<u32>` :\n                                             `@builtin(global_invocation_id) global_id : vec3<u32>,\n                                             @builtin(local_invocation_id) local_id : vec3<u32>,\n    @builtin(local_invocation_index) local_idx : u32,\n    @builtin(workgroup_id) workgroup_id : vec3<u32>,\n    @builtin(num_workgroups) num_workgroups : vec3<u32>`;\n    const globalIdxDefinition = is1DimensionDispatch ?\n        'let global_idx = global_id.x; let local_idx = local_id.x;' :\n        `let global_idx = (workgroup_id.z * num_workgroups[0] * num_workgroups[1] +\n          workgroup_id.y * num_workgroups[0] + workgroup_id.x) * ${\n            workgroupSizeX * workgroupSizeY * workgroupSizeZ}u + local_idx;`;\n\n    return `@compute @workgroup_size(${workgroupSizeX}, ${workgroupSizeY}, ${workgroupSizeZ})\n  fn main(${paramList}) {\n    ${globalIdxDefinition}\n  `;\n  }\n\n  private appendVariableUniforms(variable: IndicesHelper): void {\n    if (variable.rank !== 0) {\n      if (variable.shape.startsWith('uniforms.')) {\n        this.uniforms.push({name: variable.shape.replace('uniforms.', ''), type: 'u32', length: variable.rank});\n      }\n      if (variable.strides.startsWith('uniforms.')) {\n        this.uniforms.push({name: variable.strides.replace('uniforms.', ''), type: 'u32', length: variable.rank});\n      }\n    }\n  }\n\n  private declareVariable(variable: IndicesHelper, bindingIndex: number): string {\n    if (variable.usage === 'internal') {\n      throw new Error('cannot use internal variable with declareVariable(). use registerInternalVariables() instead.');\n    }\n    this.variables.push(variable);\n    this.appendVariableUniforms(variable);\n\n    const access = variable.usage === 'input' ? 'read' : 'read_write';\n    const storageType = variable.type.storage;\n    return `@group(0) @binding(${bindingIndex}) var<storage, ${access}> ${variable.name}: array<${storageType}>;`;\n  }\n\n  declareVariables(...variables: IndicesHelper[]): string {\n    return variables.map(v => this.declareVariable(v, this.variableIndex++)).join('\\n');\n  }\n\n  private registerInternalVariable(variable: IndicesHelper): void {\n    if (variable.usage !== 'internal') {\n      throw new Error(\n          'cannot use input or output variable with registerInternalVariable(). use declareVariables() instead.');\n    }\n\n    this.internalVariables.push(variable);\n    this.appendVariableUniforms(variable);\n  }\n\n  registerInternalVariables(...variables: IndicesHelper[]): ShaderHelper {\n    variables.forEach(v => this.registerInternalVariable(v));\n    return this;\n  }\n\n  registerUniform(name: string, type: UniformDataElementType, length = 1): ShaderHelper {\n    this.uniforms.push({name, type, length});\n    return this;\n  }\n\n  registerUniforms(additionalUniforms: UniformsArrayType): ShaderHelper {\n    this.uniforms = this.uniforms.concat(additionalUniforms);\n    return this;\n  }\n\n  private internalVariables: IndicesHelper[] = [];\n  private variables: IndicesHelper[] = [];\n  private uniforms: UniformsArrayType = [];\n  private uniformDeclaration(): string {\n    if (this.uniforms.length === 0) {\n      return '';\n    }\n\n    const uniformSnippets: string[] = [];\n    for (const {name, type, length} of this.uniforms) {\n      if (length && length > 4) {\n        if (type === 'f16') {\n          uniformSnippets.push(`@align(16) ${name}:array<mat2x4<${type}>, ${Math.ceil(length / 8)}>`);\n        } else {\n          uniformSnippets.push(`${name}:array<vec4<${type}>, ${Math.ceil(length / 4)}>`);\n        }\n      } else {\n        const typeTemp = length == null || length === 1 ? type : `vec${length}<${type}>`;\n        uniformSnippets.push(`${name}:${typeTemp}`);\n      }\n    }\n\n    return `\n      struct Uniforms { ${uniformSnippets.join(', ')} };\n      @group(0) @binding(${this.variableIndex}) var<uniform> uniforms: Uniforms;`;\n  }\n  private variableIndex = 0;\n\n  /**\n   * Get additional implementation that needs to be added to the shader source.\n   */\n  get additionalImplementations(): string {\n    return this.uniformDeclaration() + this.variables.map(i => i.impl()).join('\\n') +\n        this.internalVariables.map(i => i.impl()).join('\\n');\n  }\n\n  /**\n   * Get the variable info of the shader program.\n   */\n  get variablesInfo(): ProgramUniformVariableInfo[]|undefined {\n    if (this.uniforms.length === 0) {\n      return undefined;\n    }\n\n    const uniformWgslTypeToDataType = (type: UniformDataElementType) =>\n        ([DataType.uint32, DataType.float16, DataType.float,\n          DataType.int32][['u32', 'f16', 'f32', 'i32'].indexOf(type)]);\n    return this.uniforms.map(u => ([uniformWgslTypeToDataType(u.type), u.length ?? 1]));\n  }\n}\n\nexport const createShaderHelper = (dispatchGroup: [number, number, number], limits: GPUSupportedLimits) =>\n    new ShaderHelperImpl(dispatchGroup, limits);\n\n/**\n * This function comes from https://github.com/tensorflow/tfjs/blob/master/tfjs-core/src/ops/broadcast_util.ts#L18-L40\n * Returns the dimensions in the input shape that are broadcasted to\n * produce the provided output shape.\n *\n * The returned dimensions are 0-indexed and sorted. An example:\n * inShape = [4, 1, 3]\n * outShape = [5, 4, 3, 3]\n * result = [1]. Dimension 1 (2nd dimension of input) gets broadcasted 1 => 3.\n */\nexport const getBroadcastDims = (inShape: readonly number[], outShape: readonly number[]): number[] => {\n  const inRank = inShape.length;\n  const dims: number[] = [];\n  for (let i = 0; i < inRank; i++) {\n    const dim = inRank - 1 - i;\n    const a = inShape[dim] || 1;\n    const b = outShape[outShape.length - 1 - i] || 1;\n    if (b > 1 && a === 1) {\n      dims.unshift(dim);\n    }\n  }\n  return dims;\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface TransposeAttributes extends AttributeWithCacheKey {\n  readonly perm: number[];\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Transpose requires 1 input.');\n  }\n};\n\nconst getAdjustedPerm = (inputRank: number, perm: number[]): number[] =>\n    (perm && perm.length !== inputRank) ? [...(new Array(inputRank).keys())].reverse() : perm;\n\nconst getOutputShape = (inputShape: readonly number[], perm: number[]): readonly number[] =>\n    ShapeUtil.sortBasedOnPerm(inputShape, getAdjustedPerm(inputShape.length, perm));\n\nconst permFunctionBody = (perm: number[], rank: number, input: IndicesHelper, output: IndicesHelper): string => {\n  const reverseFunc = [];\n  reverseFunc.push(`fn perm(i: ${output.type.indices}) -> ${input.type.indices} {\n    var a: ${input.type.indices};`);\n  for (let i = 0; i < rank; ++i) {\n    reverseFunc.push(input.indicesSet('a', perm[i], `i[${i}]`));\n  }\n  reverseFunc.push('return a;}');\n  return reverseFunc.join('\\n');\n};\n\nexport const createTransposeProgramInfo = (inputTensor: TensorView, permAttr: number[]): ProgramInfo => {\n  const inputDataType = inputTensor.dataType;\n  const inputRank = inputTensor.dims.length;\n  const perm = getAdjustedPerm(inputRank, permAttr);\n  const outputShape = getOutputShape(inputTensor.dims, perm);\n  const output = outputVariable('output', inputDataType, outputShape.length);\n  const input = inputVariable('a', inputDataType, inputRank);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(input, output)}\n\n  ${permFunctionBody(perm, inputRank, input, output)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n    let indices = ${output.offsetToIndices('global_idx')};\n    let aIndices = perm(indices);\n\n    ${output.setByOffset('global_idx', input.getByIndices('aIndices'))}\n  }`;\n  return {\n    name: 'Transpose',\n    shaderCache: {hint: `${permAttr}`, inputDependencies: ['rank']},\n    getRunData: (inputs) => {\n      const outputSize = ShapeUtil.size(outputShape);\n      return {\n        outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n        dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n        programUniforms:\n            [{type: DataType.uint32, data: outputSize}, ...createTensorShapeVariables(inputs[0].dims, outputShape)],\n      };\n    },\n    getShaderSource,\n  };\n};\n\nexport const transpose = (context: ComputeContext, attributes: TransposeAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createTransposeProgramInfo(context.inputs[0], attributes.perm));\n};\n\nexport const parseTransposeAttributes = (attributes: Record<string, unknown>): TransposeAttributes =>\n    createAttributeWithCacheKey({perm: attributes.perm as number[]});\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramShaderCacheInfo} from '../types';\n\nimport {inputVariable, outputVariable, ShaderHelper} from './common';\nimport {createReduceAttributesFromInputs, ReduceAttributes} from './reduce';\nimport {createTransposeProgramInfo} from './transpose';\n\nconst reduceOps: {[key: string]: string} = {\n  max: 'select(bestValue, candidate, candidate > bestValue)',\n  min: 'select(bestValue, candidate, candidate < bestValue)',\n  mean: 'bestValue + candidate',\n  sum: 'bestValue + candidate',\n  prod: 'bestValue * candidate',\n  sumSquare: 'bestValue + candidate * candidate',\n  logSumExp: 'bestValue + exp(candidate)',\n  l1: 'bestValue + abs(candidate)',\n  l2: 'bestValue + candidate * candidate',\n  logSum: 'bestValue + candidate'\n};\n\nconst reduceSharedOps: {[key: string]: string} = {\n  max: 'select(bestValue, candidate, candidate > bestValue)',\n  min: 'select(bestValue, candidate, candidate < bestValue)',\n  mean: 'bestValue + candidate',\n  sum: 'bestValue + candidate',\n  prod: 'bestValue * candidate',\n  sumSquare: 'bestValue + candidate',\n  logSumExp: 'bestValue + candidate',\n  l1: 'bestValue + candidate',\n  l2: 'bestValue + candidate',\n  logSum: 'bestValue + candidate'\n};\n\nconst reduceInitValues: {[key: string]: string} = {\n  max: '_A[offset]',\n  min: '_A[offset]',\n  mean: '0',\n  sum: '0',\n  prod: '1',\n  sumSquare: '0',\n  logSumExp: '0',\n  l1: '0',\n  l2: '0',\n  logSum: '0'\n};\n\nconst reduceOutputValues: {[key: string]: string} = {\n  max: 'bestValue',\n  min: 'bestValue',\n  sum: 'bestValue',\n  prod: 'bestValue',\n  sumSquare: 'bestValue',\n  logSumExp: 'log(bestValue)',\n  l1: 'bestValue',\n  l2: 'sqrt(bestValue)',\n  logSum: 'log(bestValue)'\n};\n\nconst getInnerMostAxes = (numInnerAxes: number, rank: number): number[] => {\n  const res = [];\n  for (let i = rank - numInnerAxes; i < rank; ++i) {\n    res.push(i);\n  }\n  return res;\n};\n\nconst computeOutAndReduceShapes = (shape: readonly number[], axes: readonly number[]): [number[], number[]] => {\n  const outputShape = [];\n  const rank = shape.length;\n  for (let dim = 0; dim < rank; dim++) {\n    if (axes.indexOf(dim) === -1) {\n      outputShape.push(shape[dim]);\n    }\n  }\n  const reduceShape = axes.map(dim => shape[dim]);\n  return [outputShape, reduceShape];\n};\n\nconst expandShapeToKeepDim = (shape: number[], axes: number[]): number[] => {\n  const rank = shape.length + axes.length;\n  const expandShape = [];\n  let shapeIdx = 0;\n  for (let dim = 0; dim < rank; dim++) {\n    if (axes.indexOf(dim) === -1) {\n      expandShape.push(shape[shapeIdx++]);\n    } else {\n      expandShape.push(1);\n    }\n  }\n  return expandShape;\n};\n\nconst areAxesInnerMostDims = (axes: number[], rank: number): boolean => {\n  for (let i = 0; i < axes.length; ++i) {\n    if (axes[axes.length - i - 1] !== rank - 1 - i) {\n      return false;\n    }\n  }\n  return true;\n};\n\nconst getAxesPermutation = (axes: number[], rank: number): number[] => {\n  const res = [];\n  if (!areAxesInnerMostDims(axes, rank)) {\n    for (let i = 0; i < rank; ++i) {\n      if (axes.indexOf(i) === -1) {\n        res.push(i);\n      }\n    }\n    axes.forEach(axis => res.push(axis));\n  }\n  return res;\n};\n\nexport const createReduceSharedProgramInfo =\n    (name: string, shaderCache: ProgramShaderCacheInfo, inputs: readonly TensorView[], reduceType: string,\n     outputDataType: DataType, outputShape: number[], reduceShape: number[]): ProgramInfo => {\n      const inputShape = inputs[0].dims;\n\n      const outputSize = ShapeUtil.size(outputShape);\n      const reduceSize = ShapeUtil.size(reduceShape);\n\n      const input = inputVariable('_A', inputs[0].dataType, inputShape);\n      const output = outputVariable('output', outputDataType, outputShape);\n\n      const workgroupSize = 32;\n\n      const sharedMemorySnippet = `\n          var<workgroup> aBestValues : array<f32, ${workgroupSize}>;\n       `;\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => `\n        ${shaderHelper.registerUniform('reduceSize', 'u32').declareVariables(input, output)}\n        ${sharedMemorySnippet}\n        fn DIV_CEIL(a : u32, b : u32) -> u32 {\n          return ((a - 1u) / b + 1u);\n         }\n         ${shaderHelper.mainStart(workgroupSize)}\n\n          let outputIndex = global_idx / ${workgroupSize};\n          let offset = outputIndex * uniforms.reduceSize;\n\n          var bestValue = f32(${reduceInitValues[reduceType]});\n          let Length = uniforms.reduceSize;\n          for (var k = local_idx; k < Length; k = k + ${workgroupSize}) {\n           let candidate = f32(${input.getByOffset('offset + k')});\n           bestValue = ${reduceOps[reduceType]};\n          }\n          aBestValues[local_idx] = bestValue;\n          workgroupBarrier();\n\n         var reduceSize = min(Length, ${workgroupSize}u);\n         for (var currentSize = reduceSize / 2u; reduceSize > 1u;\n             currentSize = reduceSize / 2u) {\n           let interval = DIV_CEIL(reduceSize, 2u);\n           if (local_idx < currentSize) {\n            let candidate = aBestValues[local_idx + interval];\n            bestValue = ${reduceSharedOps[reduceType]};\n            aBestValues[local_idx] = bestValue;\n           }\n           reduceSize = interval;\n           workgroupBarrier();\n         }\n\n         if (local_idx == 0u) {\n          ${\n          output.setByOffset(\n              'outputIndex',\n              `${\n                  reduceType === 'mean' ? `${output.type.storage}(bestValue / f32(uniforms.reduceSize))` :\n                                          `${output.type.storage}(${reduceOutputValues[reduceType]})`}`)};\n         }\n        }`;\n\n      // One work group is responsible for only one element of output.\n      return {\n        name,\n        shaderCache,\n        getShaderSource,\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: outputDataType}],\n          dispatchGroup: {x: outputSize},\n          programUniforms: [{type: DataType.uint32, data: reduceSize}]\n        }),\n      };\n    };\n\nconst reduceCommon =\n    (context: ComputeContext, name: string, attributes: ReduceAttributes,\n     reduceType: 'sum'|'sumSquare'|'prod'|'min'|'max'|'mean'|'logSumExp'|'l1'|'l2'|'logSum'): void => {\n      const updatedAttributes: ReduceAttributes =\n          context.inputs.length === 1 ? attributes : createReduceAttributesFromInputs(context.inputs, attributes);\n\n      let updatedAxes = updatedAttributes.axes;\n      if (updatedAxes.length === 0 && !updatedAttributes.noopWithEmptyAxes) {\n        updatedAxes = context.inputs[0].dims.map((_dim, i) => i);\n      }\n      const normalizeAxes = ShapeUtil.normalizeAxes(updatedAxes, context.inputs[0].dims.length);\n\n      let axes = normalizeAxes;\n      let input = context.inputs[0];\n      const permutedAxes = getAxesPermutation(axes, context.inputs[0].dims.length);\n      if (permutedAxes.length > 0) {\n        input = context.compute(\n            createTransposeProgramInfo(context.inputs[0], permutedAxes), {inputs: [0], outputs: [-1]})[0];\n        axes = getInnerMostAxes(axes.length, input.dims.length);\n      }\n\n      const [outputShape, reduceShape] = computeOutAndReduceShapes(input.dims, axes);\n      let finalOutputShape = outputShape;\n      if (updatedAttributes.keepDims) {\n        finalOutputShape = expandShapeToKeepDim(outputShape, normalizeAxes);\n      }\n\n      context.compute(\n          createReduceSharedProgramInfo(\n              name, {hint: updatedAttributes.cacheKey, inputDependencies: ['type']}, [input], reduceType,\n              context.inputs[0].dataType, finalOutputShape, reduceShape),\n          {inputs: [input]});\n    };\n\nexport const reduceMeanShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceMeanShared', attributes, 'mean');\n};\n\nexport const reduceL1Shared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceL1Shared', attributes, 'l1');\n};\n\nexport const reduceL2Shared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceL2Shared', attributes, 'l2');\n};\n\nexport const reduceLogSumExpShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceLogSumExpShared', attributes, 'logSumExp');\n};\n\nexport const reduceMaxShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceMaxShared', attributes, 'max');\n};\n\nexport const reduceMinShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceMinShared', attributes, 'min');\n};\n\nexport const reduceProdShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceProdShared', attributes, 'prod');\n};\n\nexport const reduceSumShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceSumShared', attributes, 'sum');\n};\n\nexport const reduceSumSquareShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceSumSquareShared', attributes, 'sumSquare');\n};\n\nexport const reduceLogSumShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceLogSumShared', attributes, 'logSum');\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramShaderCacheInfo} from '../types';\n\nimport {createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\nimport {reduceL1Shared, reduceL2Shared, reduceLogSumExpShared, reduceLogSumShared, reduceMaxShared, reduceMeanShared, reduceMinShared, reduceProdShared, reduceSumShared, reduceSumSquareShared} from './reduce-shared';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length === 0 || inputs.length > 2) {\n    throw new Error('Reduce op requires 1 or 2 inputs.');\n  }\n\n  if (inputs.length === 2 && inputs[1].dims.length !== 1) {\n    throw new Error('Invalid axes input dims.');\n  }\n};\n\nexport interface ReduceAttributes extends AttributeWithCacheKey {\n  keepDims: boolean;\n  noopWithEmptyAxes: boolean;\n  axes: number[];\n}\n\nexport type ReduceOp =\n    (input: IndicesHelper, output: IndicesHelper,\n     axes: readonly number[]) => [string, string, string, string, ...string[]];\n\nconst noOp: ReduceOp = (input) => ['', '', `var value = ${input.getByIndices('input_indices')};`, ''];\nexport const createReduceProgramInfo =\n    (name: string, shaderCache: ProgramShaderCacheInfo, inputs: readonly TensorView[], reduceOp: ReduceOp,\n     axesInput: number[], outputDataType: DataType, keepDims = false, noopWithEmptyAxes = false): ProgramInfo => {\n      const outputShape: number[] = [];\n      const inputShape = inputs[0].dims;\n      const inputRank = inputShape.length;\n      const axes = ShapeUtil.normalizeAxes(axesInput, inputRank);\n      const reduceOnAllAxes = !noopWithEmptyAxes && axes.length === 0;\n      inputShape.forEach((d, i) => {\n        if (reduceOnAllAxes || axes.indexOf(i) >= 0) {\n          if (keepDims) {\n            outputShape.push(1);\n          }  // else { // skip this axis}\n        } else {\n          outputShape.push(d);\n        }\n      });\n      const outputRank = outputShape.length;\n      const outputSize = ShapeUtil.size(outputShape);\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const idxCopy: string[] = [];  // copy output indexes to input indexes\n\n        const input = inputVariable('_A', inputs[0].dataType, inputRank);\n        const output = outputVariable('output', outputDataType, outputRank);\n        const ops = reduceOp(input, output, axes);\n        let reduceOps = ops[2];\n\n        for (let k = 0, l = 0; k < inputRank; k++) {\n          // if this axis is reduced\n          if (reduceOnAllAxes || axes.indexOf(k) >= 0) {\n            if (keepDims) {\n              l++;\n            }\n            // loop over the d-th axis\n            reduceOps = `for(var j${k}: u32 = 0; j${k} < ${inputShape[k]}; j${k}++) {\n                  ${ops[2].includes('last_index') ? `let last_index = j${k};` : ''}\n                  ${input.indicesSet('input_indices', k, `j${k}`)}\n                  ${reduceOps}\n                }`;\n          } else {\n            idxCopy.push(`${input.indicesSet('input_indices', k, output.indicesGet('output_indices', l))};`);\n            l++;\n          }\n        }\n        return `\n\n        ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(input, output)}\n\n        ${shaderHelper.mainStart()}\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n          var input_indices: ${input.type.indices};\n          let output_indices = ${output.offsetToIndices('global_idx')};\n\n          ${idxCopy.join('\\n')}\n          ${ops[0]}       // init ops for reduce max/min\n          ${ops[1]}\n          ${reduceOps}\n          ${ops[3]}\n          ${ops.length === 4 ? output.setByOffset('global_idx', 'value') : ops.slice(4).join('\\n')}\n        }`;\n      };\n\n      return {\n        name,\n        shaderCache,\n        getShaderSource,\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: outputDataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms:\n              [{type: DataType.uint32, data: outputSize}, ...createTensorShapeVariables(inputShape, outputShape)]\n        }),\n      };\n    };\n\nexport const createReduceAttributesFromInputs =\n    (inputs: readonly TensorView[], attributes: ReduceAttributes): ReduceAttributes => {\n      const axes: number[] = [];\n      if (inputs[1].dims[0] > 0) {\n        inputs[1].getBigInt64Array().forEach(v => axes.push(Number(v)));\n      }\n      return createAttributeWithCacheKey(\n          {axes, keepDims: attributes.keepDims, noopWithEmptyAxes: attributes.noopWithEmptyAxes});\n    };\n\nconst runReduceProgram =\n    (context: ComputeContext, name: string, attributes: ReduceAttributes, reduceOp: ReduceOp): void => {\n      const inputs = context.inputs;\n      const updatedAttributes: ReduceAttributes =\n          inputs.length === 1 ? attributes : createReduceAttributesFromInputs(inputs, attributes);\n\n      context.compute(\n          createReduceProgramInfo(\n              name, {hint: updatedAttributes.cacheKey, inputDependencies: ['rank']}, [inputs[0]],\n              updatedAttributes.noopWithEmptyAxes && updatedAttributes.axes.length === 0 ? noOp : reduceOp,\n              updatedAttributes.axes, inputs[0].dataType, updatedAttributes.keepDims,\n              updatedAttributes.noopWithEmptyAxes),\n          {inputs: [0]});\n    };\n\nconst reduceLogSumNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var value = ${output.type.storage}(0);`,\n       '',\n       `value += ${input.getByIndices('input_indices')};`,\n       'value = log(value);',\n  ];\n  runReduceProgram(context, 'ReduceLogSum', attributes, reduceOp);\n};\n\nconst reduceL1Naive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var value = ${output.type.storage}(0);`,\n       '',\n       `value += abs(${input.getByIndices('input_indices')});`,\n       '',\n  ];\n  runReduceProgram(context, 'ReduceL1', attributes, reduceOp);\n};\n\nconst reduceL2Naive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var t = ${output.type.value}(0); var value = ${output.type.value}(0);`,\n       '',\n       `t = ${input.getByIndices('input_indices')}; value += (t * t);`,\n       'value = sqrt(value);',\n  ];\n  runReduceProgram(context, 'ReduceL2', attributes, reduceOp);\n};\n\nconst reduceLogSumExpNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var value = ${output.type.storage}(0);`,\n       '',\n       `value += exp(${input.getByIndices('input_indices')});`,\n       'value = log(value);',\n  ];\n  runReduceProgram(context, 'ReduceLogSumExp', attributes, reduceOp);\n};\n\nconst reduceMaxNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, _output, axes) => {\n    const idxZero = [];\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(input.indicesSet('input_indices', k, 0));\n      }\n    }\n\n    return [\n      `${idxZero.join('\\n')}`,\n      `var value = ${input.getByIndices('input_indices')};`,\n      `value = max(value, ${input.getByIndices('input_indices')});`,\n      '',\n    ];\n  };\n  runReduceProgram(context, 'ReduceMax', attributes, reduceOp);\n};\n\nconst reduceMeanNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output, axes) => {\n    let size = 1.0;\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        // TODO: this depends on the input dims. If we want to use uniform, this need to be updated.\n        size *= context.inputs[0].dims[k];\n      }\n    }\n\n    return [\n      'var sum = f32(0);',\n      '',\n      `sum += f32(${input.getByIndices('input_indices')});`,\n      `let value = ${output.type.value}(sum / ${size});`,\n    ];\n  };\n  runReduceProgram(context, 'ReduceMean', attributes, reduceOp);\n};\n\nconst reduceMinNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, _output, axes) => {\n    const idxZero = [];\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(`input_indices[${k}] = 0;`);  // first element\n      }\n    }\n\n    return [\n      `${idxZero.join('\\n')}`,\n      `var value = ${input.getByIndices('input_indices')};`,\n      `value = min(value, ${input.getByIndices('input_indices')});`,\n      '',\n    ];\n  };\n  runReduceProgram(context, 'ReduceMin', attributes, reduceOp);\n};\n\nconst reduceProdNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var value = ${output.type.storage}(1);`,\n       '',\n       `value *= ${input.getByIndices('input_indices')};`,\n       '',\n  ];\n  runReduceProgram(context, 'ReduceProd', attributes, reduceOp);\n};\n\nconst reduceSumNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var value = ${output.type.storage}(0);`,\n       '',\n       `value += ${input.getByIndices('input_indices')};`,\n       '',\n  ];\n  runReduceProgram(context, 'ReduceSum', attributes, reduceOp);\n};\n\nconst reduceSumSquareNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var t = ${output.type.value}(0); var value = ${output.type.value}(0);`,\n       '',\n       `t = ${input.getByIndices('input_indices')}; value += t * t;`,\n       '',\n  ];\n  runReduceProgram(context, 'ReduceSumSquare', attributes, reduceOp);\n};\n\nconst useNaiveReduceMethod =\n    (shape: readonly number[], axes: readonly number[], noopWithEmptyAxes: boolean): boolean => {\n      if (axes.length === 0) {\n        return noopWithEmptyAxes;\n      }\n\n      let outputSize = 1;\n      let reduceSize = 1;\n      for (let dim = 0; dim < axes.length; dim++) {\n        if (axes.indexOf(dim) === -1) {\n          outputSize *= shape[dim];\n        } else {\n          reduceSize *= shape[dim];\n        }\n      }\n\n      // The condition data is very rough, although considering the count of Execution Unit (EU), the potential\n      // work groups in a EU and the counts of loops in the naive and shared methods, also doing experiments\n      // on some machines.\n      return reduceSize < 32 && outputSize > 1024;\n    };\n\nexport const reduceMean = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceMeanNaive(context, attributes);\n  } else {\n    reduceMeanShared(context, attributes);\n  }\n};\n\nexport const reduceL1 = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceL1Naive(context, attributes);\n  } else {\n    reduceL1Shared(context, attributes);\n  }\n};\n\nexport const reduceL2 = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceL2Naive(context, attributes);\n  } else {\n    reduceL2Shared(context, attributes);\n  }\n};\n\nexport const reduceLogSumExp = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceLogSumExpNaive(context, attributes);\n  } else {\n    reduceLogSumExpShared(context, attributes);\n  }\n};\n\nexport const reduceMax = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceMaxNaive(context, attributes);\n  } else {\n    reduceMaxShared(context, attributes);\n  }\n};\n\nexport const reduceMin = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceMinNaive(context, attributes);\n  } else {\n    reduceMinShared(context, attributes);\n  }\n};\n\nexport const reduceProd = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceProdNaive(context, attributes);\n  } else {\n    reduceProdShared(context, attributes);\n  }\n};\n\nexport const reduceSum = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceSumNaive(context, attributes);\n  } else {\n    reduceSumShared(context, attributes);\n  }\n};\n\nexport const reduceSumSquare = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceSumSquareNaive(context, attributes);\n  } else {\n    reduceSumSquareShared(context, attributes);\n  }\n};\n\nexport const reduceLogSum = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceLogSumNaive(context, attributes);\n  } else {\n    reduceLogSumShared(context, attributes);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// TODO: this is the same naive implementation we use for reduce that has\n// performance limitations when the reduced axis is long. Need to add\n// a optimized codepath for this.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext} from '../types';\n\nimport {createReduceProgramInfo, ReduceOp} from './reduce';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length === 0 || inputs.length > 2) {\n    throw new Error('ArgMinMaxOp op requires 1 or 2 inputs.');\n  }\n  if (inputs[0].dataType !== DataType.float) {\n    throw new Error('Invalid input type.');\n  }\n};\n\nexport interface ArgMinMaxAttributes extends AttributeWithCacheKey {\n  keepDims: boolean;\n  axis: number;\n  selectLastIndex: number;\n}\n\nexport const argMin = (context: ComputeContext, attributes: ArgMinMaxAttributes): void => {\n  validateInputs(context.inputs);\n  const argMinMaxOp: ReduceOp = (input, output, axes) => {\n    const idxZero = [];\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(`input_indices[${k}] = 0;`);  // first element\n      }\n    }\n    return [\n      `${idxZero.join('\\n')}`, `var value = ${input.getByIndices('input_indices')};\\nvar best_index : i32 = 0;`,\n      `if (${input.getByIndices('input_indices')} ${attributes.selectLastIndex > 0 ? '<=' : '<'} value) {\n         value = ${input.getByIndices('input_indices')};\n         best_index = i32(last_index);\n       }`,\n      '', output.setByOffset('global_idx', 'best_index')\n    ];\n  };\n\n  context.compute(\n      createReduceProgramInfo(\n          'ArgMin', {hint: attributes.cacheKey, inputDependencies: ['rank']}, [context.inputs[0]], argMinMaxOp,\n          [attributes.axis], DataType.int64, attributes.keepDims),\n      {inputs: [0]});\n};\n\nexport const argMax = (context: ComputeContext, attributes: ArgMinMaxAttributes): void => {\n  validateInputs(context.inputs);\n  const argMinMaxOp: ReduceOp = (input, output, axes) => {\n    const idxZero = [];\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(`input_indices[${k}] = 0;`);  // first element\n      }\n    }\n    return [\n      `${idxZero.join('\\n')}`, `var value = ${input.getByIndices('input_indices')};\\nvar best_index : i32 = 0;`,\n      `if (${input.getByIndices('input_indices')} ${attributes.selectLastIndex > 0 ? '>=' : '>'} value) {\n         value = ${input.getByIndices('input_indices')};\n         best_index = i32(last_index);\n       }`,\n      '', output.setByOffset('global_idx', 'best_index')\n    ];\n  };\n\n  context.compute(\n      createReduceProgramInfo(\n          'argMax', {hint: attributes.cacheKey, inputDependencies: ['rank']}, [context.inputs[0]], argMinMaxOp,\n          [attributes.axis], DataType.int64, attributes.keepDims),\n      {inputs: [0]});\n};\n\nexport const parseArgMinMaxAttributes = (attributes: Record<string, unknown>): ArgMinMaxAttributes =>\n    createAttributeWithCacheKey(attributes as Omit<ArgMinMaxAttributes, keyof AttributeWithCacheKey>);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface ConcatAttributes extends AttributeWithCacheKey {\n  readonly axis: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[], axis: number): void => {\n  if (!inputs || inputs.length < 1) {\n    throw new Error('too few inputs');\n  }\n  const referenceIndex = 0;\n  const referenceInput = inputs[referenceIndex];\n  const inputType = referenceInput.dataType;\n  const inputRank = referenceInput.dims.length;\n  inputs.forEach((input, i) => {\n    if (i === referenceIndex) {\n      return;\n    }\n    // make sure types of all inputs match\n    if (input.dataType !== inputType) {\n      throw new Error('input tensors should be one type');\n    }\n    // make sure the dimensionality of all inputs are the same\n    if (input.dims.length !== inputRank) {\n      throw new Error('input tensors should have the same shape');\n    }\n    input.dims.forEach((dim, i) => {\n      if (i !== axis && dim !== referenceInput.dims[i]) {\n        throw new Error('non concat dimensions must match');\n      }\n    });\n  });\n};\n\nconst calculateInputIndexImpl = (numberOfTensors: number, sizeInConcatAxisStr: string): string => `\n  fn calculateInputIndex(index: u32) -> u32 {\n    let sizeInConcatAxis = array<u32, ${numberOfTensors}u>(${sizeInConcatAxisStr});\n    for (var i: u32 = 0u; i < ${numberOfTensors}; i += 1u ) {\n      if (index < sizeInConcatAxis[i]) {\n        return i;\n      }\n    }\n    return ${numberOfTensors}u;\n  }`;\n\nconst assignOutputData = (inputs: readonly IndicesHelper[], output: IndicesHelper) => {\n  const numberOfTensors = inputs.length;\n\n  const codeLines: string[] = [];\n  for (let i = 0; i < numberOfTensors; ++i) {\n    const returnSnippet = output.setByOffset('global_idx', inputs[i].getByIndices('indices'));\n    if (numberOfTensors === 1) {\n      codeLines.push(returnSnippet);\n    } else if (i === 0) {\n      codeLines.push(`if (inputIndex == ${i}u) { ${returnSnippet} }`);\n    } else if (i === numberOfTensors - 1) {\n      codeLines.push(`else { ${returnSnippet} }`);\n    } else {\n      codeLines.push(`else if (inputIndex == ${i}) { ${returnSnippet} }`);\n    }\n  }\n  return codeLines.join('\\n');\n};\n\nexport const createConcatProgramInfo =\n    (inputs: readonly TensorView[], adjustedAxis: number, outputShape: number[], dataType: DataType): ProgramInfo => {\n      const outputSize = ShapeUtil.size(outputShape);\n\n      const sizeInConcatAxis = new Array<number>(inputs.length);\n      const inputVars = new Array<IndicesHelper>(inputs.length);\n\n      let previousSum = 0;\n      const inputDependencies: ProgramInputTensorInfoDependency[] = [];\n      const inputRanks = [];\n      const programUniforms: ProgramUniform[] = [{type: DataType.uint32, data: outputSize}];\n      for (let i = 0; i < inputs.length; ++i) {\n        previousSum += inputs[i].dims[adjustedAxis];\n        sizeInConcatAxis[i] = previousSum;\n        inputRanks.push(inputs[i].dims.length);\n        inputVars[i] = inputVariable(`input${i}`, dataType, inputRanks[i]);\n        inputDependencies.push('rank');\n        programUniforms.push({type: DataType.uint32, data: sizeInConcatAxis[i]});\n      }\n      for (let i = 0; i < inputs.length; ++i) {\n        programUniforms.push(...createTensorShapeVariables(inputs[i].dims));\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShape));\n\n      const output = outputVariable('output', dataType, outputShape.length);\n      const indicesAxis = output.indicesGet('indices', adjustedAxis);\n      const sizeInConcatAxisStr =\n          Array.from(Array(sizeInConcatAxis.length).keys()).map(i => `uniforms.sizeInConcatAxis${i}`).join(',');\n      const getShaderSource = (shaderHelper: ShaderHelper) => `\n\n  ${(() => {\n        shaderHelper.registerUniform('outputSize', 'u32');\n        for (let i = 0; i < inputs.length; i++) {\n          shaderHelper.registerUniform(`sizeInConcatAxis${i}`, 'u32');\n        }\n        return shaderHelper.declareVariables(...inputVars, output);\n      })()}\n\n  ${calculateInputIndexImpl(sizeInConcatAxis.length, sizeInConcatAxisStr)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n\n    var indices = ${output.offsetToIndices('global_idx')};\n\n    let inputIndex = calculateInputIndex(${indicesAxis});\n    if (inputIndex != 0u) {\n      let sizeInConcatAxis = array<u32, ${sizeInConcatAxis.length}u>(${sizeInConcatAxisStr});\n      ${indicesAxis} -= sizeInConcatAxis[inputIndex - 1u];\n    }\n\n    ${assignOutputData(inputVars, output)}\n  }`;\n\n      return {\n        name: 'Concat',\n        shaderCache: {hint: `${adjustedAxis}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms,\n        }),\n        getShaderSource,\n      };\n    };\n\nexport const concat = (context: ComputeContext, attributes: ConcatAttributes): void => {\n  const inputs = context.inputs;\n  const inputShape = inputs[0].dims;\n  const adjustedAxis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);\n  validateInputs(inputs, adjustedAxis);\n  const outputShape = inputShape.slice();\n  outputShape[adjustedAxis] =\n      inputs.reduce((sum, input) => sum + (input.dims.length > adjustedAxis ? input.dims[adjustedAxis] : 0), 0);\n  // 0 length tensors are valid for concat, remove them\n  const nonEmptyInputs = inputs.filter(input => ShapeUtil.size(input.dims) > 0);\n  context.compute(\n      createConcatProgramInfo(nonEmptyInputs, adjustedAxis, outputShape, inputs[0].dataType), {inputs: nonEmptyInputs});\n};\n\nexport const parseConcatAttributes = (attributes: Record<string, unknown>): ConcatAttributes =>\n    createAttributeWithCacheKey({axis: attributes.axis as number});\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ComputeContext, GpuDataType, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, getMaxComponents, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, tensorTypeToWsglValueType, UniformDataElementType, UniformsArrayType} from './common';\nimport {createConcatProgramInfo} from './concat';\n\nexport const enum AttentionQkvFormat {\n  unknown,          // enum value not set, or depends on qkv projection implementation details\n  qkvBNSH,          // for non-packed qkv, permuted\n  qkvBSNH,          // for non-packed qkv, not permuted, used by memory efficient attention or MultiHeadAttention\n  qkvBSN3H,         // for TRT fused attention, qkv are packed\n  qkvBNSHqkvBS3NH,  // for TRT fused causal attention, data has two formats (qkv is 3BNSH, gemm_buffer is BS3NH)\n  qKvBSNHxBSN2H,    // for TRT fused cross attention, kv are packed\n  qkvTNH,           // for memory efficient attention, qkv are not packed, and paddings are removed.\n  qkvTN3H,          // for TRT fused attention, qkv are packed and paddings are removed\n}\n\nexport const enum AttentionMaskType {\n  none,                  // No mask\n  mask1dKeySeqLen,       // [batch_size], key sequence length\n  mask1dEndStart,        // [2 * batch_size] with end positions and start positions\n  mask1DKeySeqLenStart,  // [3 * batch_size + 2] with [key_len[0], ..., key_len[batch_size - 1], query_start[0],\n                         // ..., query_start[batch_size - 1], query_end[batch_size - 1], key_start[0], ...,\n                         // key_start[batch_size - 1], key_end[batch_size - 1]]\n  mask2dDummy,           // dummy mask with shape [1, 1] or [batch_size, 1]. It has same effect as no mask.\n  mask2dKeyPadding,      // [batch_size, total_sequence_length]\n  mask3dAttention,       // [batch_size, sequence_length, total_sequence_length]\n  mask4dMegatron,        // Megatron causal mask with shape [batch_size, 1, max_sequence_length, max_sequence_length]\n  maskUnknown\n}\n\nexport interface AttentionParameters {\n  batchSize: number;\n  sequenceLength: number;\n  pastSequenceLength: number;\n  kvSequenceLength: number;\n  totalSequenceLength: number;\n  maxSequenceLength: number;\n  inputHiddenSize: number;\n  hiddenSize: number;\n  vHiddenSize: number;\n  headSize: number;\n  vHeadSize: number;\n  numHeads: number;\n  isUnidirectional: boolean;\n  pastPresentShareBuffer: boolean;\n  maskFilterValue: number;\n  maskType: AttentionMaskType;\n  scale: number;\n  broadcastResPosBias: boolean;\n  passPastInKv: boolean;\n  qkvFormat: AttentionQkvFormat;\n}\n\nexport interface AttentionAttrs {\n  numHeads: number;\n  isUnidirectional: number;\n  maskFilterValue: number;\n  scale: number;\n  doRotary: number;\n  qkvHiddenSizes: number[];\n  pastPresentShareBuffer: boolean;\n}\n\nconst validateAttentionInputs = (inputs: readonly TensorView[], attributes: AttentionAttrs): AttentionParameters => {\n  // Abbreviation and Meanings:\n  //   B:    batch_size\n  //   S:    sequence_length (input sequence length of query)\n  //   P:    past_sequence_length (past sequence length of key or value)\n  //   L:    kv_sequence_length (input sequence length of key or value)\n  //   M:    max_sequence_length\n  //   T:    total_sequence_length = past_sequence_length + kv_sequence_length\n  //   N:    num_heads\n  //   H:    head size for Q and K, aka q_head_size or k_head_size or qk_head_size\n  //   H_v:  v_head_size\n  //   D_i:  input hidden size\n  //   D:    hidden size for Q and K (D = N * H), aka q_hidden_size or k_hidden_size or qk_hidden_size\n  //   D_v:  v_hidden_size = num_heads * v_head_size\n\n  // When past state is used, Q, K and V should have same hidden size (unless we split it into past_key and past_value).\n\n  // Input shapes:\n  //   input        (Q/K/V)    : (B, S, D_i)\n  //   weights      (Q/K/V)    : (D_i, D + D + D_v)\n  //   bias         (Q/K/V)    : (D + D + D_v)\n  //   mask_index              : see below\n  //   past         (K/V)      : (2, B, N, P, H) or NULL\n  //   relative_position_bias            : (B, N, S, T) or NULL\n\n  // For mask_index, the following shapes are supported:\n  //     NULL, (B, 1), (1, 1)\n  //     (B), (2 * B), (3 * B + 2)\n  //     (B, T)\n  //     (B, S, T)\n  //     (B, 1, M, M)\n  //\n  // When a model is pruned (like some attention heads are removed in Q/K/V), input_hidden_size could be larger\n  // than hidden dimension of Q, K and V.\n\n  const input = inputs[0];\n  const weights = inputs[1];\n  const bias = inputs[2];\n  const maskIndex = inputs[3];\n  const past = inputs[4];\n  const relativePositionBias = inputs[5];\n\n  if (past && relativePositionBias) {\n    throw new Error('Attention cannot have both past and relative_position_bias');\n  }\n\n  if (input.dims.length !== 3) {\n    throw new Error('Input \"input\" must have 3 dimensions');\n  }\n\n  const batchSize = input.dims[0];\n  const sequenceLength = input.dims[1];\n  const inputHiddenSize = input.dims[2];\n\n  if (bias.dims.length !== 1) {\n    throw new Error('Input \"bias\" is expected to have 1 dimensions');\n  }\n\n  if (weights.dims.length !== 2) {\n    throw new Error('Input \"weights\" is expected to have 2 dimensions');\n  }\n\n  if (weights.dims[0] !== inputHiddenSize) {\n    throw new Error('Input 1 dimension 0 should have same length as dimension 2 of input 0');\n  }\n\n  if (bias.dims[0] !== weights.dims[1]) {\n    throw new Error('Input \"bias\" dimension 0 should have same length as dimension 1 of input \"weights\"');\n  }\n\n  let qHiddenSize = bias.dims[0] / 3;\n  let kHiddenSize = qHiddenSize;\n  let vHiddenSize = kHiddenSize;\n  if (attributes.qkvHiddenSizes.length > 0) {\n    if (attributes.qkvHiddenSizes.length !== 3) {\n      throw new Error('qkv_hidden_sizes attribute should have 3 elements');\n    }\n    for (const sz of attributes.qkvHiddenSizes) {\n      if (sz % attributes.numHeads !== 0) {\n        throw new Error('qkv_hidden_sizes should be divisible by num_heads');\n      }\n    }\n\n    qHiddenSize = attributes.qkvHiddenSizes[0];\n    kHiddenSize = attributes.qkvHiddenSizes[1];\n    vHiddenSize = attributes.qkvHiddenSizes[2];\n  }\n\n  const kvSequenceLength = sequenceLength;\n\n  if (qHiddenSize !== kHiddenSize) {\n    throw new Error('qkv_hidden_sizes first element should be same as the second');\n  }\n\n  if (bias.dims[0] !== qHiddenSize + kHiddenSize + vHiddenSize) {\n    throw new Error('Input \"bias\" dimension 0 should have same length as sum of Q/K/V hidden sizes');\n  }\n\n  let pastSequenceLength = 0;\n  if (past) {\n    if (kHiddenSize !== vHiddenSize) {\n      throw new Error('Input \"past\" expect k_hidden_size == v_hidden_size');\n    }\n    if (past.dims.length !== 5) {\n      throw new Error('Input \"past\" must have 5 dimensions');\n    }\n    if (past.dims[0] !== 2) {\n      throw new Error('Input \"past\" first dimension must be 2');\n    }\n    if (past.dims[1] !== batchSize) {\n      throw new Error('Input \"past\" second dimension must be batch_size');\n    }\n    if (past.dims[2] !== attributes.numHeads) {\n      throw new Error('Input \"past\" third dimension must be num_heads');\n    }\n    if (past.dims[4] !== kHiddenSize / attributes.numHeads) {\n      throw new Error('Input \"past\" fifth dimension must be k_hidden_size / num_heads');\n    }\n\n    if (!attributes.pastPresentShareBuffer) {\n      pastSequenceLength = past.dims[3];\n    }\n    // TODO: handle past_seq_len\n  }\n\n  const totalSequenceLength = kvSequenceLength + pastSequenceLength;\n  const maxSequenceLength = -1;\n\n  const maskType = AttentionMaskType.none;\n  if (maskIndex) {\n    // maskType = AttentionMaskType.MASK_UNKNOWN;\n    // TODO: handle mask\n    throw new Error('Mask not supported');\n  }\n\n  if (past) {\n    throw new Error('past is not supported');\n  }\n\n  return {\n    batchSize,\n    sequenceLength,\n    pastSequenceLength,\n    kvSequenceLength,\n    totalSequenceLength,\n    maxSequenceLength,\n    inputHiddenSize,\n    hiddenSize: qHiddenSize,\n    vHiddenSize,\n    headSize: Math.floor(qHiddenSize / attributes.numHeads),\n    vHeadSize: Math.floor(vHiddenSize / attributes.numHeads),\n    numHeads: attributes.numHeads,\n    isUnidirectional: false,\n    pastPresentShareBuffer: false,\n    maskFilterValue: attributes.maskFilterValue,\n    maskType,\n    scale: attributes.scale,\n    broadcastResPosBias: false,\n    passPastInKv: false,\n    qkvFormat: AttentionQkvFormat.qkvBNSH,\n  };\n};\n\nconst createInPlaceSoftmaxProgramInfo = (_context: ComputeContext, input: TensorView, n: number, d: number) => {\n  const components = getMaxComponents(d);\n  let WG = 64;\n  const dComp = d / components;\n  if (dComp < WG) {\n    WG = 1;\n  } else if (dComp / 8 < 64) {\n    WG = Math.ceil(dComp / 8);\n  }\n  const elementsPerThread = Math.ceil(d / components / WG);\n  const programUniforms: ProgramUniform[] = [\n    {type: input.dataType, data: 1 / d}, {type: DataType.uint32, data: dComp},\n    {type: DataType.uint32, data: elementsPerThread}\n  ];\n  const dataType = tensorTypeToWsglStorageType(input.dataType, components);\n  const f32Type = tensorTypeToWsglValueType(DataType.float, components);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const inputHelper = outputVariable('x', input.dataType, input.dims, components);\n    const elemValueType = tensorTypeToWsglValueType(input.dataType);\n    const uniforms: UniformsArrayType = [\n      {name: 'd_inv', type: elemValueType as UniformDataElementType}, {name: 'd_comp', type: 'u32'},\n      {name: 'elements_per_thread', type: 'u32'}\n    ];\n\n    return `\n  var<workgroup> thread_max: array<f32, ${WG}>;\n  var<workgroup> thread_sum: array<f32, ${WG}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(inputHelper)}\n  ${shaderHelper.mainStart([\n      WG, 1, 1\n    ])}\n    let local_offset = local_idx * uniforms.elements_per_thread;\n    let offset = workgroup_id.x * uniforms.d_comp + local_offset;\n\n    var thread_max_vector = ${f32Type}(-3.402823e+38f);\n    for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n      thread_max_vector = max(${f32Type}(x[offset + i]), thread_max_vector);\n    }\n    thread_max[local_idx] = ${(() => {\n      switch (components) {\n        case 1:\n          return 'thread_max_vector';\n        case 2:\n          return 'max(thread_max_vector.x, thread_max_vector.y)';\n        case 4:\n          return 'max(max(thread_max_vector.x, thread_max_vector.y), max(thread_max_vector.z, thread_max_vector.w))';\n        default:\n          throw new Error(`Unsupported components: ${components}`);\n      }\n    })()};\n    workgroupBarrier();\n\n    var max_value =  f32(-3.402823e+38f);\n    for (var i = 0u; i < ${WG}; i++) {\n      max_value = max(thread_max[i], max_value);\n    }\n\n    var sum_vector = ${f32Type}(0);\n    for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n      sum_vector += exp(${f32Type}(x[offset + i]) - max_value);\n    }\n    thread_sum[local_idx] = ${(() => {\n      switch (components) {\n        case 1:\n          return 'sum_vector';\n        case 2:\n          return 'sum_vector.x + sum_vector.y';\n        case 4:\n          return 'sum_vector.x + sum_vector.y + sum_vector.z + sum_vector.w';\n        default:\n          throw new Error(`Unsupported components: ${components}`);\n      }\n    })()};\n    workgroupBarrier();\n\n    var sum: f32 = 0;\n    for (var i = 0u; i < ${WG}; i++) {\n      sum += thread_sum[i];\n    }\n\n    if (sum == 0) {\n      for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n        x[offset + i] = ${inputHelper.type.value}(uniforms.d_inv);\n      }\n    } else {\n      for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n        var f32input = ${f32Type}(x[offset + i]);\n        x[offset + i] = ${inputHelper.type.value}(exp(f32input - max_value) / sum);\n      }\n    }\n  }`;\n  };\n\n  return {\n    name: 'AttentionProbsSoftmax',\n    shaderCache: {hint: `${WG};${dataType};${components}`},\n    getShaderSource,\n    getRunData: () => ({outputs: [], dispatchGroup: {x: n}, programUniforms}),\n  };\n};\n\nconst createAttentionProbsProgramInfo =\n    (_context: ComputeContext, q: TensorView, key: TensorView, relativePositionBias: TensorView|undefined,\n     parameters: AttentionParameters, attributes: AttentionAttrs, pastSequenceLength: number) => {\n      const totalSequenceLength = pastSequenceLength + parameters.kvSequenceLength;\n      const probsShape = [parameters.batchSize, parameters.numHeads, parameters.sequenceLength, totalSequenceLength];\n\n      // TODO: handle mask\n\n      const alpha = attributes.scale === 0 ? 1.0 / Math.sqrt(parameters.headSize) : attributes.scale;\n      const components = getMaxComponents(parameters.headSize);\n      const vectorizedHeadSize = parameters.headSize / components;\n      const TILE_SIZE = 12;\n      const dispatch = {\n        x: Math.ceil(totalSequenceLength / TILE_SIZE),\n        y: Math.ceil(parameters.sequenceLength / TILE_SIZE),\n        z: parameters.batchSize * parameters.numHeads\n      };\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: parameters.sequenceLength}, {type: DataType.uint32, data: vectorizedHeadSize},\n        {type: DataType.uint32, data: totalSequenceLength}, {type: DataType.uint32, data: parameters.numHeads},\n        {type: DataType.float, data: alpha}\n      ];\n\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n      if (relativePositionBias) {\n        inputDependencies.push('rank');\n        programUniforms.push(...createTensorShapeVariables(relativePositionBias.dims));\n      }\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const qInput = inputVariable('q', q.dataType, q.dims, components);\n        const kInput = inputVariable('key', key.dataType, key.dims, components);\n        const inputVars = [qInput, kInput];\n        const relativePositionBiasInput = relativePositionBias ?\n            inputVariable('relative_position_bias', relativePositionBias.dataType, relativePositionBias.dims.length) :\n            undefined;\n        if (relativePositionBiasInput) {\n          inputVars.push(relativePositionBiasInput);\n        }\n        const output = outputVariable('output', q.dataType, probsShape);\n        // const dataType = tensorTypeToWsglStorageType(q.dataType);\n        const f32Type = tensorTypeToWsglValueType(DataType.float, components);\n\n        const uniforms: UniformsArrayType = [\n          {name: 'M', type: 'u32'}, {name: 'K', type: 'u32'}, {name: 'N', type: 'u32'},\n          {name: 'num_heads', type: 'u32'}, {name: 'alpha', type: 'f32' as UniformDataElementType}\n        ];\n        return `\n  const TILE_SIZE = ${TILE_SIZE}u;\n\n  var<workgroup> tileQ: array<${qInput.type.storage}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileK: array<${qInput.type.storage}, ${TILE_SIZE * TILE_SIZE}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}\n  ${shaderHelper.mainStart([\n          TILE_SIZE, TILE_SIZE, 1\n        ])}\n    // x holds the N and y holds the M\n    let headIdx = workgroup_id.z;\n    let m = workgroup_id.y * TILE_SIZE;\n    let n = workgroup_id.x * TILE_SIZE;\n    let qOffset = uniforms.M * uniforms.K * headIdx + m * uniforms.K;\n    let kOffset = uniforms.N * uniforms.K * headIdx + n * uniforms.K;\n\n    var value = ${f32Type}(0);\n    for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n      if (global_id.y < uniforms.M && w + local_id.x < uniforms.K) {\n        tileQ[TILE_SIZE * local_id.y + local_id.x] = q[qOffset + local_id.y * uniforms.K + w + local_id.x];\n      }\n      if (n + local_id.y < uniforms.N && w + local_id.x < uniforms.K) {\n        tileK[TILE_SIZE * local_id.y + local_id.x] = key[kOffset + local_id.y * uniforms.K + w + local_id.x];\n      }\n      workgroupBarrier();\n\n      for (var k: u32 = 0u; k < TILE_SIZE && w+k < uniforms.K; k++) {\n        value += ${f32Type}(tileQ[TILE_SIZE * local_id.y + k] * tileK[TILE_SIZE * local_id.x + k]);\n      }\n\n      workgroupBarrier();\n    }\n\n    let headOffset = headIdx * uniforms.M * uniforms.N;\n    if (global_id.y < uniforms.M && global_id.x < uniforms.N) {\n      let outputIdx = headOffset + global_id.y * uniforms.N + global_id.x;\n      var sum: f32 = ${(() => {\n          switch (components) {\n            case 1:\n              return 'value';\n            case 2:\n              return 'value.x + value.y';\n            case 4:\n              return 'value.x + value.y + value.z + value.w';\n            default:\n              throw new Error(`Unsupported components: ${components}`);\n          }\n        })()};\n\n  ${(() => {\n          if (relativePositionBiasInput) {\n            return `\n      let batch = workgroup_id.z / uniforms.num_heads;\n      let head = workgroup_id.z % uniforms.num_heads;\n      var indices = ${relativePositionBiasInput.type.indices}(batch, head, global_id.y, global_id.x);\n      output[outputIdx] = ${output.type.value}(sum * uniforms.alpha) + ${\n                relativePositionBiasInput.getByIndices('indices')};`;\n          }\n          return `output[outputIdx] = ${output.type.value} (sum * uniforms.alpha);`;\n        })()}\n    }\n  }`;\n      };\n      return {\n        name: 'AttentionProbs',\n        shaderCache: {hint: `${components}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: probsShape, dataType: q.dataType, gpuDataType: GpuDataType.default}],\n          dispatchGroup: dispatch,\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n\n\nconst createVxAttentionScoreProgramInfo =\n    (_context: ComputeContext, probs: TensorView, v: TensorView, params: AttentionParameters,\n     pastSequenceLength: number) => {\n      const totalSequenceLength = pastSequenceLength + params.kvSequenceLength;\n      const outputShape = [params.batchSize, params.sequenceLength, params.vHiddenSize];\n      const TILE_SIZE = 12;\n      const dispatch = {\n        x: Math.ceil(params.vHeadSize / TILE_SIZE),\n        y: Math.ceil(params.sequenceLength / TILE_SIZE),\n        z: params.batchSize * params.numHeads\n      };\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: params.sequenceLength}, {type: DataType.uint32, data: totalSequenceLength},\n        {type: DataType.uint32, data: params.vHeadSize}, {type: DataType.uint32, data: params.numHeads},\n        {type: DataType.uint32, data: params.vHiddenSize}\n      ];\n\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const probsHelper = inputVariable('probs', probs.dataType, probs.dims);\n        const vHelper = inputVariable('v', v.dataType, v.dims);\n        const output = outputVariable('output', probs.dataType, outputShape);\n        const uniforms: UniformsArrayType = [\n          {name: 'M', type: 'u32'}, {name: 'K', type: 'u32'}, {name: 'N', type: 'u32'},\n          {name: 'num_heads', type: 'u32'}, {name: 'v_hidden_size', type: 'u32'}\n        ];\n        return `\n  const TILE_SIZE = ${TILE_SIZE}u;\n  var<workgroup> tileQ: array<${probsHelper.type.value}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileK: array<${probsHelper.type.value}, ${TILE_SIZE * TILE_SIZE}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(probsHelper, vHelper, output)}\n  ${shaderHelper.mainStart([\n          TILE_SIZE, TILE_SIZE, 1\n        ])}\n   let headIdx = workgroup_id.z;\n   let m = global_id.y;\n   let n = global_id.x;\n\n   let offsetA = headIdx * (uniforms.M * uniforms.K) + m * uniforms.K;\n   let offsetB = headIdx * (uniforms.N * uniforms.K) + n;\n\n   var value = ${probsHelper.type.storage}(0);\n   for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n     if (m < uniforms.M && w + local_id.x < uniforms.K) {\n       tileQ[TILE_SIZE * local_id.y + local_id.x] = probs[offsetA + w + local_id.x];\n     }\n     if (n < uniforms.N && w + local_id.y < uniforms.K) {\n       tileK[TILE_SIZE * local_id.y + local_id.x] = v[offsetB + (w + local_id.y) * uniforms.N];\n     }\n     workgroupBarrier();\n     for (var k: u32 = 0u; k < TILE_SIZE && w+k < uniforms.K; k++) {\n       value += tileQ[TILE_SIZE * local_id.y + k] * tileK[TILE_SIZE * k + local_id.x];\n     }\n     workgroupBarrier();\n   }\n\n   // we need to transpose output from BNSH_v to BSND_v\n   let batchIdx = workgroup_id.z / uniforms.num_heads;\n   let currentBatchHeadNumber = workgroup_id.z % uniforms.num_heads;\n   if (m < uniforms.M && n < uniforms.N) {\n     let outputIdx = batchIdx * uniforms.M * uniforms.v_hidden_size + m * uniforms.v_hidden_size\n       + currentBatchHeadNumber * uniforms.N + n;\n     output[outputIdx] = value;\n   }\n  }`;\n      };\n\n      return {\n        name: 'AttentionScore',\n        shaderCache: {inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: probs.dataType, gpuDataType: GpuDataType.default}],\n          dispatchGroup: dispatch,\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n\nexport const applyAttention =\n    (context: ComputeContext, q: TensorView, k: TensorView, v: TensorView, _maskIndex: TensorView|undefined,\n     _past: TensorView|undefined, pastKey: TensorView|undefined, pastValue: TensorView|undefined,\n     relativePositionBias: TensorView|undefined, parameters: AttentionParameters, attributes: AttentionAttrs) => {\n      const outputPresentKey = context.outputCount > 1;\n      const outputPresentValue = context.outputCount > 2;\n      const pastSequenceLength = (outputPresentKey && outputPresentValue) ? parameters.pastSequenceLength : 0;\n      const totalSequenceLength = pastSequenceLength + parameters.kvSequenceLength;\n      // Concatinate pastKey and K to produce presentKey.\n      const presentKeyShape = [parameters.batchSize, parameters.numHeads, totalSequenceLength, parameters.headSize];\n      const concatKeyInputs = pastKey ? [pastKey, k] : [k];\n      const key = outputPresentKey ? context.compute(\n                                         createConcatProgramInfo(concatKeyInputs, 2, presentKeyShape, k.dataType),\n                                         {inputs: concatKeyInputs, outputs: [1]})[0] :\n                                     k;\n\n      // Concatinate pastValue and V to produce presentValue.\n      const presentValueShape = [parameters.batchSize, parameters.numHeads, totalSequenceLength, parameters.headSize];\n      const concatValueInputs = pastValue ? [pastValue, v] : [v];\n      const value = outputPresentValue ?\n          context.compute(\n              createConcatProgramInfo(concatValueInputs, 2, presentValueShape, v.dataType),\n              {inputs: concatValueInputs, outputs: [2]})[0] :\n          v;\n      const inputsK = [q, key];\n      if (relativePositionBias) {\n        inputsK.push(relativePositionBias);\n      }\n\n      // Run AttentionProbs\n      const probs = context.compute(\n          createAttentionProbsProgramInfo(\n              context, q, key, relativePositionBias, parameters, attributes, pastSequenceLength),\n          {inputs: inputsK, outputs: [-1]})[0];\n\n      // Run Softmax\n      context.compute(\n          createInPlaceSoftmaxProgramInfo(\n              context, probs, parameters.batchSize * parameters.numHeads * parameters.sequenceLength,\n              totalSequenceLength),\n          {inputs: [probs], outputs: []});\n\n      // Run AttrionScore\n      const inputsV = [probs, value];\n      context.compute(\n          createVxAttentionScoreProgramInfo(context, probs, value, parameters, pastSequenceLength),\n          {inputs: inputsV, outputs: [0]});\n    };\n\nconst prepare = (context: ComputeContext, parameters: AttentionParameters) => {\n  const outputShape = [\n    parameters.batchSize,\n    parameters.numHeads,\n    parameters.sequenceLength,\n    parameters.headSize,\n  ];\n  const M = parameters.sequenceLength;\n  const K = parameters.inputHiddenSize;\n  const N = parameters.headSize;\n  const TILE_SIZE = 12;\n  const dispatch = {\n    x: Math.ceil(parameters.headSize / TILE_SIZE),\n    y: Math.ceil(parameters.sequenceLength / TILE_SIZE),\n    z: parameters.batchSize * parameters.numHeads\n  };\n  const inputs = [context.inputs[0], context.inputs[1], context.inputs[2]];\n  const programUniforms: ProgramUniform[] = [\n    {type: DataType.uint32, data: M}, {type: DataType.uint32, data: K}, {type: DataType.uint32, data: N},\n    {type: DataType.uint32, data: parameters.numHeads}, {type: DataType.uint32, data: parameters.headSize},\n    {type: DataType.uint32, data: parameters.hiddenSize},\n    {type: DataType.uint32, data: parameters.hiddenSize + parameters.hiddenSize + parameters.vHiddenSize}\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const outputQ = outputVariable('output_q', inputs[0].dataType, outputShape);\n    const outputK = outputVariable('output_k', inputs[0].dataType, outputShape);\n    const outputV = outputVariable('output_v', inputs[0].dataType, outputShape);\n    const input = inputVariable('input', inputs[0].dataType, inputs[0].dims);\n    const weight = inputVariable('weight', inputs[1].dataType, inputs[1].dims);\n    const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims);\n    const dataType = input.type.storage;\n\n    const uniforms: UniformsArrayType = [\n      {name: 'M', type: 'u32'}, {name: 'K', type: 'u32'}, {name: 'N', type: 'u32'}, {name: 'num_heads', type: 'u32'},\n      {name: 'head_size', type: 'u32'}, {name: 'hidden_size', type: 'u32'}, {name: 'ldb', type: 'u32'}\n    ];\n    return `\n  const TILE_SIZE = ${TILE_SIZE}u;\n  var<workgroup> tileInput: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileWeightQ: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileWeightK: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileWeightV: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(input, weight, bias, outputQ, outputK, outputV)}\n  ${shaderHelper.mainStart([\n      TILE_SIZE, TILE_SIZE, 1\n    ])}\n    let batchIndex = workgroup_id.z / uniforms.num_heads;\n    let headNumber = workgroup_id.z % uniforms.num_heads;\n    let m = global_id.y;\n    let n = global_id.x;\n\n    let inputOffset = batchIndex * (uniforms.M * uniforms.K) + m * uniforms.K;\n    let biasOffsetQ = headNumber * uniforms.head_size;\n    let biasOffsetK = uniforms.hidden_size + biasOffsetQ;\n    let biasOffsetV = uniforms.hidden_size + biasOffsetK;\n\n    var valueQ = ${dataType}(0);\n    var valueK = ${dataType}(0);\n    var valueV = ${dataType}(0);\n    for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n      if (m < uniforms.M && w + local_id.x < uniforms.K) {\n        tileInput[TILE_SIZE * local_id.y + local_id.x] = input[inputOffset + w + local_id.x];\n      }\n      if (n < uniforms.N && w + local_id.y < uniforms.K) {\n        let offset = n + (w + local_id.y) * uniforms.ldb;\n        tileWeightQ[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetQ + offset];\n        tileWeightK[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetK + offset];\n        tileWeightV[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetV + offset];\n      }\n      workgroupBarrier();\n      for (var k: u32 = 0u; k<TILE_SIZE && w+k < uniforms.K; k++) {\n        let inputTileOffset = TILE_SIZE * local_id.y + k;\n        let weightTileOffset = TILE_SIZE * k + local_id.x;\n        valueQ += tileInput[inputTileOffset] * tileWeightQ[weightTileOffset];\n        valueK += tileInput[inputTileOffset] * tileWeightK[weightTileOffset];\n        valueV += tileInput[inputTileOffset] * tileWeightV[weightTileOffset];\n      }\n\n      workgroupBarrier();\n    }\n\n    let headOffset = (m * uniforms.N + n) % uniforms.head_size;\n    valueQ += bias[headOffset + biasOffsetQ];\n    valueK += bias[headOffset + biasOffsetK];\n    valueV += bias[headOffset + biasOffsetV];\n\n    let offset = workgroup_id.z * uniforms.M * uniforms.N;\n    if (m < uniforms.M && n < uniforms.N) {\n      let outputIdx = offset + m * uniforms.N + n;\n      output_q[outputIdx] = valueQ;\n      output_k[outputIdx] = valueK;\n      output_v[outputIdx] = valueV;\n    }\n  }`;\n  };\n\n  return context.compute(\n      {\n        name: 'AttentionPrepare',\n        shaderCache: {inputDependencies: ['type', 'type', 'type']},\n        getRunData: () => ({\n          outputs: [\n            {dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: GpuDataType.default},\n            {dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: GpuDataType.default},\n            {dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: GpuDataType.default},\n          ],\n          dispatchGroup: dispatch,\n          programUniforms\n        }),\n        getShaderSource,\n      },\n      {inputs, outputs: [-1, -1, -1]});\n};\n\nexport const attention = (context: ComputeContext, attributes: AttentionAttrs): void => {\n  const params = validateAttentionInputs(context.inputs, attributes);\n\n  const [q, k, v] = prepare(context, params);\n\n  return applyAttention(\n      context, q, k, v, context.inputs[4], undefined, undefined, undefined, context.inputs[5], params, attributes);\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {env} from 'onnxruntime-common';\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, getMaxComponents, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface BatchNormAttributes extends AttributeWithCacheKey {\n  readonly epsilon: number;\n  readonly momentum: number;\n  readonly spatial: boolean;\n  readonly trainingMode: boolean;\n  readonly format: 'NHWC'|'NCHW';\n  readonly outputCount: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: BatchNormAttributes): void => {\n  if (!inputs || inputs.length !== 5) {\n    throw new Error('BatchNormalization requires 5 inputs');\n  }\n\n  const checkShapeEqual = (actual: readonly number[], expected: readonly number[], message: string) => {\n    const r = expected.length;\n    if (r !== actual.length) {\n      throw new Error(`${message}: num dimensions != ${r}`);\n    }\n    expected.forEach((v, i) => {\n      if (v !== actual[i]) {\n        throw new Error(`${message}: dim[${i}] do not match`);\n      }\n    });\n  };\n\n  if (inputs[0].dims.length > 1) {\n    const shape = attributes.format === 'NHWC' ?\n        (attributes.spatial ? inputs[0].dims.slice(-1) :\n                              inputs[0].dims.slice(-1).concat(inputs[0].dims.slice(1, inputs[0].dims.length - 1))) :\n        inputs[0].dims.slice(1, attributes.spatial ? 2 : undefined);\n    checkShapeEqual(inputs[1].dims, shape, 'Invalid input scale');\n    checkShapeEqual(inputs[2].dims, shape, 'Invalid input B');\n    checkShapeEqual(inputs[3].dims, shape, 'Invalid input mean');\n    checkShapeEqual(inputs[4].dims, shape, 'Invalid input var');\n  } else {\n    checkShapeEqual(inputs[1].dims, [1], 'Invalid input scale');\n    checkShapeEqual(inputs[2].dims, [1], 'Invalid input B');\n    checkShapeEqual(inputs[3].dims, [1], 'Invalid input mean');\n    checkShapeEqual(inputs[4].dims, [1], 'Invalid input var');\n  }\n};\n\nconst createBatchNormInferenceProgramInfo =\n    (inputs: readonly TensorView[], attributes: BatchNormAttributes): ProgramInfo => {\n      const {epsilon, spatial, format} = attributes;\n      const yShape = inputs[0].dims;\n      const components = spatial ? getMaxComponents(yShape[yShape.length - 1]) : 1;\n      const cComponents = format === 'NHWC' && yShape.length > 1 ? components : 1;\n      const outputSize = ShapeUtil.size(yShape) / components;\n      // Only support uniforms for opset version >= 9 (spatial = true).\n      const useShapesUniforms = spatial;\n      const shapeOrRank = useShapesUniforms ? yShape.length : yShape;\n      const x = inputVariable('x', inputs[0].dataType, inputs[0].dims, components);\n      const scale = inputVariable('scale', inputs[1].dataType, inputs[1].dims, cComponents);\n      const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims, cComponents);\n      const inputMean = inputVariable('inputMean', inputs[3].dataType, inputs[3].dims, cComponents);\n      const inputVar = inputVariable('inputVar', inputs[4].dataType, inputs[4].dims, cComponents);\n      const y = outputVariable('y', inputs[0].dataType, shapeOrRank, components);\n      // TODO: support inputs with different data type. Current we need to make sure all inputs have the same data type.\n      // Otherwise, the shader compilation will fail.\n      const calcCOffset = (): string => {\n        let cOffset = '';\n        if (spatial) {\n          cOffset = `let cOffset = ${\n              yShape.length === 1   ? '0u' :\n                  format === 'NHWC' ? `outputIndices[${yShape.length - 1}] / ${components}` :\n                                      'outputIndices[1]'};`;\n        } else {\n          if (format === 'NCHW') {\n            cOffset = `\n            ${y.indicesSet('outputIndices', '0', '0')}\n            let cOffset = ${y.indicesToOffset('outputIndices')};`;\n          } else {\n            // update C channel.\n            cOffset = `var cIndices = ${scale.type.indices}(0);\n                       cIndices[0] = outputIndices[${yShape.length - 1}];`;\n            // update D1 x ... x Dn channels.\n            for (let i = 1; i < scale.rank; i++) {\n              cOffset += `cIndices[${i}] = outputIndices[${i}];`;\n            }\n            cOffset += `let cOffset = ${scale.indicesToOffset('cIndices')};`;\n          }\n        }\n        return cOffset;\n      };\n      const getInferenceModeShaderSource = (helper: ShaderHelper) => `\n  const epsilon = ${epsilon};\n  ${helper.registerUniform('outputSize', 'u32').declareVariables(x, scale, bias, inputMean, inputVar, y)}\n  ${helper.mainStart()}\n  ${helper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n    var outputIndices = ${y.offsetToIndices(`global_idx * ${components}`)};\n    ${calcCOffset()}\n    let scale = ${scale.getByOffset('cOffset')};\n    let bias = ${bias.getByOffset('cOffset')};\n    let inputMean = ${inputMean.getByOffset('cOffset')};\n    let inputVar = ${inputVar.getByOffset('cOffset')};\n    let x = ${x.getByOffset('global_idx')};\n    let value = (x - inputMean) * inverseSqrt(inputVar + epsilon) * scale + bias;\n    ${y.setByOffset('global_idx', 'value')}\n  }`;\n      return {\n        name: 'BatchNormalization',\n        shaderCache: {\n          hint: `${attributes.epsilon}_${attributes.format}_${spatial}_${components}`,\n          inputDependencies: useShapesUniforms ? ['rank', 'type', 'type', 'type', 'type'] : undefined,\n        },\n        getShaderSource: getInferenceModeShaderSource,\n        getRunData: () => ({\n          outputs: [{dims: inputs[0].dims, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms: useShapesUniforms ?\n              [\n                {type: DataType.uint32, data: outputSize},\n                ...createTensorShapeVariables(yShape),\n              ] :\n              [\n                {type: DataType.uint32, data: outputSize},\n              ],\n        }),\n      };\n    };\n\nexport const parseBatchNormAttributes = (attributes: Record<string, unknown>): BatchNormAttributes =>\n    createAttributeWithCacheKey(attributes as Omit<BatchNormAttributes, keyof AttributeWithCacheKey>);\n\nexport const batchNorm = (context: ComputeContext, attributes: Record<string, unknown>): void => {\n  const {inputs, outputCount} = context;\n  const updatedAttributes = parseBatchNormAttributes({...attributes, outputCount});\n  if (env.webgpu.validateInputContent) {\n    validateInputs(inputs, updatedAttributes);\n  }\n  if (attributes.trainingMode) {\n    throw new Error('BatchNormalization trainingMode is not supported yet.');\n  } else {\n    context.compute(createBatchNormInferenceProgramInfo(inputs, updatedAttributes));\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {inputVariable, outputVariable, ShaderHelper} from './common';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (inputs[0].dims.length !== 3) {\n    throw new Error('input should have 3 dimensions');\n  }\n\n  if (![320, 640, 1280].includes(inputs[0].dims[2])) {\n    throw new Error('number of channels should be 320, 640 or 1280');\n  }\n\n  if (inputs[1].dims.length !== 1) {\n    throw new Error('bias is expected to have 1 dimensions');\n  }\n\n  if (inputs[0].dims[2] !== inputs[1].dims[0]) {\n    throw new Error('last dimension of input and bias are not the same');\n  }\n};\n\nconst createBiasAddProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const outputShape = inputs[0].dims;\n\n  const channels = inputs[0].dims[2];\n  // since channel number can be only 320/640/1280, it's always divisable by 4\n  const outputSize = ShapeUtil.size(outputShape) / 4;\n\n  const dataType = inputs[0].dataType;\n  const input = inputVariable('input', dataType, outputShape, 4);\n  const bias = inputVariable('bias', dataType, [channels], 4);\n  const residual = inputVariable('residual', dataType, outputShape, 4);\n  const output = outputVariable('output', dataType, outputShape, 4);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  const channels = ${channels}u / 4;\n  ${shaderHelper.declareVariables(input, bias, residual, output)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}\n    let value = ${input.getByOffset('global_idx')}\n      + ${bias.getByOffset('global_idx % channels')} + ${residual.getByOffset('global_idx')};\n    ${output.setByOffset('global_idx', 'value')}\n  }`;\n\n  return {\n    name: 'BiasAdd',\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)}\n    }),\n    getShaderSource,\n  };\n};\n\nexport const biasAdd = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  context.compute(createBiasAddProgramInfo(context.inputs));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {MAX_CLIP, MIN_CLIP, ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglValueType} from './common';\n\ntype BuiltinFunctionName = string;\ntype ElementwiseCustomExpression = (expression: string) => string;\ntype ElementwiseFunctionCall = BuiltinFunctionName|ElementwiseCustomExpression;\n\nconst createElementwiseProgramShader =\n    (shaderHelper: ShaderHelper, datasize: number, inputDataType: number, outputDataType: number,\n     funcCall: ElementwiseFunctionCall, additionalImplementation?: string): string => {\n      const vecSize = Math.ceil(datasize / 4);\n\n      let expression = '';\n      if (typeof funcCall === 'string') {\n        expression = `${funcCall}(a)`;\n      } else {\n        expression = funcCall('a');\n      }\n\n      const input = inputVariable('inputData', inputDataType, [vecSize], 4);\n      const output = outputVariable('outputData', outputDataType, [vecSize], 4);\n\n      return `\n      ${shaderHelper.registerUniform('vec_size', 'u32').declareVariables(input, output)}\n\n  ${additionalImplementation ?? ''}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.vec_size')}\n\n    let a = ${input.getByOffset('global_idx')};\n    ${output.setByOffset('global_idx', expression)}\n  }`;\n    };\n\nconst createElementwiseProgramInfo =\n    (input: TensorView, name: string, funcCall: ElementwiseFunctionCall, additionalImplementation?: string,\n     cacheKey?: string, outputDataType: number = input.dataType): ProgramInfo => ({\n      name,\n      shaderCache: {hint: cacheKey, inputDependencies: ['type']},\n      getShaderSource: shaderHelper => createElementwiseProgramShader(\n          shaderHelper, ShapeUtil.size(input.dims), input.dataType, outputDataType, funcCall, additionalImplementation),\n      getRunData: (inputTensors) => ({\n        outputs: [{dims: input.dims, dataType: outputDataType}],\n        dispatchGroup:\n            {x: Math.ceil(ShapeUtil.size(inputTensors[0].dims) / 64 /* workgroup size */ / 4 /* vec size */)},\n        programUniforms: [\n          {type: DataType.uint32, data: Math.ceil(ShapeUtil.size(input.dims) / 4)},\n        ],\n      })\n    });\n\nexport const abs = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Abs', 'abs'));\n};\n\nexport const acos = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Acos', 'acos'));\n};\n\nexport const acosh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Acosh', 'acosh'));\n};\n\nexport const asin = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Asin', 'asin'));\n};\n\nexport const asinh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Asinh', 'asinh'));\n};\n\nexport const atan = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Atan', 'atan'));\n};\nexport const atanh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Atanh', 'atanh'));\n};\n\nexport interface CastAttributes extends AttributeWithCacheKey {\n  readonly to: number;\n  readonly saturate?: boolean;\n}\n\nexport const parseCastAttributes = (attributes: Record<string, unknown>): CastAttributes =>\n    createAttributeWithCacheKey(attributes as {to: number});\n\n\nexport const cast = (context: ComputeContext, attributes: CastAttributes): void => {\n  let func: ElementwiseFunctionCall;\n  switch (attributes.to) {\n    case DataType.float16:\n      func = 'vec4<f16>';\n      break;\n    case DataType.float:\n      func = 'vec4<f32>';\n      break;\n    case DataType.uint32:\n      func = 'vec4<u32>';\n      break;\n    case DataType.int32:\n      func = 'vec4<i32>';\n      break;\n    case DataType.bool:\n      func = 'vec4<bool>';\n      break;\n    default:\n      throw new RangeError(`not supported type (specified in attribute 'to' from 'Cast' operator): ${attributes.to}`);\n  }\n  context.compute(\n      createElementwiseProgramInfo(context.inputs[0], 'Cast', func, undefined, attributes.cacheKey, attributes.to));\n};\n\nexport interface ClipAttributes extends AttributeWithCacheKey {\n  readonly min: number;\n  readonly max: number;\n}\n\nconst generateClipAttributesFromInputs = (inputs: readonly TensorView[]): ClipAttributes => {\n  const min = (inputs.length >= 2 && inputs[1].data !== 0) ? inputs[1].getFloat32Array()[0] : MIN_CLIP;\n  const max = (inputs.length >= 3 && inputs[2].data !== 0) ? inputs[2].getFloat32Array()[0] : MAX_CLIP;\n  return createAttributeWithCacheKey({min, max});\n};\n\nexport const clip = (context: ComputeContext, clipAttributes: ClipAttributes): void => {\n  const attributes = context.inputs.length === 1 ? clipAttributes : generateClipAttributesFromInputs(context.inputs);\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(\n      createElementwiseProgramInfo(\n          context.inputs[0], 'Clip', a => `clamp(${a}, clip_min_, clip_max_)`, `\n    const clip_min_: vec4<${dataType}> = vec4(${dataType}(${attributes.min}));\n    const clip_max_: vec4<${dataType}> = vec4(${dataType}(${attributes.max}));\n`,\n          attributes.cacheKey),\n      {inputs: [0]});\n};\n\nexport const ceil = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Ceil', 'ceil'));\n};\n\nexport const cos = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Cos', 'cos'));\n};\n\nexport const cosh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Cosh', 'cosh'));\n};\n\nexport interface AlphaAttributes extends AttributeWithCacheKey {\n  readonly alpha: number;\n}\n\nexport const parseAlphaAttributes = (attributes: Record<string, unknown>): AlphaAttributes =>\n    createAttributeWithCacheKey(attributes as {alpha: number});\n\nexport const elu = (context: ComputeContext, attributes: AlphaAttributes): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'Elu', a => `elu_vf32(${a})`, `\n  const elu_alpha_ = ${dataType}(${attributes.alpha});\n\n  fn elu_f32(a: ${dataType}) -> ${dataType} {\n  return select((exp(a) - 1.0) * elu_alpha_, a, a >= 0.0);\n  }\n\n  fn elu_vf32(v: vec4<${dataType}>) -> vec4<${dataType}> {\n  return vec4(elu_f32(v.x), elu_f32(v.y), elu_f32(v.z), elu_f32(v.w));\n  }`,\n      attributes.cacheKey));\n};\n\nexport const erfImpl = (varType = 'f32') => `\nconst r0: ${varType} = 0.3275911;\nconst r1: ${varType} = 0.254829592;\nconst r2: ${varType} = -0.284496736;\nconst r3: ${varType} = 1.421413741;\nconst r4: ${varType} = -1.453152027;\nconst r5: ${varType} = 1.061405429;\n\nfn erf_vf32(v: vec4<${varType}>) -> vec4<${varType}> {\n  let absv = abs(v);\n  let x = 1.0 / (1.0 + r0 * absv);\n  return sign(v) * (1.0 - ((((r5 * x + r4) * x + r3) * x + r2) * x + r1) * x * exp(-absv * absv));\n}`;\n\nexport const erf = (context: ComputeContext): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Erf', a => `erf_vf32(${a})`, erfImpl(dataType)));\n};\n\nexport const exp = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Exp', 'exp'));\n};\n\nexport const floor = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Floor', 'floor'));\n};\n\nexport const gelu = (context: ComputeContext): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'Gelu', a => `0.5 * ${a} * (1.0 + erf_vf32(${a} * 0.7071067811865475))`, erfImpl(dataType)));\n};\n\nexport const leakyRelu = (context: ComputeContext, attributes: AlphaAttributes): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'LeakyRelu', a => `select(leaky_relu_alpha_ * ${a}, ${a}, ${a} >= vec4<${dataType}>(0.0))`,\n      `const leaky_relu_alpha_ = ${dataType}(${attributes.alpha});`, attributes.cacheKey));\n};\n\nexport const not = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Not', a => `!${a}`));\n};\n\nexport const neg = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Neg', a => `-${a}`));\n};\n\nexport const reciprocal = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Reciprocal', a => `1.0/${a}`));\n};\n\nexport const relu = (context: ComputeContext): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'Relu', a => `select(vec4<${dataType}>(0.0), ${a}, ${a} > vec4<${dataType}>(0.0))`));\n};\n\nexport const sigmoid = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Sigmoid', a => `(1.0 / (1.0 + exp(-${a})))`));\n};\n\nexport interface HardSigmoidAttributes extends AttributeWithCacheKey {\n  readonly alpha: number;\n  readonly beta: number;\n}\n\nexport const parseHardSigmoidAttributes = (attributes: Record<string, unknown>): HardSigmoidAttributes =>\n    createAttributeWithCacheKey(attributes as {\n      alpha: number;\n      beta: number;\n    });\n\nexport const hardSigmoid = (context: ComputeContext, attributes: HardSigmoidAttributes): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'HardSigmoid',\n      a => `max(vec4<${dataType}>(0.0), min(vec4<${dataType}>(1.0), ${attributes.alpha} * ${a} + vec4<${dataType}>(${\n          attributes.beta})))`,\n      undefined, attributes.cacheKey));\n};\n\nexport const sin = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Sin', 'sin'));\n};\n\nexport const sinh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Sinh', 'sinh'));\n};\n\nexport const sqrt = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Sqrt', 'sqrt'));\n};\n\nexport const tan = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Tan', 'tan'));\n};\n\nexport const tanhExpression = (a: string) => `sign(${a}) * (1 - exp(-2 * abs(${a}))) / (1 + exp(-2 * abs(${a})))`;\n\nexport const tanh = (context: ComputeContext): void => {\n  // TODO: revisit after https://github.com/gpuweb/gpuweb/issues/4458 is resolved\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Tanh', tanhExpression));\n};\n\nexport const fastGeluImpl = (varType = 'f32') => `\nconst fast_gelu_a: ${varType} = 0.5;\nconst fast_gelu_b: ${varType} = 0.7978845608028654;\nconst fast_gelu_c: ${varType} = 0.035677408136300125;\n\nfn tanh_v(v: vec4<${varType}>) -> vec4<${varType}> {\n  return ${tanhExpression('v')};\n}\n`;\n\nexport const fastGeluExpression = (x: string) =>\n    `(fast_gelu_a + fast_gelu_a * tanh_v(${x} * (fast_gelu_c * ${x} * ${x} + fast_gelu_b))) * ${x}`;\n\nexport const fastGelu = (context: ComputeContext): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'FastGelu', fastGeluExpression, fastGeluImpl(dataType), undefined,\n      context.inputs[0].dataType));\n};\n\nexport const thresholdedRelu = (context: ComputeContext, attributes: AlphaAttributes): number => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'ThresholdedRelu', a => `select(vec4<${dataType}>(0.0), ${a}, ${a} > thresholded_relu_alpha_)`,\n      `const thresholded_relu_alpha_ = vec4<${dataType}>(${attributes.alpha});`, attributes.cacheKey));\n  return 0;\n};\n\nexport const log = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Log', 'log'));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType} from './common';\nimport {erfImpl} from './unary-op';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (inputs[0].dims.length !== 3) {\n    throw new Error('input should have 3 dimensions');\n  }\n\n  if (![2560, 5120, 10240].includes(inputs[0].dims[2])) {\n    throw new Error('hidden state should be 2560, 5120 or 10240');\n  }\n\n  if (inputs[1].dims.length !== 1) {\n    throw new Error('bias is expected to have 1 dimensions');\n  }\n\n  if (inputs[0].dims[2] !== inputs[1].dims[0]) {\n    throw new Error('last dimension of input and bias are not the same');\n  }\n};\n\nconst createBiasSplitGeluProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const outputShape = inputs[0].dims.slice();\n  outputShape[2] = outputShape[2] / 2;\n\n  const input = inputVariable('input', inputs[0].dataType, inputs[0].dims, 4);\n  const bias = inputVariable('bias', inputs[0].dataType, [inputs[0].dims[2]], 4);\n  const output = outputVariable('output', inputs[0].dataType, outputShape, 4);\n\n  const outputSize = ShapeUtil.size(outputShape) / 4;\n  const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  const M_SQRT2 = sqrt(2.0);\n  const halfChannels = ${inputs[0].dims[2] / 4 / 2}u;\n\n  ${shaderHelper.declareVariables(input, bias, output)}\n\n  ${erfImpl(dataType)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}\n    let biasIdx = global_idx % halfChannels;\n    let batchIndex = global_idx / halfChannels;\n    let inputOffset = biasIdx + batchIndex * halfChannels * 2;\n    let valueLeft = input[inputOffset] + bias[biasIdx];\n    let valueRight = input[inputOffset + halfChannels] + bias[biasIdx + halfChannels];\n    let geluRight = valueRight * 0.5 * (erf_vf32(valueRight / M_SQRT2) + 1);\n\n    ${output.setByOffset('global_idx', 'valueLeft * geluRight')}\n  }`;\n\n  return {\n    name: 'BiasSplitGelu',\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)}\n    }),\n    getShaderSource,\n  };\n};\n\nexport const biasSplitGelu = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  context.compute(createBiasSplitGeluProgramInfo(context.inputs));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {BroadcastUtil, ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\ntype BuiltinFunctionName = string;\ntype BinaryCustomExpression = (expressionA: string, expressionB: string) => string;\ntype BinaryFunctionCall = BuiltinFunctionName|BinaryCustomExpression|{\n  scalar: BinaryCustomExpression;\n  vector: BinaryCustomExpression;\n};\n\nconst createBinaryOpProgramShader =\n    (shaderHelper: ShaderHelper, dimsA: readonly number[], dimsB: readonly number[], dimsOutput: readonly number[],\n     vectorize: boolean, doBroadcast: boolean, sharedDimensionDivisibleBy4: boolean, funcCall: BinaryFunctionCall,\n     typeA: number, typeB: number, typeOutput: number, additionalImplementation?: string) => {\n      let expressionScalar: BinaryCustomExpression;\n      let expressionVector: BinaryCustomExpression;\n      if (typeof funcCall === 'string') {\n        expressionScalar = expressionVector = (a, b) => `${funcCall}((${a}),(${b}))`;\n      } else if (typeof funcCall === 'function') {\n        expressionScalar = expressionVector = funcCall;\n      } else {\n        expressionScalar = funcCall.scalar;\n        expressionVector = funcCall.vector;\n      }\n\n      const output = outputVariable('outputData', typeOutput, dimsOutput.length, 4);\n      const a = inputVariable('aData', typeA, dimsA.length, 4);\n      const b = inputVariable('bData', typeB, dimsB.length, 4);\n\n      let assignment: string;\n      if (vectorize) {\n        if (doBroadcast) {\n          const isAOneElement = ShapeUtil.size(dimsA) === 1;\n          const isBOneElement = ShapeUtil.size(dimsB) === 1;\n          const aLastDimDivisibleBy4 = dimsA.length > 0 && dimsA[dimsA.length - 1] % 4 === 0;\n          const bLastDimDivisibleBy4 = dimsB.length > 0 && dimsB[dimsB.length - 1] % 4 === 0;\n          if (isAOneElement || isBOneElement) {\n            assignment = output.setByOffset(\n                'global_idx',\n                expressionVector(\n                    isAOneElement ? `${a.type.value}(${a.getByOffset('0')}.x)` : a.getByOffset('global_idx'),\n                    isBOneElement ? `${b.type.value}(${b.getByOffset('0')}.x)` : b.getByOffset('global_idx')));\n          } else {\n            assignment = `\n            let outputIndices = ${output.offsetToIndices('global_idx * 4u')};\n            let offsetA = ${a.broadcastedIndicesToOffset('outputIndices', output)};\n            let offsetB = ${b.broadcastedIndicesToOffset('outputIndices', output)};\n            ${\n                output.setByOffset(\n                    'global_idx',\n                    expressionVector(\n                        sharedDimensionDivisibleBy4 || aLastDimDivisibleBy4 ?\n                            a.getByOffset('offsetA / 4u') :\n                            `${a.type.value}(${a.getByOffset('offsetA / 4u')}[offsetA % 4u])`,\n                        sharedDimensionDivisibleBy4 || bLastDimDivisibleBy4 ?\n                            b.getByOffset('offsetB / 4u') :\n                            `${b.type.value}(${b.getByOffset('offsetB / 4u')}[offsetB % 4u])`))}\n          `;\n          }\n        } else {\n          assignment = output.setByOffset(\n              'global_idx', expressionVector(a.getByOffset('global_idx'), b.getByOffset('global_idx')));\n        }\n      } else {\n        if (!doBroadcast) {\n          throw new Error('no necessary to use scalar implementation for element-wise binary op implementation.');\n        }\n\n        const singleAssignment = (resStr: string, x: number, typeCast = '') => {\n          const expressionA = `aData[indexA${x}][componentA${x}]`;\n          const expressionB = `bData[indexB${x}][componentB${x}]`;\n          return `\n            let outputIndices${x} = ${output.offsetToIndices(`global_idx * 4u + ${x}u`)};\n            let offsetA${x} = ${a.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n            let offsetB${x} = ${b.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n            let indexA${x} = offsetA${x} / 4u;\n            let indexB${x} = offsetB${x} / 4u;\n            let componentA${x} = offsetA${x} % 4u;\n            let componentB${x} = offsetB${x} % 4u;\n            ${resStr}[${x}] = ${typeCast}(${expressionScalar(expressionA, expressionB)});\n          `;\n        };\n        if (typeOutput === DataType.bool) {\n          assignment = `\n            var data = vec4<u32>(0);\n            ${singleAssignment('data', 0, 'u32')}\n            ${singleAssignment('data', 1, 'u32')}\n            ${singleAssignment('data', 2, 'u32')}\n            ${singleAssignment('data', 3, 'u32')}\n            outputData[global_idx] = dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(data));`;\n        } else {\n          assignment = `\n            ${singleAssignment('outputData[global_idx]', 0)}\n            ${singleAssignment('outputData[global_idx]', 1)}\n            ${singleAssignment('outputData[global_idx]', 2)}\n            ${singleAssignment('outputData[global_idx]', 3)}\n          `;\n        }\n      }\n\n      return `\n        ${shaderHelper.registerUniform('vec_size', 'u32').declareVariables(a, b, output)}\n\n        ${additionalImplementation ?? ''}\n\n        ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.vec_size')}\n        ${assignment}\n      }`;\n    };\n\nconst createBinaryOpProgramInfo =\n    (name: string, cacheKey: string, a: TensorView, b: TensorView, funcCall: BinaryFunctionCall,\n     additionalImplementation?: string, outputDataType: number = a.dataType): ProgramInfo => {\n      const isBroadcast = !ShapeUtil.areEqual(a.dims, b.dims);\n      let outputShape = a.dims;\n      let outputSize = ShapeUtil.size(a.dims);\n\n      let vectorize = false;\n      let sharedDimensionDivisibleBy4 = false;\n\n      // TODO: deal with zero-sized tensors (eg. dims=[1,0])\n      const cacheKeyAux = [isBroadcast];\n      if (isBroadcast) {\n        const calculatedShape = BroadcastUtil.calcShape(a.dims, b.dims, false);\n        if (!calculatedShape) {\n          throw new Error('Can\\'t perform binary op on the given tensors');\n        }\n        outputShape = calculatedShape;\n        outputSize = ShapeUtil.size(outputShape);\n        const isAOneElement = ShapeUtil.size(a.dims) === 1;\n        const isBOneElement = ShapeUtil.size(b.dims) === 1;\n        const aLastDimDivisibleBy4 = a.dims.length > 0 && a.dims[a.dims.length - 1] % 4 === 0;\n        const bLastDimDivisibleBy4 = b.dims.length > 0 && b.dims[b.dims.length - 1] % 4 === 0;\n        cacheKeyAux.push(isAOneElement);\n        cacheKeyAux.push(isBOneElement);\n        cacheKeyAux.push(aLastDimDivisibleBy4);\n        cacheKeyAux.push(bLastDimDivisibleBy4);\n        // check whether vectorize can be enabled\n        let sharedDimension = 1;\n        for (let i = 1; i < outputShape.length; i++) {\n          const dimA = a.dims[a.dims.length - i] ?? 1;\n          const dimB = b.dims[b.dims.length - i] ?? 1;\n          if (dimA === dimB) {\n            sharedDimension *= dimA;\n          } else {\n            break;\n          }\n        }\n        if (sharedDimension % 4 === 0) {\n          sharedDimensionDivisibleBy4 = true;\n          vectorize = true;\n        } else if (isAOneElement || isBOneElement || aLastDimDivisibleBy4 || bLastDimDivisibleBy4) {\n          vectorize = true;\n        }\n      } else {\n        // element-wise\n        vectorize = true;\n      }\n      cacheKeyAux.push(vectorize);\n\n      return {\n        name,\n        shaderCache: {\n          hint: cacheKey + cacheKeyAux.map((x) => x.toString()).join('_'),\n          inputDependencies: ['rank', 'rank'],\n        },\n        getShaderSource: (shaderHelper) => createBinaryOpProgramShader(\n            shaderHelper, a.dims, b.dims, outputShape, vectorize, isBroadcast, sharedDimensionDivisibleBy4, funcCall,\n            a.dataType, b.dataType, outputDataType, additionalImplementation),\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: outputDataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */ / 4 /* component size */)},\n          programUniforms: [\n            {type: DataType.uint32, data: Math.ceil(ShapeUtil.size(outputShape) / 4)},\n            ...createTensorShapeVariables(a.dims, b.dims, outputShape)\n          ],\n        }),\n      };\n    };\n\nconst runBinaryOp =\n    (context: ComputeContext, name: string, funcCall: BinaryFunctionCall, additionalImplementation?: string,\n     cacheKey?: string, outputDataType?: number): void => {\n      context.compute(createBinaryOpProgramInfo(\n          name, cacheKey ?? '', context.inputs[0], context.inputs[1], funcCall, additionalImplementation,\n          outputDataType));\n    };\n\nexport const add = (context: ComputeContext): void => {\n  runBinaryOp(context, 'Add', (a, b) => `${a}+${b}`);\n};\n\nexport const div = (context: ComputeContext): void => {\n  runBinaryOp(context, 'Div', (a, b) => `${a}/${b}`);\n};\n\nexport const equal = (context: ComputeContext): void => {\n  runBinaryOp(\n      context, 'Equal', ({scalar: (a, b) => `u32(${a}==${b})`, vector: (a, b) => `vec4<u32>(${a}==${b})`}), undefined,\n      undefined, DataType.bool);\n};\n\nexport const mul = (context: ComputeContext): void => {\n  runBinaryOp(context, 'Mul', (a, b) => `${a}*${b}`);\n};\n\nexport const pow = (context: ComputeContext): void => {\n  const type = inputVariable('input', context.inputs[0].dataType, context.inputs[0].dims).type.value;\n  const roundStr = type === 'i32' ? 'round' : '';\n  runBinaryOp(\n      context, 'Pow', ({scalar: (a, b) => `pow_custom(${a},${b})`, vector: (a, b) => `pow_vector_custom(${a},${b})`}),\n      `\n    fn pow_custom(a : ${type}, b : ${type}) -> ${type} {\n      if (b == ${type}(0.0)) {\n        return ${type}(1.0);\n      } else if (a < ${type}(0.0) && f32(b) != floor(f32(b))) {\n        return ${type}(pow(f32(a), f32(b))); // NaN\n      }\n      return select(sign(a), ${type}(1.0), round(f32(abs(b) % ${type}(2.0))) != 1.0) * ${type}(${\n          roundStr}(pow(f32(abs(a)), f32(b))));\n    }\n    fn pow_vector_custom(a : vec4<${type}>, b : vec4<${type}>) -> vec4<${type}> {\n      // TODO: implement vectorized pow\n      return vec4<${type}>(pow_custom(a.x, b.x), pow_custom(a.y, b.y), pow_custom(a.z, b.z), pow_custom(a.w, b.w));\n    }\n      `);\n};\n\nexport const sub = (context: ComputeContext): void => {\n  runBinaryOp(context, 'Sub', (a, b) => `${a}-${b}`);\n};\n\nexport const greater = (context: ComputeContext): void => {\n  runBinaryOp(\n      context, 'Greater', ({scalar: (a, b) => `u32(${a}>${b})`, vector: (a, b) => `vec4<u32>(${a}>${b})`}), undefined,\n      undefined, DataType.bool);\n};\n\nexport const less = (context: ComputeContext): void => {\n  runBinaryOp(\n      context, 'Less', ({scalar: (a, b) => `u32(${a}<${b})`, vector: (a, b) => `vec4<u32>(${a}<${b})`}), undefined,\n      undefined, DataType.bool);\n};\n\nexport const greaterOrEqual = (context: ComputeContext): void => {\n  runBinaryOp(\n      context, 'GreaterOrEqual', ({scalar: (a, b) => `u32(${a}>=${b})`, vector: (a, b) => `vec4<u32>(${a}>=${b})`}),\n      undefined, undefined, DataType.bool);\n};\n\nexport const lessOrEqual = (context: ComputeContext): void => {\n  runBinaryOp(\n      context, 'LessOrEqual', ({scalar: (a, b) => `u32(${a}<=${b})`, vector: (a, b) => `vec4<u32>(${a}<=${b})`}),\n      undefined, undefined, DataType.bool);\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {MAX_CLIP, MIN_CLIP} from '../../util';\nimport {ProgramUniform} from '../types';\n\nimport {UniformsArrayType} from './common';\n\nexport interface InternalActivationAttributes {\n  readonly activation: string;\n  readonly clipMin?: number;\n  readonly clipMax?: number;\n  readonly alpha?: number;\n  readonly beta?: number;\n}\n\nexport const getActivationSnippet =\n    (attributes: InternalActivationAttributes, valueType: string, baseType = 'f32'): string => {\n      switch (attributes.activation) {\n        case 'Relu':\n          return `value = max(value, ${valueType}(0.0));`;\n        case 'Sigmoid':\n          return `value = (${valueType}(1.0) / (${valueType}(1.0) + exp(-value)));`;\n        case 'Clip':\n          return `value = clamp(value, ${valueType}(${baseType}(uniforms.clip_min)), ${valueType}(${\n              baseType}(uniforms.clip_max)));`;\n        case 'HardSigmoid':\n          return `value = max(${valueType}(0.0), min(${valueType}(1.0), ${baseType}(uniforms.alpha) * value + ${\n              baseType}(uniforms.beta)));`;\n        case 'LeakyRelu':\n          return `value = select(${baseType}(uniforms.alpha) * value, value, value >= ${valueType}(0.0));`;\n        case '':\n          return '';\n        // TODO: adding other activations that can be fused.\n        default:\n          throw new Error(`Unsupported activation ${attributes.activation}`);\n      }\n    };\n\nexport const appendActivationUniformsData =\n    (attributes: InternalActivationAttributes, programUniform: ProgramUniform[]) => {\n      if (attributes.activation === 'Clip') {\n        programUniform.push(\n            {type: DataType.float, data: attributes.clipMax!}, {type: DataType.float, data: attributes.clipMin!});\n      } else if (attributes.activation === 'HardSigmoid') {\n        programUniform.push(\n            {type: DataType.float, data: attributes.alpha!}, {type: DataType.float, data: attributes.beta!});\n      } else if (attributes.activation === 'LeakyRelu') {\n        programUniform.push({type: DataType.float, data: attributes.alpha!});\n      }\n    };\n\nexport const appendActivationUniforms = (attributes: InternalActivationAttributes, uniforms: UniformsArrayType) => {\n  if (attributes.activation === 'Clip') {\n    uniforms.push({name: 'clip_max', type: 'f32'}, {name: 'clip_min', type: 'f32'});\n  } else if (attributes.activation === 'HardSigmoid') {\n    uniforms.push({name: 'alpha', type: 'f32'}, {name: 'beta', type: 'f32'});\n  } else if (attributes.activation === 'LeakyRelu') {\n    uniforms.push({name: 'alpha', type: 'f32'});\n  }\n};\n\nexport const parseInternalActivationAttributes =\n    (attributes: Record<string, unknown>|undefined): InternalActivationAttributes => {\n      const activation = attributes?.activation as string || '';\n      if (activation === 'HardSigmoid') {\n        const [alpha, beta] = attributes?.activation_params as [number, number] || [0.2, 0.5];\n        return {activation, alpha, beta};\n      } else if (activation === 'Clip') {\n        const [clipMin, clipMax] = attributes?.activation_params as [number, number] || [MIN_CLIP, MAX_CLIP];\n        return {activation, clipMax, clipMin};\n      } else if (activation === 'LeakyRelu') {\n        const [alpha] = attributes?.activation_params as [number] || [0.01];\n        return {activation, alpha};\n      }\n      return {activation};\n    };\n", "/**\n * @license\n * Copyright 2021 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/activation_util.ts\n//\n// modified to fit the needs of the project\n\nexport const typeSnippet = (component: number, dataType: string) => {\n  switch (component) {\n    case 1:\n      return dataType;\n    case 2:\n      return `vec2<${dataType}>`;\n    case 3:\n      return `vec3<${dataType}>`;\n    case 4:\n      return `vec4<${dataType}>`;\n    default:\n      throw new Error(`${component}-component is not supported.`);\n  }\n};\n\nexport const biasSnippet = (hasBias: boolean): string => `\n      ${hasBias ? 'value = value + getBiasByOutputCoords(coords);' : ''}\n      `;\n", "/**\n * @license\n * Copyright 2020 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-core/src/ops/conv_util.ts\n//\n// modified to fit the needs of the project\n\nexport const utilFunctions = (strideStr: string) => (`\nfn getIndexFromCoords4D(coords : vec4<i32>, shape : vec4<i32>) -> i32 {\n  return dot(coords, vec4<i32>(\n      shape.y * shape.z * shape.w, shape.z * shape.w, shape.w, 1));\n}\nfn getOutputIndexFromCoords(coords : vec4<i32>) -> i32 {\n  return dot(coords, vec4<i32>(\n    i32(${strideStr}.x), i32(${strideStr}.y), i32(${strideStr}.z), 1));\n}\n`);\n", "/**\n * @license\n * Copyright 2019 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/matmul_packed_webgpu.ts\n//\n// modified to fit the needs of the project\n\nimport {DataType} from '../../../../wasm-common';\nimport {TensorView} from '../../../tensor-view';\nimport {ShapeUtil} from '../../../util';\nimport {ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../../types';\nimport {createTensorShapeVariables, getBroadcastDims, IndicesHelper, inputVariable, internalVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from '../common';\nimport {appendActivationUniforms, appendActivationUniformsData, getActivationSnippet, InternalActivationAttributes} from '../fuse-utils';\n\nimport {typeSnippet} from './activation_util';\n\nconst writeDataToSubAVec4Snippet = (transpose: boolean, batchDims?: IndicesHelper) => {\n  if (transpose) {\n    return `\n        mm_Asub[inputRow][inputCol] = mm_readA(batch,\n          kStart + inputRow,\n          globalRowStart / innerElementSize + inputCol${batchDims ? ', batchIndices' : ''});\n        `;\n\n  } else {\n    return `\n        mm_Asub[inputRow][inputCol] = mm_readA(batch,\n          globalRow + innerRow,\n          kStart / innerElementSize + inputCol${batchDims ? ', batchIndices' : ''});\n        `;\n  }\n};\n\nconst calculateResultSnippet = (transposeA: boolean, innerElementSize: number) => {\n  if (transposeA) {\n    return `\n        let ACached0 = mm_Asub[k * innerElementSize][localRow];\n        let ACached1 = mm_Asub[k * innerElementSize + 1][localRow];\n        let ACached2 = mm_Asub[k * innerElementSize + 2][localRow];\n        ${innerElementSize === 3 ? '' : 'let ACached3 = mm_Asub[k * innerElementSize + 3][localRow];'}\n        for (var i = 0; i < rowPerThread; i = i + 1) {\n          acc[i] = BCached0 * ACached0[i] + acc[i];\n          acc[i] = BCached1 * ACached1[i] + acc[i];\n          acc[i] = BCached2 * ACached2[i] + acc[i];\n          ${innerElementSize === 3 ? '' : 'acc[i] = BCached3 * ACached3[i] + acc[i];'}\n        }`;\n  } else {\n    return `\n        for (var i = 0; i < rowPerThread; i = i + 1) {\n          let ACached = mm_Asub[tileRow + i][k];\n          acc[i] = BCached0 * ACached.x + acc[i];\n          acc[i] = BCached1 * ACached.y + acc[i];\n          acc[i] = BCached2 * ACached.z + acc[i];\n          ${innerElementSize === 3 ? '' : 'acc[i] = BCached3 * ACached.w + acc[i];'}\n        }`;\n  }\n};\n\nexport const makeMatMulPackedVec4Source =\n    (workPerThread: number[], workgroupSize: [number, number, number], type = 'f32', batchDims?: IndicesHelper,\n     transposeA = false, tileInner = 32, splitK = false, splitedDimInner = 32): string => {\n      const tileAOuter = workgroupSize[1] * workPerThread[1];\n      const tileBOuter = workgroupSize[0] * workPerThread[0];\n      const tileAWidth = transposeA ? tileAOuter : tileInner;\n      const tileAHight = transposeA ? tileInner : tileAOuter;\n      const innerElementSize = tileAWidth / workgroupSize[0];\n      const rowPerThreadB = tileInner / workgroupSize[1];\n\n      if (!(((transposeA && innerElementSize === 4 && workPerThread[1] === 4) ||\n             (!transposeA && (innerElementSize === 3 || innerElementSize === 4))) &&\n            tileAWidth % workgroupSize[0] === 0 && tileInner % workgroupSize[1] === 0 && workPerThread[0] === 4)) {\n        throw new Error(`If transposeA ${transposeA} is true, innerElementSize ${\n            innerElementSize} and workPerThread[1] ${workPerThread[1]} must be 4.\n      Otherwise, innerElementSize ${innerElementSize} must be 3 or 4.\n  tileAWidth ${tileAWidth} must be divisible by workgroupSize[0]${workgroupSize[0]}. tileInner ${\n            tileInner} must be divisible by workgroupSize[1] ${workgroupSize[1]}. colPerThread ${\n            workPerThread[0]} must be 4.`);\n      }\n      return `\nvar<workgroup> mm_Asub: array<array<vec${innerElementSize}<${type}>, ${tileAWidth / innerElementSize}>, ${tileAHight}>;\nvar<workgroup> mm_Bsub: array<array<vec4<${type}>, ${tileBOuter / workPerThread[0]}>, ${tileInner}>;\n\nconst rowPerThread = ${workPerThread[1]};\nconst colPerThread = ${workPerThread[0]};\nconst innerElementSize = ${innerElementSize};\nconst tileInner = ${tileInner};\n\n@compute @workgroup_size(${workgroupSize[0]}, ${workgroupSize[1]}, ${workgroupSize[2]})\nfn main(@builtin(local_invocation_id) localId : vec3<u32>,\n        @builtin(global_invocation_id) globalId : vec3<u32>,\n        @builtin(workgroup_id) workgroupId : vec3<u32>) {\n  let localRow = i32(localId.y);\n  let tileRow = localRow * rowPerThread;\n  let tileCol = i32(localId.x);\n\n  let globalRow =i32(globalId.y) * rowPerThread;\n  let globalCol = i32(globalId.x);\n  let batch = ${splitK ? '0' : 'i32(globalId.z)'};\n  ${batchDims ? `let batchIndices = ${batchDims.offsetToIndices('u32(batch)')};` : ''}\n  let globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n\n  let num_tiles = ${splitK ? `${Math.ceil(splitedDimInner / tileInner)}` : '(uniforms.dim_inner - 1) / tileInner + 1'};\n  var kStart = ${splitK ? `i32(globalId.z) * ${splitedDimInner}` : '0'};\n\n  var acc: array<vec4<${type}>, rowPerThread>;\n\n  // Loop over shared dimension.\n  let tileRowB = localRow * ${rowPerThreadB};\n  for (var t = 0; t < num_tiles; t = t + 1) {\n      // Load one tile of A into local memory.\n      for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n          let inputRow = tileRow + innerRow;\n          let inputCol = tileCol;\n          ${writeDataToSubAVec4Snippet(transposeA, batchDims)}\n      }\n\n      // Load one tile of B into local memory.\n      for (var innerRow = 0; innerRow < ${rowPerThreadB}; innerRow = innerRow + 1) {\n          let inputRow = tileRowB + innerRow;\n          let inputCol = tileCol;\n          mm_Bsub[inputRow][inputCol] = mm_readB(batch, kStart + inputRow, globalCol${\n          batchDims ? ', batchIndices' : ''});\n      }\n      kStart = kStart + tileInner;\n      workgroupBarrier();\n\n      // Compute acc values for a single thread.\n      for (var k = 0; k < tileInner / innerElementSize; k = k + 1) {\n          let BCached0 = mm_Bsub[k * innerElementSize][tileCol];\n          let BCached1 = mm_Bsub[k * innerElementSize + 1][tileCol];\n          let BCached2 = mm_Bsub[k * innerElementSize + 2][tileCol];\n          ${innerElementSize === 3 ? '' : 'let BCached3 = mm_Bsub[k * innerElementSize + 3][tileCol];'}\n\n          ${calculateResultSnippet(transposeA, innerElementSize)}\n      }\n\n      workgroupBarrier();\n  }\n\n  for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      mm_write(batch, globalRow + innerRow, globalCol, acc[innerRow]);\n  }\n}`;\n    };\n\nconst writeDataToSubASnippet = (transpose: boolean, batchDims?: IndicesHelper) => {\n  if (transpose) {\n    return `\n            mm_Asub[inputRow][inputCol] = mm_readA(batch,\n              kStart + inputRow,\n              globalRowStart + inputCol${batchDims ? ', batchIndices' : ''});\n            `;\n\n  } else {\n    return `\n            mm_Asub[inputRow][inputCol] = mm_readA(batch,\n              globalRowStart + inputRow,\n              kStart + inputCol${batchDims ? ', batchIndices' : ''});\n            `;\n  }\n};\n\nconst readDataFromSubASnippet = (transposeA: boolean) =>\n    transposeA ? 'let ACached = mm_Asub[k][tileRow + innerRow];' : 'let ACached = mm_Asub[tileRow + innerRow][k];';\n\n// sequentialAccessByThreads means sequential data in memory is accessed by\n// threads, instead of a single thread (default behavior).\nexport const makeMatMulPackedSource =\n    (workPerThread: number[], workgroupSize: [number, number, number], type = 'f32', batchDims?: IndicesHelper,\n     transposeA = false, tileInner = 32, splitK = false, splitedDimInner = 32,\n     sequentialAccessByThreads = false): string => {\n      const tileAOuter = workPerThread[1] * workgroupSize[1];\n      const tileBOuter = workPerThread[0] * workgroupSize[0];\n      const tileAWidth = transposeA ? tileAOuter : tileInner;\n      const tileAHight = transposeA ? tileInner : tileAOuter;\n\n      if (!(tileAHight % workgroupSize[1] === 0 && tileAWidth % workgroupSize[0] === 0 &&\n            tileInner % workgroupSize[1] === 0)) {\n        throw new Error(`tileAHight ${tileAHight} must be divisible by workgroupSize[1]${\n            workgroupSize[1]}, tileAWidth ${tileAWidth} must be divisible by workgroupSize[0]${\n            workgroupSize[0]}, tileInner ${tileInner} must be divisible by workgroupSize[1]${workgroupSize[1]}`);\n      }\n      const rowPerThreadA = tileAHight / workgroupSize[1];\n      const colPerThreadA = tileAWidth / workgroupSize[0];\n      const rowPerThreadB = tileInner / workgroupSize[1];\n      const matmulSnippet = sequentialAccessByThreads ?\n          `\n    let localRow = i32(localId.y);\n    let localCol = i32(localId.x);\n    let globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n    let globalColStart = i32(workgroupId.x) * ${tileBOuter};\n\n    // Loop over shared dimension.\n    for (var t = 0; t < num_tiles; t = t + 1) {\n      // Load one tile of A into local memory.\n      for (var inputRow = localRow; inputRow < ${tileAHight}; inputRow = inputRow + ${workgroupSize[1]}) {\n        for (var inputCol = localCol; inputCol < ${tileAWidth}; inputCol = inputCol + ${workgroupSize[0]}) {\n          ${writeDataToSubASnippet(transposeA, batchDims)}\n        }\n      }\n      // Load one tile of B into local memory.\n      for (var inputRow = localRow; inputRow < ${tileInner}; inputRow = inputRow + ${workgroupSize[1]}) {\n            for (var inputCol = localCol; inputCol < ${tileBOuter}; inputCol = inputCol + ${workgroupSize[0]}) {\n          mm_Bsub[inputRow][inputCol] = mm_readB(batch,\n            kStart + inputRow,\n            globalColStart + inputCol${batchDims ? ', batchIndices' : ''});\n        }\n      }\n      kStart = kStart + tileInner;\n      workgroupBarrier();\n\n      // Compute acc values for a single thread.\n      var BCached : array<${type}, colPerThread>;\n      for (var k = 0; k < tileInner; k = k + 1) {\n        for (var inner = 0; inner < colPerThread; inner = inner + 1) {\n          BCached[inner] = mm_Bsub[k][localCol + inner * ${workgroupSize[0]}];\n        }\n        for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n          let ACached = ${\n              transposeA ? `mm_Asub[k][localRow + innerRow * ${workgroupSize[1]}];` :\n                           `mm_Asub[localRow + innerRow * ${workgroupSize[1]}][k];`}\n          for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n            acc[innerRow][innerCol] = acc[innerRow][innerCol] +\n                ACached * BCached[innerCol];\n          }\n        }\n      }\n      workgroupBarrier();\n    }\n    for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      let gRow = globalRowStart + localRow + innerRow * ${workgroupSize[1]};\n      for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n        let gCol = globalColStart + localCol + innerCol * ${workgroupSize[0]};\n        mm_write(batch, gRow, gCol, acc[innerRow][innerCol]);\n      }\n    }\n    ` :\n          `\nlet tileRow = i32(localId.y) * rowPerThread;\nlet tileCol = i32(localId.x) * colPerThread;\n\nlet globalRow = i32(globalId.y) * rowPerThread;\nlet globalCol = i32(globalId.x) * colPerThread;\nlet globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n\nlet tileRowA = i32(localId.y) * ${rowPerThreadA};\nlet tileColA = i32(localId.x) * ${colPerThreadA};\nlet tileRowB = i32(localId.y) * ${rowPerThreadB};\n// Loop over shared dimension.\nfor (var t = 0; t < num_tiles; t = t + 1) {\n  // Load one tile of A into local memory.\n  for (var innerRow = 0; innerRow < ${rowPerThreadA}; innerRow = innerRow + 1) {\n    for (var innerCol = 0; innerCol < ${colPerThreadA}; innerCol = innerCol + 1) {\n      let inputRow = tileRowA + innerRow;\n      let inputCol = tileColA + innerCol;\n      ${writeDataToSubASnippet(transposeA, batchDims)}\n    }\n  }\n\n  // Load one tile of B into local memory.\n  for (var innerRow = 0; innerRow < ${rowPerThreadB}; innerRow = innerRow + 1) {\n    for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n      let inputRow = tileRowB + innerRow;\n      let inputCol = tileCol + innerCol;\n      mm_Bsub[inputRow][inputCol] = mm_readB(batch,\n        kStart + inputRow,\n        globalCol + innerCol${batchDims ? ', batchIndices' : ''});\n    }\n  }\n  kStart = kStart + tileInner;\n  workgroupBarrier();\n\n  // Compute acc values for a single thread.\n  var BCached : array<${type}, colPerThread>;\n  for (var k = 0; k < tileInner; k = k + 1) {\n    for (var inner = 0; inner < colPerThread; inner = inner + 1) {\n      BCached[inner] = mm_Bsub[k][tileCol + inner];\n    }\n\n    for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      ${readDataFromSubASnippet(transposeA)}\n      for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n        acc[innerRow][innerCol] = acc[innerRow][innerCol] + ACached * BCached[innerCol];\n      }\n    }\n  }\n\n  workgroupBarrier();\n}\n\nfor (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n  for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n    mm_write(batch, globalRow + innerRow, globalCol + innerCol,\n        acc[innerRow][innerCol]);\n  }\n}\n`;\n\n      return `\n  var<workgroup> mm_Asub : array<array<${type}, ${tileAWidth}>, ${tileAHight}>;\n  var<workgroup> mm_Bsub : array<array<${type}, ${tileBOuter}>, ${tileInner}>;\n  const rowPerThread = ${workPerThread[1]};\n  const colPerThread = ${workPerThread[0]};\n  const tileInner = ${tileInner};\n\n@compute @workgroup_size(${workgroupSize[0]}, ${workgroupSize[1]}, ${workgroupSize[2]})\nfn main(@builtin(local_invocation_id) localId : vec3<u32>,\n        @builtin(global_invocation_id) globalId : vec3<u32>,\n        @builtin(workgroup_id) workgroupId : vec3<u32>) {\n    let batch = ${splitK ? '0' : 'i32(globalId.z)'};\n    ${batchDims ? `let batchIndices = ${batchDims.offsetToIndices('u32(batch)')};` : ''}\n    let num_tiles = ${\n          splitK ? `${Math.ceil(splitedDimInner / tileInner)}` : '(uniforms.dim_inner - 1) / tileInner + 1'};\n    var kStart = ${splitK ? `i32(globalId.z) * ${splitedDimInner}` : '0'};\n\n    var acc : array<array<${type}, colPerThread>, rowPerThread>;\n\n    // Without this initialization strange values show up in acc.\n    for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n        acc[innerRow][innerCol] = 0.0;\n      }\n    }\n    ${matmulSnippet}\n  }\n`;\n    };\n\nconst matMulReadWriteFnSource =\n    (component: number, hasBias: boolean, applyActivation: string, variables: IndicesHelper[],\n     batchShapes: Array<readonly number[]>, isChannelsLast = false): string => {\n      const [batchAShape, batchBShape, batchShape] = batchShapes;\n      const [batchVariable, aVariable, bVariable, outputVariable] = variables;\n      const broadCastADims = getBroadcastDims(batchAShape, batchShape);\n      const broadCastBDims = getBroadcastDims(batchBShape, batchShape);\n      const dataType = tensorTypeToWsglStorageType(variables[0].type.tensor);\n      const getAIndices = () => {\n        const aRank = aVariable.rank;\n        const batchRank = batchVariable.rank;\n        let resStr = `var aIndices: ${aVariable.type.indices};`;\n        for (let i = aRank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) {\n          resStr += `\\naIndices[${i}] = ${batchRank > 1 ? `batchIndices[${j}]` : 'batchIndices'};`;\n        }\n        broadCastADims.forEach(i => {\n          resStr += `\\naIndices[${i}] = 0;`;\n        });\n        resStr += `\\naIndices[${aRank - 2}] = u32(row);\n                   aIndices[${aRank - 1}] = u32(colIn);`;\n        return resStr;\n      };\n      const getBIndices = () => {\n        const bRank = bVariable.rank;\n        const batchRank = batchVariable.rank;\n        let resStr = `var bIndices: ${bVariable.type.indices};`;\n        for (let i = bRank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) {\n          resStr += `\\nbIndices[${i}] = ${batchRank > 1 ? `batchIndices[${j}]` : 'batchIndices'};`;\n        }\n        broadCastBDims.forEach(i => {\n          resStr += `\\nbIndices[${i}] = 0;`;\n        });\n        resStr += `\\nbIndices[${bRank - 2}] = u32(row);\n                   bIndices[${bRank - 1}] = u32(colIn);`;\n        return resStr;\n      };\n      const source = `\n    fn mm_readA(batch: i32, row: i32, colIn: i32, batchIndices: ${batchVariable.type.indices}) -> ${\n          typeSnippet(component, dataType)} {\n      var value = ${typeSnippet(component, dataType)}(0.0);\n      let col = colIn * ${component};\n      if(row < uniforms.dim_a_outer && col < uniforms.dim_inner)\n      {\n        ${getAIndices()}\n        value = ${aVariable.getByIndices('aIndices')};\n      }\n      return value;\n    }\n\n    fn mm_readB(batch: i32, row: i32, colIn: i32, batchIndices: ${batchVariable.type.indices}) -> ${\n          typeSnippet(component, dataType)} {\n      var value = ${typeSnippet(component, dataType)}(0.0);\n      let col = colIn * ${component};\n      if(row < uniforms.dim_inner && col < uniforms.dim_b_outer)\n      {\n        ${getBIndices()}\n        value = ${bVariable.getByIndices('bIndices')};\n      }\n      return value;\n    }\n\n    fn mm_write(batch: i32, row: i32, colIn: i32, valueIn: ${typeSnippet(component, dataType)}) {\n      let col = colIn * ${component};\n      if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer) {\n        var value = valueIn;\n        let coords = vec3<i32>(batch, row, colIn);\n        ${\n          hasBias ?\n              `value = value + ${isChannelsLast ? 'bias[colIn]' : `${typeSnippet(component, dataType)}(bias[row])`};` :\n                                                  ''                                    }\n        ${applyActivation}\n        ${outputVariable.setByIndices('vec3<u32>(coords)', 'value')}\n      }\n    }\n    `;\n      return source;\n    };\n\nexport const createMatmulProgramInfo =\n    (inputs: readonly TensorView[], activationAttributes: InternalActivationAttributes, outputShape: readonly number[],\n     reshapedOutputShape?: readonly number[],\n     isChannelsLast = false /* only used for conv2dByMatMul*/): ProgramInfo => {\n      const aShape = inputs[0].dims;\n      const bShape = inputs[1].dims;\n      const outerDimsA = aShape.slice(0, -2);\n      const outerDimsB = bShape.slice(0, -2);\n      const outerDims = reshapedOutputShape ? reshapedOutputShape.slice(0, -2) : outputShape.slice(0, -2);\n      const batchSize = ShapeUtil.size(outerDims);\n      const dimAOuter = aShape[aShape.length - 2];\n      const dimInner = aShape[aShape.length - 1];\n      const dimBOuter = bShape[bShape.length - 1];\n      const isVec4 = dimInner % 4 === 0 && dimBOuter % 4 === 0;\n\n      // TODO: fine tune size\n      const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];\n      const workgroupSize: [number, number, number] = [8, 8, 1];\n      const dispatch = [\n        Math.ceil(dimBOuter / workgroupSize[0] / elementsPerThread[0]),\n        Math.ceil(dimAOuter / workgroupSize[1] / elementsPerThread[1]),\n        Math.ceil(batchSize / workgroupSize[2] / elementsPerThread[2])\n      ];\n\n      const components = isVec4 ? 4 : 1;\n      const aShapeTemp = [...outerDimsA, dimAOuter, dimInner / components];\n      const aRank = aShapeTemp.length;\n      const bShapeTemp = [...outerDimsB, dimInner, dimBOuter / components];\n      const bRank = bShapeTemp.length;\n      const outputShapeTemp = [batchSize, dimAOuter, dimBOuter / components];\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.int32, data: dimAOuter}, {type: DataType.int32, data: dimBOuter},\n        {type: DataType.int32, data: dimInner}\n      ];\n      appendActivationUniformsData(activationAttributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(outerDims, aShapeTemp, bShapeTemp));\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n\n      const hasBias = inputs.length > 2;\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n        inputDependencies.push('rank');\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShapeTemp));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const batchRank = outerDims.length;\n        const batchDims = internalVariable('batchDims', inputs[0].dataType, batchRank, 1);\n        const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n\n        const A = inputVariable('a', inputs[0].dataType, aRank, components);\n        const B = inputVariable('b', inputs[1].dataType, bRank, components);\n        const output = outputVariable('result', inputs[0].dataType, outputShapeTemp.length, components);\n        const inputVariables = [A, B];\n        if (hasBias) {\n          const biasComponents = isChannelsLast ? components : 1;\n          inputVariables.push(inputVariable('bias', inputs[2].dataType, inputs[2].dims.length, biasComponents));\n        }\n        const uniforms: UniformsArrayType =\n            [{name: 'dim_a_outer', type: 'i32'}, {name: 'dim_b_outer', type: 'i32'}, {name: 'dim_inner', type: 'i32'}];\n        appendActivationUniforms(activationAttributes, uniforms);\n        const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n        const applyActivation = getActivationSnippet(activationAttributes, output.type.value, baseType);\n        const declareFunctions = matMulReadWriteFnSource(\n            components, hasBias, applyActivation, [batchDims, A, B, output], [outerDimsA, outerDimsB, outerDims],\n            isChannelsLast);\n        return `\n  ${\n            shaderHelper.registerUniforms(uniforms).registerInternalVariables(batchDims).declareVariables(\n                ...inputVariables, output)}\n  ${declareFunctions}\n  ${\n            isVec4 ? makeMatMulPackedVec4Source(elementsPerThread, workgroupSize, dataType, batchDims) :\n                     makeMatMulPackedSource(elementsPerThread, workgroupSize, dataType, batchDims)}\n                   `;\n      };\n      return {\n        name: 'MatMul',\n        shaderCache: {\n          hint: `${elementsPerThread};${activationAttributes.activation};${isVec4};${isChannelsLast}`,\n          inputDependencies\n        },\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: dispatch[0], y: dispatch[1], z: dispatch[2]},\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n", "/**\n * @license\n * Copyright 2019 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/conv2d_mm_webgpu.ts\n//\n// modified to fit the needs of the project\n\nimport {DataType} from '../../../../wasm-common';\nimport {LOG_DEBUG} from '../../../log';\nimport {TensorView} from '../../../tensor-view';\nimport {ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../../types';\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from '../common';\nimport {ConvAttributes} from '../conv';\nimport {appendActivationUniforms, appendActivationUniformsData, getActivationSnippet} from '../fuse-utils';\n\nimport {biasSnippet, typeSnippet} from './activation_util';\nimport {utilFunctions} from './conv_util';\nimport {makeMatMulPackedSource, makeMatMulPackedVec4Source} from './matmul_packed_webgpu';\n\nconst conv2dCommonSnippet =\n    (isChannelsLast: boolean, fitAOuter: boolean, fitBOuter: boolean, fitInner: boolean, addBias = false,\n     attributes: ConvAttributes, innerElementSizeX = 4, innerElementSizeW = 4, innerElementSize = 4,\n     dataType = 'f32'): string => {\n      const getXSnippet = (innerElementSize: number) => {\n        switch (innerElementSize) {\n          case 1:\n            return 'resData = x[xIndex];';\n          case 3:\n            return `resData = vec3<${dataType}>(x[xIndex], x[xIndex + 1], x[xIndex + 2]);`;\n          case 4:\n            return 'resData = x[xIndex / 4];';\n          default:\n            throw new Error(`innerElementSize ${innerElementSize} is not supported.`);\n        }\n      };\n      const getWSnippet = (innerElementSize: number) => {\n        switch (innerElementSize) {\n          case 1:\n            return 'return w[row * i32(uniforms.w_shape[3]) + colIn];';\n          case 4:\n            return 'return w[row * i32(uniforms.w_shape[3]) / 4 + colIn];';\n          default:\n            throw new Error(`innerElementSize ${innerElementSize} is not supported.`);\n        }\n      };\n      const coordASnippet = isChannelsLast ? `\n    let coord = vec4<i32>(batch, xRow, xCol, xCh);\n    ` :\n                                             `\n    let coord = vec4<i32>(batch, xCh, xRow, xCol);\n    `;\n\n      const coordResSnippet = isChannelsLast ? `\n    let coords = vec4<i32>(\n      batch,\n      row / outWidth,\n      row % outWidth,\n      col);\n    ` :\n                                               `\n    let coords = vec4<i32>(\n      batch,\n      row,\n      col / outWidth,\n      col % outWidth);\n    `;\n\n      const xHeight = isChannelsLast ? 'i32(uniforms.x_shape[1])' : 'i32(uniforms.x_shape[2])';\n      const xWidth = isChannelsLast ? 'i32(uniforms.x_shape[2])' : 'i32(uniforms.x_shape[3])';\n      const row = isChannelsLast ? 'row' : 'col';\n      const col = isChannelsLast ? 'col' : 'row';\n      const readXSnippet = `\n    let inChannels = i32(uniforms.w_shape[2]);\n    let outWidth = ${isChannelsLast ? 'i32(uniforms.result_shape[2])' : 'i32(uniforms.result_shape[3])'};\n    let outRow = ${row} / outWidth;\n    let outCol = ${row} % outWidth;\n\n    let WRow = ${col} / (i32(uniforms.w_shape[1]) * inChannels);\n    let WCol = ${col} / inChannels % i32(uniforms.w_shape[1]);\n    let xRow = outRow * uniforms.stride[0] + uniforms.dilation[0] * WRow - uniforms.pad[0];\n    let xCol = outCol * uniforms.stride[1] + uniforms.dilation[1] * WCol - uniforms.pad[1];\n    let xCh = ${col} % inChannels;\n    var resData = ${typeSnippet(innerElementSizeX, dataType)}(0.0);\n    // The bounds checking is always needed since we use it to pad zero for\n    // the 'same' padding type.\n    if (xRow >= 0 && xRow < ${xHeight} && xCol >= 0 && xCol < ${xWidth}) {\n      ${coordASnippet}\n      let xIndex = getIndexFromCoords4D(coord, vec4<i32>(uniforms.x_shape));\n      ${getXSnippet(innerElementSizeX)}\n    }\n    return resData;`;\n\n      const sampleX = isChannelsLast ? (fitAOuter && fitInner ? `\n    let col = colIn * ${innerElementSizeX};\n    ${readXSnippet}` :\n                                                                `\n    let col = colIn * ${innerElementSizeX};\n    if (row < uniforms.dim_a_outer && col < uniforms.dim_inner) {\n      ${readXSnippet}\n    }\n    return ${typeSnippet(innerElementSizeX, dataType)}(0.0);`) :\n                                       (fitInner && fitBOuter ? `\n    let col = colIn * ${innerElementSizeX};\n    ${readXSnippet}` :\n                                                                `\n    let col = colIn * ${innerElementSizeX};\n    if (row < uniforms.dim_inner && col < uniforms.dim_b_outer) {\n      ${readXSnippet}\n    }\n    return ${typeSnippet(innerElementSizeX, dataType)}(0.0);`);\n\n      const sampleW = `${getWSnippet(innerElementSizeW)}`;\n\n      const resType = typeSnippet(innerElementSize, dataType);\n      const aType =\n          isChannelsLast ? typeSnippet(innerElementSizeX, dataType) : typeSnippet(innerElementSizeW, dataType);\n      const bType =\n          isChannelsLast ? typeSnippet(innerElementSizeW, dataType) : typeSnippet(innerElementSizeX, dataType);\n      const applyActivation = getActivationSnippet(attributes, resType, dataType);\n      const userCode = `\n    fn mm_readA(batch: i32, row : i32, colIn : i32) -> ${aType} {\n      ${isChannelsLast ? sampleX : sampleW}\n    }\n\n    fn mm_readB(batch: i32, row : i32, colIn : i32) -> ${bType} {\n      ${isChannelsLast ? sampleW : sampleX}\n    }\n\n    fn mm_write(batch: i32, row : i32, colIn : i32, valueIn : ${resType}) {\n      let col = colIn * ${innerElementSize};\n      if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer)\n      {\n      var value = valueIn;\n      let outWidth = ${isChannelsLast ? 'i32(uniforms.result_shape[2])' : 'i32(uniforms.result_shape[3])'};\n      ${coordResSnippet}\n      ${biasSnippet(addBias)}\n      ${applyActivation}\n      setOutputAtCoords(coords[0], coords[1], coords[2], coords[3], value);\n      }\n    }`;\n      return userCode;\n    };\n\nexport const createConv2DMatMulProgramInfo =\n    (inputs: readonly TensorView[], attributes: ConvAttributes, outputShape: readonly number[], dimAOuter: number,\n     dimBOuter: number, dimInner: number, hasBias: boolean, sequentialAccessByThreads: boolean): ProgramInfo => {\n      const isChannelsLast = attributes.format === 'NHWC';\n      const inChannels = isChannelsLast ? inputs[0].dims[3] : inputs[0].dims[1];\n      const batchSize = outputShape[0];\n      const outWidth = isChannelsLast ? outputShape[2] : outputShape[3];\n      const outHeight = isChannelsLast ? outputShape[1] : outputShape[2];\n      const outChannels = isChannelsLast ? outputShape[3] : outputShape[1];\n      // TODO: enable vec4 for NCHW\n      const isVec4 = isChannelsLast && (inChannels % 4 === 0 || inChannels % 3 === 0) && outChannels % 4 === 0;\n\n      // TODO: fine tune size\n      const dispatchX = isChannelsLast ? outChannels : outWidth * outHeight;\n      const dispatchY = isChannelsLast ? outWidth * outHeight : outChannels;\n      const workGroupSize: [number, number, number] = [8, 8, 1];\n      const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];\n      const dispatch = [\n        Math.ceil(dispatchX / workGroupSize[0] / elementsPerThread[0]),\n        Math.ceil(dispatchY / workGroupSize[1] / elementsPerThread[1]),\n        Math.ceil(batchSize / workGroupSize[2] / elementsPerThread[2])\n      ];\n\n      LOG_DEBUG('verbose', () => `[conv2d_mm_webgpu] dispatch = ${dispatch}`);\n\n      const innerElementSize = isVec4 ? (isChannelsLast && inChannels % 4 !== 0 ? 3 : 4) : 1;\n      const tileAOuter = workGroupSize[1] * elementsPerThread[1];\n      const tileBOuter = workGroupSize[0] * elementsPerThread[0];\n      const tileInner = Math.max(workGroupSize[0] * innerElementSize, workGroupSize[1]);\n      const fitAOuter = dimAOuter % tileAOuter === 0;\n      const fitBOuter = dimBOuter % tileBOuter === 0;\n      const fitInner = dimInner % tileInner === 0;\n      const elementsSize = isVec4 ? [innerElementSize, 4, 4] : [1, 1, 1];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.int32, data: dimAOuter}, {type: DataType.int32, data: dimBOuter},\n        {type: DataType.int32, data: dimInner}, {type: DataType.int32, data: [attributes.pads[0], attributes.pads[1]]},\n        {type: DataType.int32, data: attributes.strides}, {type: DataType.int32, data: attributes.dilations}\n      ];\n      appendActivationUniformsData(attributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(inputs[0].dims, inputs[1].dims));\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n        inputDependencies.push('rank');\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShape));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const uniforms: UniformsArrayType = [\n          {name: 'dim_a_outer', type: 'i32'}, {name: 'dim_b_outer', type: 'i32'}, {name: 'dim_inner', type: 'i32'},\n          {name: 'pad', type: 'i32', length: 2}, {name: 'stride', type: 'i32', length: 2},\n          {name: 'dilation', type: 'i32', length: 2}\n        ];\n        appendActivationUniforms(attributes, uniforms);\n\n        // TODO: support component 2, 3.\n        const components = isVec4 ? 4 : 1;\n        const t = tensorTypeToWsglStorageType(inputs[0].dataType);\n        let declareFunctions = `\n      fn setOutputAtIndex(flatIndex : i32, value : ${isVec4 ? `vec4<${t}>` : t}) {\n        result[flatIndex] = ${isVec4 ? `vec4<${t}>` : t}(value);\n      }\n      fn setOutputAtCoords(d0 : i32, d1 : i32, d2 : i32, d3 : i32, value : ${isVec4 ? `vec4<${t}>` : t}) {\n        let flatIndex = getOutputIndexFromCoords(vec4<i32>(d0, d1, d2, d3));\n        setOutputAtIndex(flatIndex ${isVec4 ? '/ 4' : ''}, value);\n      }`;\n        const x = inputVariable(\n            'x', inputs[0].dataType, inputs[0].dims.length, innerElementSize === 3 ? 1 : innerElementSize);\n        const w = inputVariable('w', inputs[1].dataType, inputs[1].dims.length, components);\n        const inputVariables = [x, w];\n        const output = outputVariable('result', inputs[0].dataType, outputShape.length, components);\n        if (hasBias) {\n          const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims.length, components);\n          inputVariables.push(bias);\n          declareFunctions += `\n        fn getBiasByOutputCoords(coords : vec4<i32>) -> ${isVec4 ? `vec4<${t}>` : t} {\n          return bias[coords.${isChannelsLast ? 'w' : 'y'}${isVec4 ? '/ 4' : ''}];\n        }`;\n        }\n\n        return `\n        ${utilFunctions('uniforms.result_strides')}\n        //struct Uniforms { xShape : vec4<i32>, wShape : vec4<i32>, outShape : vec4<i32>,\n        //  outShapeStrides: vec3<i32>, filterDims : vec2<i32>, pad : vec2<i32>, stride : vec2<i32>,\n        //  dilation : vec2<i32>, dimAOuter : i32, dimBOuter : i32, dimInner : i32 };\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n        ${declareFunctions}\n        ${\n            conv2dCommonSnippet(\n                isChannelsLast, fitAOuter, fitBOuter, fitInner, hasBias, attributes, elementsSize[0], elementsSize[1],\n                elementsSize[2], t)}\n        ${\n            isVec4 ?\n                makeMatMulPackedVec4Source(elementsPerThread, workGroupSize, t, undefined, !isChannelsLast, tileInner) :\n                makeMatMulPackedSource(\n                    elementsPerThread, workGroupSize, t, undefined, !isChannelsLast, tileInner, false, undefined,\n                    sequentialAccessByThreads)}`;\n      };\n      return {\n        name: 'Conv2DMatMul',\n        shaderCache: {\n          hint: `${attributes.cacheKey};${innerElementSize};${isVec4};${fitAOuter};${fitBOuter};${fitInner};${\n              tileAOuter};${tileBOuter};${tileInner}`,\n          inputDependencies\n        },\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: dispatch[0], y: dispatch[1], z: dispatch[2]},\n          programUniforms,\n        }),\n        getShaderSource\n      };\n    };\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, getMaxComponents, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from './common';\nimport {calculateOutputShape, ConvAttributes} from './conv';\nimport {appendActivationUniforms, appendActivationUniformsData, getActivationSnippet} from './fuse-utils';\n\n/**\n * naive grouped conv implementation, supports 1d/2d conv\n * @param squeezeOutputShapeFunction - an optional function to squeeze the output shape, only used in conv1d\n */\nexport const createGroupedConvProgramInfo =\n    (inputs: readonly TensorView[], attributes: ConvAttributes,\n     squeezeOutputShapeFunction?: (shape: readonly number[]) => number[]): ProgramInfo => {\n      const hasBias = inputs.length > 2;\n      const processBias = hasBias ? 'value += b[output_channel];' : '';\n      const xShape = inputs[0].dims;\n      const wShape = inputs[1].dims;\n      const outputChannelsPerGroup = wShape[0] / attributes.group;\n\n      const isChannelLast = attributes.format === 'NHWC';\n      const outputShape = calculateOutputShape(\n          xShape, wShape, attributes.dilations, attributes.pads, attributes.strides, isChannelLast);\n      const outputSize = ShapeUtil.size(outputShape);\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: attributes.dilations},\n        {type: DataType.uint32, data: [attributes.strides[0], attributes.strides[1]]},\n        {type: DataType.uint32, data: [attributes.pads[0], attributes.pads[1]]},\n        {type: DataType.uint32, data: outputChannelsPerGroup}\n      ];\n      appendActivationUniformsData(attributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(xShape, wShape));\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n        inputDependencies.push('rank');\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShape));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n        const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n        const applyActivation = getActivationSnippet(attributes, output.type.value, baseType);\n        const x = inputVariable('x', inputs[0].dataType, xShape.length);\n        const w = inputVariable('w', inputs[1].dataType, wShape.length);\n        const inputVars = [x, w];\n        if (hasBias) {\n          inputVars.push(inputVariable('b', inputs[2].dataType, inputs[2].dims.length));\n        }\n\n        const uniforms: UniformsArrayType = [\n          {name: 'output_size', type: 'u32'}, {name: 'dilations', type: 'u32', length: attributes.dilations.length},\n          {name: 'strides', type: 'u32', length: 2}, {name: 'pads', type: 'u32', length: 2},\n          {name: 'output_channels_per_group', type: 'u32'}\n        ];\n        appendActivationUniforms(attributes, uniforms);\n        return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n    let outputIndices = ${output.offsetToIndices('global_idx')};\n    let batch: u32 = outputIndices[0];\n    let output_channel: u32 = outputIndices[${isChannelLast ? 3 : 1}];\n    let xRCCorner: vec2<u32> = vec2<u32>(outputIndices[${isChannelLast ? 1 : 2}], outputIndices[${\n            isChannelLast ? 2 : 3}]) * uniforms.strides - uniforms.pads;\n    let group_id: u32 = output_channel / uniforms.output_channels_per_group;\n\n    var value: ${output.type.value} = ${output.type.value}(0);\n    for (var wInChannel: u32 = 0u; wInChannel < uniforms.w_shape[1]; wInChannel++) {\n      let input_channel = group_id * uniforms.w_shape[1] + wInChannel;\n      for (var wHeight: u32 = 0u; wHeight < uniforms.w_shape[2]; wHeight++) {\n        let xHeight = xRCCorner.x + wHeight * uniforms.dilations[0];\n\n        if (xHeight < 0u || xHeight >= uniforms.x_shape[${isChannelLast ? 1 : 2}]) {\n          continue;\n        }\n\n        for (var wWidth: u32 = 0u; wWidth < uniforms.w_shape[3]; wWidth++) {\n          let xWidth = xRCCorner.y + wWidth * uniforms.dilations[1];\n          if (xWidth < 0u || xWidth >= uniforms.x_shape[${isChannelLast ? 2 : 3}]) {\n            continue;\n          }\n\n          let xVal = ${\n            isChannelLast ? x.get('batch', 'xHeight', 'xWidth', 'input_channel') :\n                            x.get('batch', 'input_channel', 'xHeight', 'xWidth')};\n          let wVal = ${w.get('output_channel', 'wInChannel', 'wHeight', 'wWidth')};\n          value += xVal*wVal;\n        }\n      }\n    }\n    ${processBias}\n    ${applyActivation}\n    ${output.setByOffset('global_idx', 'value')}\n  }`;\n      };\n      return {\n        name: 'GroupedConv',\n        shaderCache: {hint: attributes.cacheKey, inputDependencies},\n        getRunData: () => ({\n          outputs: [{\n            dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,\n            dataType: inputs[0].dataType\n          }],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n\nexport const createGroupedConvVectorizeProgramInfo =\n    (inputs: readonly TensorView[], attributes: ConvAttributes, outputShape: readonly number[]): ProgramInfo => {\n      const hasBias = inputs.length > 2;\n      const components = getMaxComponents(outputShape[3]);\n      const outputNumber = getMaxComponents(outputShape[2]);\n      const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;\n      const xShape = [inputs[0].dims[0], inputs[0].dims[1], inputs[0].dims[2], inputs[0].dims[3] / components];\n      const wShape = [inputs[1].dims[0], inputs[1].dims[1], inputs[1].dims[2], inputs[1].dims[3] / components];\n      const outputShapeInShader = [outputShape[0], outputShape[1], outputShape[2], outputShape[3] / components];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize},\n        {type: DataType.int32, data: [attributes.strides[0], attributes.strides[1]]},\n        {type: DataType.int32, data: [attributes.pads[0], attributes.pads[1]]}\n      ];\n      appendActivationUniformsData(attributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(xShape, wShape, outputShapeInShader));\n      const xNumber = (outputNumber - 1) * attributes.strides[1] + wShape[1];\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const output = outputVariable('output', inputs[0].dataType, outputShapeInShader.length, components);\n        const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n        const applyActivation = getActivationSnippet(attributes, output.type.value, baseType);\n        const x = inputVariable('x', inputs[0].dataType, xShape.length, components);\n        const w = inputVariable('w', inputs[1].dataType, wShape.length, components);\n        const inputVars = [x, w];\n        if (hasBias) {\n          inputVars.push(inputVariable('b', inputs[2].dataType, inputs[2].dims, components));\n        }\n        const processBias = hasBias ? 'value += b[output_channel];' : '';\n        const uniforms: UniformsArrayType = [\n          {name: 'output_size', type: 'u32'},\n          {name: 'strides', type: 'i32', length: 2},\n          {name: 'pads', type: 'i32', length: 2},\n        ];\n        appendActivationUniforms(attributes, uniforms);\n        return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n    let width0 = uniforms.output_shape[3];\n    let output_channel = global_idx % width0;\n    var index1 = global_idx / width0;\n    let width1 = uniforms.output_shape[2] / ${outputNumber}u;\n    let col = (index1 % width1) * ${outputNumber}u;\n    index1 = index1 / width1;\n    let row = index1 % uniforms.output_shape[1];\n    let batch = index1 / uniforms.output_shape[1];\n\n    let x_corner = vec2<i32>(i32(row), i32(col)) * uniforms.strides - uniforms.pads;\n\n    var x_vals: array<${x.type.value}, ${xNumber}>;\n    var values: array<${output.type.value}, ${outputNumber}>;\n    let input_channel = output_channel;\n    // Use constant instead of uniform can give better performance for w's height/width.\n    for (var w_height: u32 = 0u; w_height < ${wShape[0]}; w_height++) {\n      let x_height = x_corner.x + i32(w_height);\n      if (x_height >= 0 && u32(x_height) < uniforms.x_shape[1]) {\n        for (var i = 0; i < ${xNumber}; i++) {\n          let x_width = x_corner.y + i;\n          if (x_width >= 0 && u32(x_width) < uniforms.x_shape[2]) {\n            x_vals[i] = ${x.get('batch', 'u32(x_height)', 'u32(x_width)', 'input_channel')};\n          } else {\n            x_vals[i] = ${x.type.value}(0);\n          }\n        }\n        for (var w_width: u32 = 0u; w_width < ${wShape[1]}; w_width++) {\n          let w_val = ${w.get('w_height', 'w_width', '0', 'output_channel')};\n          for (var i = 0u; i < ${outputNumber}u; i++) {\n            values[i] = fma(x_vals[i * u32(uniforms.strides[1]) + w_width], w_val, values[i]);\n          }\n        }\n      }\n    }\n\n    for (var i = 0u; i < ${outputNumber}u; i++) {\n      var value = values[i];\n      ${processBias}\n      ${applyActivation}\n      ${output.set('batch', 'row', 'col + i', 'output_channel', 'value')};\n    }\n  }`;\n      };\n\n      return {\n        name: 'GroupedConv-Vectorize',\n        shaderCache: {\n          hint: `${attributes.cacheKey};${components};${outputNumber};${xNumber};${wShape[0]};${wShape[1]}`,\n          inputDependencies: hasBias ? ['rank', 'rank', 'type'] : ['rank', 'rank']\n        },\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {BroadcastUtil, ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createMatmulProgramInfo} from './3rd-party/matmul_packed_webgpu';\nimport {createTensorShapeVariables, getBroadcastDims, getMaxComponents, IndicesHelper, inputVariable, internalVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from './common';\nimport {appendActivationUniforms, appendActivationUniformsData, getActivationSnippet, InternalActivationAttributes} from './fuse-utils';\n\nexport const createNaiveMatmulProgramInfo =\n    (inputs: readonly TensorView[], activationAttributes: InternalActivationAttributes, outputShape: readonly number[],\n     reshapedOutputShape?: readonly number[],\n     isChannelsLast = false /* only used for conv2dByMatMul*/): ProgramInfo => {\n      const aShape = inputs[0].dims;\n      const bShape = inputs[1].dims;\n\n      const M = aShape[aShape.length - 2];\n      const N = bShape[bShape.length - 1];\n      const K = aShape[aShape.length - 1];\n      const components = getMaxComponents(N);\n      const aComponents = getMaxComponents(K);\n      const outputNumber = getMaxComponents(M);\n      const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;\n      const hasBias = inputs.length > 2;\n      const outerDims = reshapedOutputShape ? reshapedOutputShape.slice(0, -2) : outputShape.slice(0, -2);\n      const batchSize = ShapeUtil.size(outerDims);\n      const outputShapeInShader = [batchSize, M, N];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: M}, {type: DataType.uint32, data: N},\n        {type: DataType.uint32, data: K}\n      ];\n      appendActivationUniformsData(activationAttributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(outerDims, aShape, bShape));\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShapeInShader));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const batchDims = internalVariable('batch_dims', inputs[0].dataType, outerDims.length);\n        const a = inputVariable('a', inputs[0].dataType, aShape.length, aComponents);\n        const b = inputVariable('b', inputs[1].dataType, bShape.length, components);\n        const output = outputVariable('output', inputs[0].dataType, outputShapeInShader.length, components);\n        const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n        const applyActivation = getActivationSnippet(activationAttributes, output.type.value, baseType);\n        const inputVariables = [a, b];\n        let processBias = '';\n        if (hasBias) {\n          const biasComponents = isChannelsLast ? components : 1;\n          inputVariables.push(inputVariable('bias', inputs[2].dataType, inputs[2].dims.length, biasComponents));\n          processBias = `${\n              isChannelsLast ? `value += bias[col / ${biasComponents}];` :\n                               `value += ${output.type.value}(bias[row + i]);`}`;\n        }\n\n        const outerDimsA = aShape.slice(0, -2);\n        const outerDimsB = bShape.slice(0, -2);\n        const broadCastADims = getBroadcastDims(outerDimsA, outerDims);\n        const broadCastBDims = getBroadcastDims(outerDimsB, outerDims);\n        const uniforms: UniformsArrayType = [\n          {name: 'output_size', type: 'u32'}, {name: 'M', type: 'u32'}, {name: 'N', type: 'u32'},\n          {name: 'K', type: 'u32'}\n        ];\n        appendActivationUniforms(activationAttributes, uniforms);\n\n        const getIndices = (variable: IndicesHelper, broadCastDims: number[]) => {\n          const rank = variable.rank;\n          const name = variable.name;\n          if (rank === 2) {\n            return `var ${name}_indices = ${variable.type.indices}(0u, 0u);`;\n          }\n          const batchRank = batchDims.rank;\n          let resStr = `var ${name}_indices: ${variable.type.indices};`;\n          for (let i = rank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) {\n            resStr += `\\n${name}_indices[${i}] = ${batchRank > 1 ? `batch_indices[${j}]` : 'batch_indices'};`;\n          }\n          broadCastDims.forEach(i => {\n            resStr += `\\n${name}_indices[${i}] = 0;`;\n          });\n          resStr += `${name}_indices[${rank - 2}] = 0u;\n                     ${name}_indices[${rank - 1}] = 0u;`;\n          return resStr;\n        };\n\n        const calcResult = (): string => {\n          let calcStr = `var a_data: ${a.type.value};`;\n          for (let i = 0; i < aComponents; i++) {\n            calcStr += `\n              let b_data${i} = b[(b_offset + (k + ${i}) * uniforms.N + col) / ${components}];`;\n          }\n          for (let i = 0; i < outputNumber; i++) {\n            calcStr += `a_data = a[(a_offset + (row + ${i}) * uniforms.K + k) / ${aComponents}];`;\n\n            for (let j = 0; j < aComponents; j++) {\n              calcStr += `\n            values[${i}] = fma(${b.type.value}(a_data${aComponents === 1 ? '' : `[${j}]`}), b_data${j}, values[${\n                  i}]);\\n`;\n            }\n          }\n          return calcStr;\n        };\n\n        return `\n  ${\n            shaderHelper.registerUniforms(uniforms).registerInternalVariables(batchDims).declareVariables(\n                ...inputVariables, output)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n    let col = (global_idx % (uniforms.N / ${components})) * ${components};\n    var index1 = global_idx / (uniforms.N / ${components});\n    let stride1 = uniforms.M / ${outputNumber};\n    let row = (index1 % stride1) * ${outputNumber};\n    let batch = index1 / stride1;\n\n    ${outputShape.length === 2 ? '' : `let batch_indices = ${batchDims.offsetToIndices('batch')};`}\n    ${getIndices(a, broadCastADims)}\n    let a_offset = ${a.indicesToOffset('a_indices')};\n    ${getIndices(b, broadCastBDims)}\n    let b_offset = ${b.indicesToOffset('b_indices')};\n    var values: array<${output.type.value}, ${outputNumber}>;\n    for (var k: u32 = 0u; k < uniforms.K; k = k + ${aComponents}) {\n      ${calcResult()}\n    }\n    for (var i = 0u; i < ${outputNumber}u; i++) {\n      var value = values[i];\n      ${processBias}\n      ${applyActivation}\n      let cur_indices = ${output.type.indices}(batch, row + i, col);\n      let offset = ${output.indicesToOffset('cur_indices')};\n      ${output.setByOffset(`offset / ${components}`, 'value')};\n    }\n  }\n  `;\n      };\n      return {\n        name: 'MatMulNaive',\n        shaderCache: {\n          hint: `${activationAttributes.activation};${components};${aComponents};${outputNumber};${isChannelsLast}`,\n          inputDependencies: hasBias ? ['rank', 'rank', 'rank'] : ['rank', 'rank']\n        },\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource\n      };\n    };\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('MatMul requires 2 inputs.');\n  }\n\n  if (inputs[0].dims[inputs[0].dims.length - 1] !== inputs[1].dims[inputs[1].dims.length - 2]) {\n    throw new Error('shared dimension does not match.');\n  }\n};\n\nexport const matMul = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  const outputShape = BroadcastUtil.calcShape(context.inputs[0].dims, context.inputs[1].dims, true);\n  if (!outputShape) {\n    throw new Error('Can\\'t use matmul on the given tensors');\n  }\n  const N = outputShape[outputShape.length - 1];\n  const K = context.inputs[0].dims[context.inputs[0].dims.length - 1];\n  if (N < 8 && K < 8) {\n    context.compute(createNaiveMatmulProgramInfo(context.inputs, {activation: ''}, outputShape));\n  } else {\n    context.compute(createMatmulProgramInfo(context.inputs, {activation: ''}, outputShape));\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorView} from '../../tensor-view';\nimport {PoolConvUtil} from '../../util';\nimport {AttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext} from '../types';\n\nimport {createConv2DMatMulProgramInfo} from './3rd-party/conv2d_mm_webgpu';\nimport {createMatmulProgramInfo} from './3rd-party/matmul_packed_webgpu';\nimport {createGroupedConvProgramInfo, createGroupedConvVectorizeProgramInfo} from './conv-grouped';\nimport {InternalActivationAttributes, parseInternalActivationAttributes} from './fuse-utils';\nimport {createNaiveMatmulProgramInfo} from './matmul';\nimport {createTransposeProgramInfo} from './transpose';\n\nexport const calculateOutputShape =\n    (inputShape: readonly number[], kernelShape: readonly number[], dilations: readonly number[],\n     adjustPads: readonly number[], strides: readonly number[], isChannelLast: boolean): number[] => {\n      const batchSize = inputShape[0];\n      const inputSpatialShape = inputShape.slice(isChannelLast ? 1 : 2, isChannelLast ? 3 : 4);\n      const spatialRank = inputSpatialShape.length;\n      const outChannels = kernelShape[0];\n      const kernelSpatialShape = kernelShape.slice(2);\n      const dilatedKernelShape = kernelSpatialShape.map((v, i) => v + (v - 1) * (dilations[i] - 1));\n      const inputSpatialShapeWithPad = inputSpatialShape.map((v, i) => v + adjustPads[i] + adjustPads[i + spatialRank]);\n      const outputShape =\n          inputSpatialShapeWithPad.map((v, i) => Math.floor((v - dilatedKernelShape[i] + strides[i]) / strides[i]));\n      outputShape.splice(0, 0, batchSize);\n      outputShape.splice(isChannelLast ? 3 : 1, 0, outChannels);\n      return outputShape;\n    };\n\nexport interface ConvAttributes extends InternalActivationAttributes, AttributeWithCacheKey {\n  readonly autoPad: string;\n  readonly dilations: readonly number[];\n  readonly format: 'NHWC'|'NCHW';\n  readonly group: number;\n  readonly kernelShape: readonly number[];\n  readonly pads: readonly number[];\n  readonly strides: readonly number[];\n  readonly wIsConst: boolean;\n}\n\n// for transposing weight tensor from [M, C/group, KH, KW] to [KH, KW, C/group, M]\nconst weightTransposeAttribute = [2, 3, 1, 0];\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: ConvAttributes): void => {\n  // Refer to the below link for all input checks\n  // https://github.com/onnx/onnx/blob/master/docs/Operators.md#Conv\n  if (!inputs || (inputs.length !== 2 && inputs.length !== 3)) {\n    throw new Error('Conv requires 2 or 3 inputs');\n  }\n\n  // TODO : Need to add support for multi-dimensional conv\n  if (inputs[0].dims.length !== 4 && inputs[0].dims.length !== 3) {\n    throw new Error('currently only support conv 1D and 2D');\n  }\n\n  if (inputs[0].dims.length !== inputs[1].dims.length) {\n    throw new Error('filter does not have same dimension as input');\n  }\n\n  // FILTER_IN_CHANNEL should be equal to DATA_CHANNEL\n  const dataChannel = inputs[0].dims[attributes.format === 'NHWC' ? inputs[0].dims.length - 1 : 1];\n  const filterInChannel = inputs[1].dims[1] * attributes.group;\n  if (dataChannel !== filterInChannel) {\n    throw new Error('FILTER_IN_CHANNEL should be equal to DATA_CHANNEL');\n  }\n\n  // if bias is provided it should be 1D and the number of elements should be equal to the number of feature maps\n  if (inputs.length === 3 && (inputs[2].dims.length !== 1 || inputs[1].dims[0] !== inputs[2].dims[0])) {\n    throw new Error('invalid bias');\n  }\n\n  const spatialRank = inputs[0].dims.length - 2;\n  // wrong dilations dimension\n  if (attributes.dilations.length !== spatialRank) {\n    throw new Error(`dilations should be ${spatialRank}D`);\n  }\n\n  // Wrong strides dimension\n  if (attributes.strides.length !== spatialRank) {\n    throw new Error(`strides should be ${spatialRank}D`);\n  }\n\n  // Wrong pads dimension\n  if (attributes.pads.length !== spatialRank * 2) {\n    throw new Error(`pads should be ${spatialRank * 2}D`);\n  }\n\n  // if kernelShape is specified, it's data length must be 2 less than dims length of the weights tensor\n  // (the first 2 dims are batch_size and channels)\n  if (attributes.kernelShape.length !== 0 && attributes.kernelShape.length !== inputs[1].dims.length - 2) {\n    throw new Error('invalid kernel shape');\n  }\n};\n\nconst getAdjustedConvAttributes = <T extends ConvAttributes>(attributes: T, inputs: readonly TensorView[]): T => {\n  const kernelShape = attributes.kernelShape.slice();\n  // if kernelShape is not specified in the attributes of this op, infer it from the weight tensor dims\n  for (let i = 2; i < inputs[1].dims.length; ++i) {\n    if (kernelShape[i - 2] === 0) {\n      kernelShape[i - 2] = inputs[1].dims[i];\n    }\n  }\n  const pads = attributes.pads.slice();\n  PoolConvUtil.adjustPadsBasedOnAutoPad(\n      inputs[0].dims, attributes.strides, attributes.dilations, kernelShape, pads, attributes.format === 'NHWC',\n      attributes.autoPad);\n\n  // always return a new object so does not modify the original attributes\n  const newAttributes: T = Object.assign({}, attributes);\n  Object.assign(newAttributes, {kernelShape, pads});\n  return newAttributes;\n};\n\nexport const parseConvAttributes = (attributes: Record<string, unknown>): ConvAttributes => {\n  const activationAttributes = parseInternalActivationAttributes(attributes);\n  // TODO : Make this generic enough to compute default attributes for multi-dimensional conv\n  const format = attributes.format as 'NHWC' | 'NCHW';\n  const autoPad = ['NOTSET', 'VALID', 'SAME_UPPER', 'SAME_LOWER'][attributes.auto_pad as number];\n  const dilations = attributes.dilations as [number, number];\n  const group = attributes.group as number;\n  const kernelShape = attributes.kernel_shape as [number, number];\n  const pads = attributes.pads as [number, number, number, number];\n  const strides = attributes.strides as [number, number];\n  const wIsConst = (attributes.w_is_const as () => boolean)();\n\n  return {\n    autoPad,\n    format,\n    dilations,\n    group,\n    kernelShape,\n    pads,\n    strides,\n    wIsConst,\n    ...activationAttributes,\n    cacheKey: `${attributes.format};${activationAttributes.activation};`\n  };\n};\n\nconst conv2d = (context: ComputeContext, inputs: readonly TensorView[], attributes: ConvAttributes): void => {\n  const adjustedAttributes = getAdjustedConvAttributes(attributes, inputs);\n\n  // check attributes\n\n  // const hasPreluActivationWeights = false; /* TODO: add support for prelu activation weights */\n  const isChannelsLast = attributes.format === 'NHWC';\n  if (attributes.group !== 1) {\n    // NVIDIA GPU with ampere architecture fails with below 2 cases, but we couldn't repro them with any other\n    // GPUs. So just disable vectorize on NVIDIA ampere to ensure always correct outputs.\n    // [webgpu]Conv - conv - vectorize group - B\n    // [webgpu]Conv - conv - vectorize group - D\n    const enableGroupedConvVectorize = !context.adapterInfo.isArchitecture('ampere');\n    if (enableGroupedConvVectorize && isChannelsLast && inputs[1].dims[0] === attributes.group &&\n        inputs[1].dims[1] === 1 && attributes.dilations[0] === 1 && attributes.dilations[1] === 1) {\n      const outputShape = calculateOutputShape(\n          inputs[0].dims, inputs[1].dims, attributes.dilations, adjustedAttributes.pads, attributes.strides,\n          isChannelsLast);\n      const transposedWeight = (context.kernelCustomData.wT as TensorView | undefined) ??\n          context.compute(\n              createTransposeProgramInfo(inputs[1], weightTransposeAttribute),\n              {inputs: [1], outputs: [attributes.wIsConst ? -2 : -1]})[0];\n      if (attributes.wIsConst && !context.kernelCustomData.wT) {\n        context.kernelCustomData.wT = transposedWeight;\n      }\n      const convInputs = [inputs[0], transposedWeight];\n      if (inputs.length === 3) {\n        convInputs.push(inputs[2]);\n      }\n      context.compute(\n          createGroupedConvVectorizeProgramInfo(convInputs, adjustedAttributes, outputShape), {inputs: convInputs});\n    } else {\n      context.compute(createGroupedConvProgramInfo(inputs, adjustedAttributes));\n    }\n    return;\n  }\n\n  const hasBias = inputs.length === 3;\n  const inputHeight = inputs[0].dims[isChannelsLast ? 1 : 2];\n  const inputWidth = inputs[0].dims[isChannelsLast ? 2 : 3];\n  const inputChannels = inputs[0].dims[isChannelsLast ? 3 : 1];\n  const weightHeight = inputs[1].dims[2];\n  const weightWidth = inputs[1].dims[3];\n\n  const outputShape = calculateOutputShape(\n      inputs[0].dims, inputs[1].dims, attributes.dilations, adjustedAttributes.pads, attributes.strides,\n      isChannelsLast);\n  const outHeight = outputShape[isChannelsLast ? 1 : 2];\n  const outWidth = outputShape[isChannelsLast ? 2 : 3];\n  const outChannels = outputShape[isChannelsLast ? 3 : 1];\n\n  const sameSize = isChannelsLast && weightHeight === inputHeight && weightWidth === inputWidth &&\n      attributes.pads[0] === 0 && attributes.pads[1] === 0;\n  if (sameSize ||\n      (weightHeight === 1 && weightWidth === 1 && attributes.dilations[0] === 1 && attributes.dilations[1] === 1 &&\n       attributes.strides[0] === 1 && attributes.strides[1] === 1 && attributes.pads[0] === 0 &&\n       attributes.pads[1] === 0)) {\n    // conv2dByMatMul\n    const batch = outputShape[0];\n    let xReshaped, wReshaped, matmulOutputShape;\n    const matmulInputs = [];\n    if (isChannelsLast) {\n      const transposedWeight = (context.kernelCustomData.wT as TensorView | undefined) ??\n          context.compute(\n              createTransposeProgramInfo(inputs[1], weightTransposeAttribute),\n              {inputs: [1], outputs: [attributes.wIsConst ? -2 : -1]})[0];\n      if (attributes.wIsConst && !context.kernelCustomData.wT) {\n        context.kernelCustomData.wT = transposedWeight;\n      }\n      if (sameSize) {\n        const sharedDim = inputHeight * inputWidth * inputChannels;\n        xReshaped = inputs[0].reshape([1, batch, sharedDim]);\n        wReshaped = transposedWeight.reshape([1, sharedDim, outChannels]);\n        matmulOutputShape = [1, batch, outChannels];\n      } else {\n        xReshaped = inputs[0].reshape([batch, inputHeight * inputWidth, inputChannels]);\n        wReshaped = transposedWeight.reshape([1, inputChannels, outChannels]);\n        matmulOutputShape = [batch, outHeight * outWidth, outChannels];\n      }\n      matmulInputs.push(xReshaped);\n      matmulInputs.push(wReshaped);\n    } else {\n      xReshaped = inputs[0].reshape([batch, inputChannels, inputHeight * inputWidth]);\n      wReshaped = inputs[1].reshape([1, outChannels, inputChannels]);\n      matmulOutputShape = [batch, outChannels, outHeight * outWidth];\n      matmulInputs.push(wReshaped);\n      matmulInputs.push(xReshaped);\n    }\n    if (hasBias) {\n      matmulInputs.push(inputs[2]);\n    }\n    const N = matmulOutputShape[2];\n    const K = matmulInputs[0].dims[matmulInputs[0].dims.length - 1];\n    // Tune the threshold.\n    if (N < 8 && K < 8) {\n      context.compute(\n          createNaiveMatmulProgramInfo(\n              matmulInputs, adjustedAttributes, outputShape, matmulOutputShape, isChannelsLast),\n          {inputs: matmulInputs});\n    } else {\n      context.compute(\n          createMatmulProgramInfo(matmulInputs, adjustedAttributes, outputShape, matmulOutputShape, isChannelsLast),\n          {inputs: matmulInputs});\n    }\n    return;\n  }\n\n  // TODO: implement conv2dWithIm2Col()\n\n  const sequentialAccessByThreads = /* backend.adapterInfo.isIntel() */ true;\n\n  // STEP.1: transpose weight\n  const transposedWeight = (context.kernelCustomData.wT as TensorView | undefined) ??\n      context.compute(\n          createTransposeProgramInfo(inputs[1], weightTransposeAttribute),\n          {inputs: [1], outputs: [attributes.wIsConst ? -2 : -1]})[0];\n  if (attributes.wIsConst && !context.kernelCustomData.wT) {\n    context.kernelCustomData.wT = transposedWeight;\n  }\n\n  // STEP.2: prepare reshaped inputs\n  const convInputs = [inputs[0], transposedWeight];\n  if (hasBias) {\n    convInputs.push(inputs[2]);\n  }\n\n  // STEP.3: compute matmul\n  const dimAOuter = isChannelsLast ? outHeight * outWidth : outChannels;\n  const dimBOuter = isChannelsLast ? outChannels : outHeight * outWidth;\n  const dimInner = weightHeight * weightWidth * inputChannels;\n  context.compute(\n      createConv2DMatMulProgramInfo(\n          convInputs, adjustedAttributes, outputShape, dimAOuter, dimBOuter, dimInner, hasBias,\n          sequentialAccessByThreads),\n      {inputs: convInputs});\n};\n\nconst conv1d = (context: ComputeContext, attributes: ConvAttributes): void => {\n  // extend the input to 2D by adding H dimension\n  const isChannelLast = attributes.format === 'NHWC';\n  const inputs = [\n    context.inputs[0].reshape(\n        isChannelLast ?\n            // [N, W, C] -> [N, H=1, W, C]\n            [context.inputs[0].dims[0], 1, context.inputs[0].dims[1], context.inputs[0].dims[2]] :\n            // [N, C, W] -> [N, C, H=1, W]\n            [context.inputs[0].dims[0], context.inputs[0].dims[1], 1, context.inputs[0].dims[2]]),\n    //[FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kW] -> [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kH=1, kW]\n    context.inputs[1].reshape([context.inputs[1].dims[0], context.inputs[1].dims[1], 1, context.inputs[1].dims[2]])\n  ];\n  if (context.inputs.length === 3) {\n    inputs.push(context.inputs[2]);\n  }\n  const pads = [0, attributes.pads[0], 0, attributes.pads[1]];\n  const strides = [1].concat(attributes.strides);\n  const dilations = [1].concat(attributes.dilations);\n  const kernelShape = [1].concat(attributes.kernelShape);\n  const adjustedAttributes = getAdjustedConvAttributes({...attributes, pads, strides, dilations, kernelShape}, inputs);\n  context.compute(createGroupedConvProgramInfo(\n      inputs, adjustedAttributes,\n      outputShape => isChannelLast ? [outputShape[0], outputShape[2], outputShape[3]] : []));\n};\n\nexport const conv = (context: ComputeContext, attributes: ConvAttributes): void => {\n  validateInputs(context.inputs, attributes);  // currently will fail if not conv1D/2D\n  if (context.inputs[0].dims.length === 3) {\n    conv1d(context, attributes);\n  } else {\n    conv2d(context, context.inputs, attributes);\n  }\n};\n", "/**\n * @license\n * Copyright 2021 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/conv_backprop_mm_webgpu.ts\n//\n// modified to fit the needs of the project\n\nimport {DataType} from '../../../../wasm-common';\nimport {LOG_DEBUG} from '../../../log';\nimport {TensorView} from '../../../tensor-view';\nimport {ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../../types';\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from '../common';\nimport {ConvTransposeAttributes} from '../conv-transpose';\nimport {appendActivationUniforms, appendActivationUniformsData, getActivationSnippet} from '../fuse-utils';\n\nimport {biasSnippet} from './activation_util';\nimport {utilFunctions} from './conv_util';\nimport {makeMatMulPackedSource, makeMatMulPackedVec4Source} from './matmul_packed_webgpu';\n\nconst conv2dTransposeCommonSnippet =\n    (isChannelsLast: boolean, addBias = false, attributes: ConvTransposeAttributes, type: string,\n     innerElementSize = 4): string => {\n      const getWSnippet = (innerElementSize: number) => {\n        switch (innerElementSize) {\n          case 1:\n            return 'return w[getIndexFromCoords4D(coord, vec4<i32>(uniforms.w_shape))];';\n          case 4:\n            return `\n            let coord1 = vec4<i32>(coordX, coordY, col + 1, rowInner);\n            let coord2 = vec4<i32>(coordX, coordY, col + 2, rowInner);\n            let coord3 = vec4<i32>(coordX, coordY, col + 3, rowInner);\n            let v0 = w[getIndexFromCoords4D(coord, vec4<i32>(uniforms.w_shape))];\n            let v1 = w[getIndexFromCoords4D(coord1, vec4<i32>(uniforms.w_shape))];\n            let v2 = w[getIndexFromCoords4D(coord2, vec4<i32>(uniforms.w_shape))];\n            let v3 = w[getIndexFromCoords4D(coord3, vec4<i32>(uniforms.w_shape))];\n            return ${type}(v0, v1, v2, v3);\n            `;\n          default:\n            throw new Error(`innerElementSize ${innerElementSize} is not supported.`);\n        }\n      };\n      const coordASnippet = isChannelsLast ? `\n      let coord = vec4<i32>(batch, iXR, iXC, xCh);\n      ` :\n                                             `\n      let coord = vec4<i32>(batch, xCh, iXR, iXC);\n      `;\n\n      const coordResSnippet = isChannelsLast ? `\n    let coords = vec4<i32>(\n      batch,\n      row / outWidth,\n      row % outWidth,\n      col);\n    ` :\n                                               `\n    let coords = vec4<i32>(\n      batch,\n      row,\n      col / outWidth,\n      col % outWidth);\n    `;\n\n      const xHeight = isChannelsLast ? 'i32(uniforms.x_shape[1])' : 'i32(uniforms.x_shape[2])';\n      const xWidth = isChannelsLast ? 'i32(uniforms.x_shape[2])' : 'i32(uniforms.x_shape[3])';\n      const row = isChannelsLast ? 'row' : 'col';\n      const col = isChannelsLast ? 'col' : 'row';\n\n      const readASnippet = `\n      let inChannels = ${isChannelsLast ? 'i32(uniforms.x_shape[3])' : 'i32(uniforms.x_shape[1])'};\n      let outWidth = ${isChannelsLast ? 'i32(uniforms.result_shape[2])' : 'i32(uniforms.result_shape[3])'};\n      let outRow = ${row} / outWidth;\n      let outCol = ${row} % outWidth;\n\n      let WRow = ${col} / (uniforms.filter_dims[1] * inChannels);\n      let WCol = ${col} / inChannels % uniforms.filter_dims[1];\n      let xR = f32(outRow - uniforms.pads[0] + uniforms.dilations[0] * WRow) / f32(uniforms.strides[0]);\n      let xC = f32(outCol - uniforms.pads[1] + uniforms.dilations[1] * WCol) / f32(uniforms.strides[1]);\n      if (xR < 0.0 || xR >= f32(${xHeight}) || fract(xR) > 0.0) {\n        return ${type}(0.0);\n      }\n      if (xC < 0.0 || xC >= f32(${xWidth}) || fract(xC) > 0.0) {\n        return ${type}(0.0);\n      }\n      let iXR = i32(xR);\n      let iXC = i32(xC);\n      let xCh = ${col} % inChannels;\n      ${coordASnippet}\n      return x[getIndexFromCoords4D(coord, vec4<i32>(uniforms.x_shape))/${innerElementSize}];`;\n\n      const sampleA = isChannelsLast ? `\n      let col = colIn * ${innerElementSize};\n      if (row < uniforms.dim_a_outer && col < uniforms.dim_inner) {\n        ${readASnippet}\n      }\n      return ${type}(0.0);` :\n                                       `\n      let col = colIn * ${innerElementSize};\n      if (row < uniforms.dim_inner && col < uniforms.dim_b_outer) {\n        ${readASnippet}\n      }\n      return ${type}(0.0);`;\n\n      const sampleW = `\n      let col = colIn * ${innerElementSize};\n      let inChannels = ${isChannelsLast ? 'i32(uniforms.x_shape[3])' : 'i32(uniforms.x_shape[1])'};\n      let coordX = uniforms.filter_dims[0] - 1 - row / (uniforms.filter_dims[1] * inChannels);\n      let coordY = uniforms.filter_dims[1] - 1 - (row / inChannels) % uniforms.filter_dims[1];\n      if (${\n          isChannelsLast ? 'row < uniforms.dim_inner && col < uniforms.dim_b_outer' :\n                           'row < uniforms.dim_inner && col < uniforms.dim_a_outer'}  && coordX >= 0 && coordY >= 0) {\n        let rowInner = row % inChannels;\n        let coord = vec4<i32>(coordX, coordY, col, rowInner);\n        ${getWSnippet(innerElementSize)}\n      }\n      return ${type}(0.0);\n      `;\n\n      const applyActivation = getActivationSnippet(attributes, type);\n      const userCode = `\n  fn mm_readA(batch: i32, row : i32, colIn : i32) -> ${type} {\n    ${isChannelsLast ? sampleA : sampleW}\n  }\n\n  fn mm_readB(batch: i32, row : i32, colIn : i32) -> ${type} {\n    ${isChannelsLast ? sampleW : sampleA}\n  }\n\n  fn mm_write(batch: i32, row : i32, colIn : i32, valueInput : ${type}) {\n    let col = colIn * ${innerElementSize};\n    if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer) {\n      var value = valueInput;\n      let outWidth = ${isChannelsLast ? 'i32(uniforms.result_shape[2])' : 'i32(uniforms.result_shape[3])'};\n      ${coordResSnippet}\n      ${biasSnippet(addBias)}\n      ${applyActivation}\n      result[getIndexFromCoords4D(coords, vec4<i32>(uniforms.result_shape))/${innerElementSize}] = value;\n    }\n  }`;\n      return userCode;\n    };\n\nexport const createConv2DTransposeMatMulProgramInfo =\n    (inputs: readonly TensorView[], attributes: ConvTransposeAttributes, outputShape: readonly number[],\n     dimAOuter: number, dimBOuter: number, dimInner: number, hasBias: boolean,\n     sequentialAccessByThreads: boolean): ProgramInfo => {\n      const isChannelsLast = attributes.format === 'NHWC';\n      const inChannels = isChannelsLast ? inputs[0].dims[3] : inputs[0].dims[1];\n      const batchSize = outputShape[0];\n      const outWidth = isChannelsLast ? outputShape[2] : outputShape[3];\n      const outHeight = isChannelsLast ? outputShape[1] : outputShape[2];\n      const outChannels = isChannelsLast ? outputShape[3] : outputShape[1];\n      // TODO: enable vec4 for NCHW\n      const isVec4 = isChannelsLast && (inChannels % 4 === 0 && inChannels % 3) && outChannels % 4 === 0;\n\n      // TODO: fine tune size\n      const dispatchX = isChannelsLast ? outChannels : outWidth * outHeight;\n      const dispatchY = isChannelsLast ? outWidth * outHeight : outChannels;\n      const workGroupSize: [number, number, number] = [8, 8, 1];\n      const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];\n      const dispatch = [\n        Math.ceil(dispatchX / workGroupSize[0] / elementsPerThread[0]),\n        Math.ceil(dispatchY / workGroupSize[1] / elementsPerThread[1]),\n        Math.ceil(batchSize / workGroupSize[2] / elementsPerThread[2])\n      ];\n\n      LOG_DEBUG('verbose', () => `[conv_backprop_mm_webgpu] dispatch = ${dispatch}`);\n\n      const innerElementSize = isVec4 ? 4 : 1;\n      const tileInner = Math.max(workGroupSize[0] * innerElementSize, workGroupSize[1]);\n      const components = isVec4 ? 4 : 1;\n      const filterDims =\n          [attributes.kernelShape[isChannelsLast ? 1 : 2], attributes.kernelShape[isChannelsLast ? 2 : 3]];\n      const effectiveFilterDims = [\n        filterDims[0] + (attributes.dilations[0] <= 1 ? 0 : (filterDims[0] - 1) * (attributes.dilations[0] - 1)),\n        filterDims[1] + (attributes.dilations[1] <= 1 ? 0 : (filterDims[1] - 1) * (attributes.dilations[1] - 1))\n      ];\n      const pads = [\n        effectiveFilterDims[0] - 1 - Math.floor((attributes.pads[0] + attributes.pads[2]) / 2),\n        effectiveFilterDims[1] - 1 - Math.floor((attributes.pads[1] + attributes.pads[3]) / 2)\n      ];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.int32, data: dimAOuter}, {type: DataType.int32, data: dimBOuter},\n        {type: DataType.int32, data: dimInner}, {type: DataType.int32, data: attributes.strides},\n        {type: DataType.int32, data: attributes.dilations}, {type: DataType.int32, data: filterDims},\n        {type: DataType.int32, data: pads}\n      ];\n      appendActivationUniformsData(attributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(inputs[0].dims, inputs[1].dims));\n\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n        inputDependencies.push('rank');\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShape));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const x = inputVariable('x', inputs[0].dataType, inputs[0].dims.length, components);\n        const w = inputVariable('w', inputs[1].dataType, inputs[1].dims.length, 1);\n        const output = outputVariable('result', inputs[0].dataType, outputShape.length, components);\n        const inputVariables = [x, w];\n\n        let declareFunctions = '';\n        if (hasBias) {\n          const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims.length, components);\n          inputVariables.push(bias);\n          declareFunctions += `\n          fn getBiasByOutputCoords(coords : vec4<i32>) -> ${bias.type.value} {\n            return bias[coords.${isChannelsLast ? 'w' : 'y'}${isVec4 ? '/ 4' : ''}];\n          }`;\n        }\n\n        const uniforms: UniformsArrayType = [\n          {name: 'dim_a_outer', type: 'i32'}, {name: 'dim_b_outer', type: 'i32'}, {name: 'dim_inner', type: 'i32'},\n          {name: 'strides', type: 'i32', length: 2}, {name: 'dilations', type: 'i32', length: 2},\n          {name: 'filter_dims', type: 'i32', length: filterDims.length},\n          {name: 'pads', type: 'i32', length: pads.length}\n        ];\n        appendActivationUniforms(attributes, uniforms);\n        const elemType = tensorTypeToWsglStorageType(inputs[0].dataType, 1);\n        if (elemType !== 'f16' && elemType !== 'f32') {\n          throw new Error(`elemType ${elemType} is not supported.`);\n        }\n        return `\n        ${utilFunctions('uniforms.result_strides')}\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)};\n        ${declareFunctions}\n        ${conv2dTransposeCommonSnippet(isChannelsLast, hasBias, attributes, x.type.value, innerElementSize)}\n        ${\n            isVec4 ? makeMatMulPackedVec4Source(\n                         elementsPerThread, workGroupSize, elemType, undefined, !isChannelsLast, tileInner) :\n                     makeMatMulPackedSource(\n                         elementsPerThread, workGroupSize, elemType, undefined, !isChannelsLast, tileInner, false,\n                         undefined, sequentialAccessByThreads)}`;\n      };\n\n      return {\n        name: 'Conv2DTransposeMatMul',\n        shaderCache:\n            {hint: `${attributes.cacheKey};${elementsPerThread};${workGroupSize};${isVec4}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: dispatch[0], y: dispatch[1], z: dispatch[2]},\n          programUniforms\n        }),\n        getShaderSource\n      };\n    };\n", "/**\n * @license\n * Copyright 2021 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/conv_backprop_webgpu.ts\n\nimport {DataType} from '../../../../wasm-common';\nimport {LOG_DEBUG} from '../../../log';\nimport {TensorView} from '../../../tensor-view';\nimport {ShapeUtil} from '../../../util';\nimport {ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../../types';\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from '../common';\nimport {ConvTransposeAttributes} from '../conv-transpose';\n\nconst createConvTranspose2DOpProgramShaderSource =\n    (shaderHelper: ShaderHelper, inputs: readonly TensorView[], outputShape: readonly number[], hasBias: boolean,\n     is1DimensionDispatch: boolean, isVec4 = false, dataType: string, uniforms: UniformsArrayType,\n     isChannelsLast = false): string => {\n      const rowDim = isChannelsLast ? 1 : 2;\n      const colDim = isChannelsLast ? 2 : 3;\n      const channelDim = isChannelsLast ? 3 : 1;\n      const workPerThread = isVec4 ? 2 : 1;\n\n      let declareFunctions = `\n  fn setOutputAtIndex(flatIndex : u32, value : ${isVec4 ? `vec4<${dataType}>` : dataType}) {\n    result[flatIndex] = ${isVec4 ? `vec4<${dataType}>` : dataType}(value);\n  }`;\n      if (hasBias) {\n        declareFunctions += `\n    fn getBiasByOutputCoords(coords : vec4<u32>) -> ${isVec4 ? `vec4<${dataType}>` : dataType} {\n      return bias[coords.${isChannelsLast ? 'w' : 'y'}${isVec4 ? '/ 4' : ''}];\n    }`;\n      }\n      const components = isVec4 ? 4 : 1;\n      const w = inputVariable('W', inputs[1].dataType, inputs[1].dims.length, components);\n      const dy = inputVariable('Dy', inputs[0].dataType, inputs[0].dims.length, components);\n      const inputVariables = [dy, w];\n      if (hasBias) {\n        inputVariables.push(inputVariable('bias', inputs[2].dataType, [outputShape[channelDim]].length, components));\n      }\n      const output = outputVariable('result', inputs[0].dataType, outputShape.length, components);\n\n      const codeSnippet4 = `{\n        let batch: u32 = ${is1DimensionDispatch ? 'global_id.z' : 'workgroup_id.z'} / uniforms.result_shape[1];\n        let r = ${is1DimensionDispatch ? 'global_id.z' : 'workgroup_id.z'} % uniforms.result_shape[1];\n        let c = ${is1DimensionDispatch ? 'global_id.y' : 'workgroup_id.y'} * ${workPerThread};\n        let d1: u32 = ${is1DimensionDispatch ? 'global_id.x' : 'workgroup_id.x'} * 4;\n\n        let dyCorner = vec2<i32>(i32(r), i32(c)) - vec2<i32>(uniforms.pads);\n\n        // Convolve dy(?, ?, d2) with w(:, :, d1, d2) to compute dx(xR, xC, d1).\n        // ? = to be determined. : = across all values in that axis.\n        var dotProd: array<vec4<${dataType}>, ${workPerThread}>;\n        for (var i = 0; i < ${workPerThread}; i++) {\n          dotProd[i] = vec4<${dataType}>(0.0);\n        }\n        for (var wR: u32 = 0; wR < uniforms.filter_dims[0]; wR = wR + 1) {\n          var dyR = (${dataType}(dyCorner.x) + ${dataType}(wR)) / ${dataType}(uniforms.strides.x);\n          let wRPerm = uniforms.filter_dims[0] - 1 - wR;\n          if (dyR < 0.0 || dyR >= ${dataType}(uniforms.Dy_shape[1]) ||\n              fract(dyR) > 0.0 || wRPerm < 0) {\n            continue;\n          }\n          let idyR: u32 = u32(dyR);\n\n          for (var wC: u32 = 0; wC < uniforms.filter_dims[1]; wC = wC + 1) {\n            let dyC = (${dataType}(dyCorner.y) + ${dataType}(wC)) / ${dataType}(uniforms.strides.y);\n            let dyC2 = (${dataType}(dyCorner.y) + 1.0 + ${dataType}(wC)) / ${dataType}(uniforms.strides.y);\n            let wCPerm = uniforms.filter_dims[1] - 1 - wC;\n            if (wCPerm < 0) {\n              continue;\n            }\n            var bDyCVal = true;\n            var bDyCVal2 = true;\n            if (dyC < 0.0 || dyC >= ${dataType}(uniforms.Dy_shape[2]) ||\n                fract(dyC) > 0.0) {\n              bDyCVal = false;\n            }\n            if (dyC2 < 0.0 || dyC2 >= ${dataType}(uniforms.Dy_shape[2]) ||\n                fract(dyC2) > 0.0) {\n              bDyCVal2 = false;\n            }\n\n            let idyC: u32 = u32(dyC);\n            let idyC2: u32 = u32(dyC2);\n            if (bDyCVal && bDyCVal2) {\n              let d2Length = uniforms.Dy_shape[3];\n              for (var d2 :u32 = 0; d2 < d2Length; d2 = d2 + 4) {\n                let wValue0 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1', 'd2')};\n                let wValue1 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 1', 'd2')};\n                let wValue2 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 2', 'd2')};\n                let wValue3 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 3', 'd2')};\n\n                var xValue = ${dy.get('batch', 'idyR', 'idyC', 'd2')};\n                let tmpval = vec4<${dataType}>(dot(xValue, wValue0),\n                                      dot(xValue, wValue1),\n                                      dot(xValue, wValue2),\n                                      dot(xValue, wValue3));\n                dotProd[0] = dotProd[0] + tmpval;\n\n                xValue =  ${dy.get('batch', 'idyR', 'idyC2', 'd2')};\n\n                dotProd[1] = dotProd[1] + vec4<${dataType}>(dot(xValue, wValue0),\n                                                    dot(xValue, wValue1),\n                                                    dot(xValue, wValue2),\n                                                    dot(xValue, wValue3));\n              }\n            } else if (bDyCVal) {\n              let d2Length = uniforms.Dy_shape[${channelDim}];\n              for (var d2: u32 = 0; d2 < d2Length; d2 = d2 + 4) {\n                let wValue0 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1', 'd2')};\n                let wValue1 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 1', 'd2')};\n                let wValue2 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 2', 'd2')};\n                let wValue3 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 3', 'd2')};\n\n                var xValue = ${dy.get('batch', 'idyR', 'idyC', 'd2')};\n                let tmpval = vec4<${dataType}>(dot(xValue, wValue0),\n                                      dot(xValue, wValue1),\n                                      dot(xValue, wValue2),\n                                      dot(xValue, wValue3));\n                dotProd[0] = dotProd[0] + tmpval;\n              }\n            } else if (bDyCVal2) {\n              let d2Length = uniforms.Dy_shape[3];\n              for (var d2: u32 = 0; d2 < d2Length; d2 = d2 + 4) {\n                let wValue0 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1', 'd2')};\n                let wValue1 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 1', 'd2')};\n                let wValue2 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 2', 'd2')};\n                let wValue3 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 3', 'd2')};\n\n                var xValue = ${dy.get('batch', 'idyR', 'idyC2', 'd2')};\n                let tmpval = vec4<${dataType}>(dot(xValue, wValue0),\n                                      dot(xValue, wValue1),\n                                      dot(xValue, wValue2),\n                                      dot(xValue, wValue3));\n                dotProd[1] = dotProd[1] + tmpval;\n              }\n            }\n          }\n        }\n\n        for (var i: u32 = 0; i < ${workPerThread}; i = i + 1) {\n          let value = dotProd[i] + ${hasBias ? 'bias[c+i]' : `vec4<${dataType}>(0.0)`};\n          ${output.set('batch', 'r', 'c + i', 'd1', 'value')};\n        }\n      }`;\n      const codeSnippet = `\n          let outputIndices = ${output.offsetToIndices('global_idx')};\n          let batch = ${output.indicesGet('outputIndices', 0)};\n          let d1 = ${output.indicesGet('outputIndices', channelDim)};\n          let r = ${output.indicesGet('outputIndices', rowDim)};\n          let c = ${output.indicesGet('outputIndices', colDim)};\n          let dyCorner = vec2<i32>(i32(r), i32(c)) - uniforms.pads;\n          let dyRCorner = dyCorner.x;\n          let dyCCorner = dyCorner.y;\n          let groupId = d1 / uniforms.output_channels_per_group;\n          let wOutChannel = d1 - groupId * uniforms.output_channels_per_group;\n          // Convolve dy(?, ?, d2) with w(:, :, d1, d2) to compute dx(xR, xC, d1).\n          // ? = to be determined. : = across all values in that axis.\n          var dotProd = ${dataType}(0.0);\n          for (var wR: u32 = 0; wR < uniforms.effective_filter_dims.x; wR = wR + 1) {\n            if (wR % uniforms.dilations.x != 0) {\n              continue;\n            }\n            let dyR = (${dataType}(dyRCorner) + ${dataType}(wR)) / ${dataType}(uniforms.strides[0]);\n            let wRPerm = uniforms.filter_dims.x - 1 - wR / uniforms.dilations.x;\n            if (dyR < 0.0 || dyR >= ${dataType}(uniforms.Dy_shape[${rowDim}]) || fract(dyR) > 0.0 ||\n                wRPerm < 0) {\n              continue;\n            }\n            let idyR: u32 = u32(dyR);\n\n            for (var wC: u32 = 0; wC < uniforms.effective_filter_dims.y; wC = wC + 1) {\n              if (wC % uniforms.dilations.y != 0) {\n                continue;\n              }\n              let dyC = (${dataType}(dyCCorner) + ${dataType}(wC)) / ${dataType}(uniforms.strides.y);\n              let wCPerm = uniforms.filter_dims.y - 1 - wC / uniforms.dilations.y;\n              if (dyC < 0.0 || dyC >= ${dataType}(uniforms.Dy_shape[${colDim}]) ||\n                  fract(dyC) > 0.0 || wCPerm < 0) {\n                continue;\n              }\n              let idyC: u32 = u32(dyC);\n              var inputChannel = groupId * uniforms.input_channels_per_group;\n              for (var d2: u32 = 0; d2 < uniforms.input_channels_per_group; d2 = d2 + 1) {\n                let xValue = ${\n          isChannelsLast ? dy.get('batch', 'idyR', 'idyC', 'inputChannel') :\n                           dy.get('batch', 'inputChannel', 'idyR', 'idyC')};\n                let wValue = ${w.get('inputChannel', 'wOutChannel', 'u32(wRPerm)', 'u32(wCPerm)')};\n                dotProd = dotProd + xValue * wValue;\n                inputChannel = inputChannel + 1;\n              }\n            }\n          }\n          let value = dotProd + ${hasBias ? 'bias[d1]' : `${dataType}(0.0)`};\n          ${output.setByOffset('global_idx', 'value')};\n        `;\n\n      return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n  ${declareFunctions}\n\n    ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')};\n  ${isVec4 ? codeSnippet4 : codeSnippet}}`;\n    };\n\nexport const createConvTranspose2DProgramInfo =\n    (inputs: readonly TensorView[], attributes: ConvTransposeAttributes,\n     squeezeOutputShapeFunction?: (shape: readonly number[]) => number[]): ProgramInfo => {\n      const hasBias = inputs.length > 2;\n      // const isChannelsLast = attributes.format === 'NHWC';\n      const outputShape = attributes.outputShape;\n      const outputSize = ShapeUtil.size(outputShape);\n\n      // const inChannels = inputs[0].dims[isChannelsLast ? 3 : 1];\n      // TODO Enable isVec4 for performance\n      // Disabled due to weight matrix layout issue\n      // const isVec4 = attributes.group === 1 && isChannelsLast && inChannels % 4 === 0 && outChannels % 4 === 0;\n      const dispatch = [\n        Math.ceil(outputSize / 64),\n        1,\n        1,\n      ];\n      LOG_DEBUG('verbose', () => `[conv2d_backprop_webgpu] dispatch = ${dispatch}`);\n\n      const isChannelsLast = attributes.format === 'NHWC';\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n      const strides = [attributes.strides[0], attributes.strides[1]];\n      const filterDims =\n          [attributes.kernelShape[isChannelsLast ? 1 : 2], attributes.kernelShape[isChannelsLast ? 2 : 3]];\n      const dilations = [attributes.dilations[0], attributes.dilations[1]];\n      const effectiveFilterDims = [\n        filterDims[0] +\n            (attributes.dilations[0] <= 1 ?\n                 0 :\n                 (attributes.kernelShape[isChannelsLast ? 1 : 2] - 1) * (attributes.dilations[0] - 1)),\n        filterDims[1] +\n            (attributes.dilations[1] <= 1 ?\n                 0 :\n                 (attributes.kernelShape[isChannelsLast ? 2 : 3] - 1) * (attributes.dilations[1] - 1))\n      ];\n      const pads = [\n        effectiveFilterDims[0] - 1 - Math.floor((attributes.pads[0] + attributes.pads[2]) / 2),\n        effectiveFilterDims[1] - 1 - Math.floor(attributes.pads[1] + attributes.pads[3]) / 2\n      ];\n\n      const isVec4 = false;\n      const group = attributes.group;\n      const wShape = inputs[1].dims;\n      const inputChannelsPerGroup = wShape[0] / group;\n      const outputChannelsPerGroup = wShape[1];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: strides},\n        {type: DataType.uint32, data: filterDims}, {type: DataType.uint32, data: dilations},\n        {type: DataType.uint32, data: effectiveFilterDims}, {type: DataType.int32, data: pads},\n        {type: DataType.uint32, data: inputChannelsPerGroup}, {type: DataType.uint32, data: outputChannelsPerGroup},\n        ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims)\n      ];\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n        inputDependencies.push('rank');\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShape));\n\n      const is1DimensionDispatch = dispatch[1] === 1 && dispatch[2] === 1;\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const uniforms: UniformsArrayType = [\n          {name: 'output_size', type: 'u32'}, {name: 'strides', type: 'u32', length: strides.length},\n          {name: 'filter_dims', type: 'u32', length: filterDims.length},\n          {name: 'dilations', type: 'u32', length: filterDims.length},\n          {name: 'effective_filter_dims', type: 'u32', length: effectiveFilterDims.length},\n          {name: 'pads', type: 'i32', length: pads.length}, {name: 'input_channels_per_group', type: 'u32'},\n          {name: 'output_channels_per_group', type: 'u32'}\n        ];\n        const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n        return `${\n            createConvTranspose2DOpProgramShaderSource(\n                shaderHelper, inputs, outputShape, hasBias, is1DimensionDispatch, isVec4, dataType, uniforms,\n                isChannelsLast)}`;\n      };\n      return {\n        name: 'ConvTranspose2D',\n        shaderCache: {hint: `${attributes.cacheKey};`, inputDependencies},\n        getRunData: () => ({\n          dispatchGroup: {x: dispatch[0], y: dispatch[1], z: dispatch[2]},\n          outputs: [{\n            dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,\n            dataType: inputs[0].dataType\n          }],\n          programUniforms\n        }),\n        getShaderSource\n      };\n    };\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorView} from '../../tensor-view';\nimport {ComputeContext} from '../types';\n\nimport {createConv2DTransposeMatMulProgramInfo} from './3rd-party/conv_backprop_mm_webgpu';\nimport {createConvTranspose2DProgramInfo} from './3rd-party/conv_backprop_webgpu';\nimport {ConvAttributes} from './conv';\nimport {parseInternalActivationAttributes} from './fuse-utils';\nimport {createTransposeProgramInfo} from './transpose';\n\nconst computeTotalPad =\n    (inDim: number, stride: number, adj: number, kernel: number, dilation: number, outSize: number) =>\n        (inDim - 1) * stride + adj + (kernel - 1) * dilation + 1 - outSize;\n\nconst distributePadding = (totalPad: number, autoPad: string, pads: number[], head: number, tail: number) => {\n  const smallPad = Math.floor(totalPad / 2);\n  if (autoPad === 'SAME_UPPER') {\n    pads[head] = smallPad;\n    pads[tail] = totalPad - smallPad;\n  } else if (autoPad === 'SAME_LOWER') {\n    pads[head] = totalPad - smallPad;\n    pads[tail] = smallPad;\n  }\n};\n\nconst calculateOutputShapeAndPads =\n    (inputShape: readonly number[], kernelShape: readonly number[], dilations: readonly number[], autoPad: string,\n     group: number, pads: number[], strides: readonly number[], isChannelLast: boolean, outputPadding: number[],\n     outputShape: number[]) => {\n      const spatialRank = inputShape.length - 2;\n      const updateOutputShape = outputShape.length === 0;\n      if (outputPadding.length === 0) {\n        for (let i = 0; i < spatialRank; ++i) {\n          outputPadding.push(0);\n        }\n      }\n      const batchSize = inputShape[0];\n      const outChannels = kernelShape[isChannelLast ? 3 : 1] * group;\n      for (let i = 0, j = inputShape.length - spatialRank - (isChannelLast ? 1 : 0); i < spatialRank; ++i, ++j) {\n        const inSize = inputShape[j];\n        const outSize = updateOutputShape ? inSize * strides[i] : outputShape[i];\n        const totalPad = computeTotalPad(inSize, strides[i], pads[i], kernelShape[j], dilations[i], outSize);\n        distributePadding(totalPad, autoPad, pads, i, i + spatialRank);\n        if (updateOutputShape) {\n          outputShape.push(\n              strides[i] * (inSize - 1) + outputPadding[i] + (kernelShape[j] - 1) * dilations[i] + 1 - pads[i] -\n              pads[i + spatialRank]);\n        }\n      }\n      outputShape.splice(0, 0, batchSize);\n      outputShape.splice(isChannelLast ? 3 : 1, 0, outChannels);\n    };\n\nexport interface ConvTransposeAttributes extends ConvAttributes {\n  readonly outputPadding: readonly number[];\n  readonly outputShape: readonly number[];\n}\n\nconst getAdjustedConvTransposeAttributes =\n    <T extends ConvTransposeAttributes>(attributes: T, inputs: readonly TensorView[]): T => {\n      const kernelShape = attributes.kernelShape.slice();\n      // if kernelShape is not specified in the attributes of this op, infer it from the weight tensor dims\n      if (attributes.kernelShape.length === 0 || attributes.kernelShape.reduce((a, b) => a * b, 1) === 0) {\n        kernelShape.length = 0;\n        for (let i = 2; i < inputs[1].dims.length; ++i) {\n          kernelShape.push(inputs[1].dims[i]);\n        }\n      }\n      const isChannelsLast = attributes.format === 'NHWC';\n      kernelShape.splice(0, 0, inputs[1].dims[0]);\n      kernelShape.splice(isChannelsLast ? 3 : 1, 0, inputs[1].dims[1]);\n\n      const pads = attributes.pads.slice();\n      const outputShape = attributes.outputShape.slice();\n      const outputPadding = attributes.outputPadding.slice();\n      const inputShape = inputs[0].dims;\n      let dilations = attributes.dilations.slice();\n      if (dilations.reduce((a, b) => a + b, 0) === 0) {\n        const spatialRank = inputs[0].dims.length - 2;\n        dilations = new Array(spatialRank).fill(1);\n      }\n      let strides = attributes.strides.slice();\n      if (strides.reduce((a, b) => a + b, 0) === 0) {\n        const spatialRank = inputs[0].dims.length - 2;\n        strides = new Array(spatialRank).fill(1);\n      }\n      // If outputShape is not specified in the attributes of this op, infer it from the parameters\n      // Similarly, automatically infer pads if not specified\n      calculateOutputShapeAndPads(\n          inputShape, kernelShape, dilations, attributes.autoPad, attributes.group, pads, strides, isChannelsLast,\n          outputPadding, outputShape);\n\n      // always return a new object so does not modify the original attributes\n      const newAttributes: T = Object.assign({}, attributes);\n      Object.assign(newAttributes, {kernelShape, pads, outputPadding, outputShape, dilations, strides});\n      return newAttributes;\n    };\n\nexport const parseConvTransposeAttributes = (attributes: Record<string, unknown>): ConvTransposeAttributes => {\n  const activationAttributes = parseInternalActivationAttributes(attributes);\n  // TODO : Make this generic enough to compute default attributes for multi-dimensional conv\n  const format = attributes.format as 'NHWC' | 'NCHW';\n  const autoPad =\n      ['NOTSET', 'VALID', 'SAME_UPPER',\n       'SAME_LOWER'][typeof attributes.autoPad == 'undefined' ? 0 : attributes.autoPad as number];\n  const dilations = attributes.dilations as [number, number];\n  const group = attributes.group as number;\n  const kernelShape = attributes.kernelShape as [number, number];\n  const pads = attributes.pads as [number, number, number, number];\n  const strides = attributes.strides as [number, number];\n  const wIsConst = (attributes.wIsConst as () => boolean)();\n  const outputPadding = attributes.outputPadding as [number, number, number, number];\n  const outputShape = attributes.outputShape as [number, number];\n  return {\n    autoPad,\n    format,\n    dilations,\n    group,\n    kernelShape,\n    outputPadding,\n    outputShape,\n    pads,\n    strides,\n    wIsConst,\n    ...activationAttributes,\n    cacheKey: `${attributes.format};${activationAttributes.activation};`\n  };\n};\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: ConvTransposeAttributes): void => {\n  // Refer to the below link for all input checks\n  // https://github.com/onnx/onnx/blob/main/docs/Operators.md#ConvTranspose\n  if (!inputs || (inputs.length !== 2 && inputs.length !== 3)) {\n    throw new Error('Conv requires 2 or 3 inputs');\n  }\n\n  // TODO : Need to add support for multi-dimensional conv\n  if (inputs[0].dims.length !== 4 && inputs[0].dims.length !== 3) {\n    throw new Error('currently only support 2-dimensional conv');\n  }\n\n  if (inputs[0].dims.length !== inputs[1].dims.length) {\n    throw new Error('filter does not have same dimension as input');\n  }\n\n  // FILTER_IN_CHANNEL should be equal to DATA_CHANNEL\n  const dataChannel = inputs[0].dims[attributes.format === 'NHWC' ? inputs[0].dims.length - 1 : 1];\n  const filterInChannel = inputs[1].dims[0];\n  if (dataChannel !== filterInChannel) {\n    throw new Error('FILTER_IN_CHANNEL should be equal to DATA_CHANNEL');\n  }\n\n  const featureMaps = inputs[1].dims[1] * attributes.group;\n\n  // if bias is provided it should be 1D and the number of elements should be equal to the number of feature maps\n  if (inputs.length === 3 && (inputs[2].dims.length !== 1 || inputs[2].dims[0] !== featureMaps)) {\n    throw new Error('invalid bias');\n  }\n\n  const spatialRank = inputs[0].dims.length - 2;\n  const dilationsSet = attributes.dilations.reduce((a, b) => a + b, 0) > 0;\n  // wrong dilations dimension\n  if (dilationsSet && attributes.dilations.length !== spatialRank) {\n    throw new Error(`dilations should be ${spatialRank}D`);\n  }\n\n  const stridesSet = attributes.strides.reduce((a, b) => a + b, 0) > 0;\n  // Wrong strides dimension\n  if (stridesSet && attributes.strides.length !== spatialRank) {\n    throw new Error(`strides should be ${spatialRank}D`);\n  }\n\n  // Wrong pads dimension\n  const padsSet = attributes.pads.reduce((a, b) => a + b, 0) > 0;\n  if (padsSet && attributes.pads.length !== spatialRank * 2) {\n    throw new Error(`pads should be ${spatialRank * 2}D`);\n  }\n\n  // Wrong output padding dimension\n  if (attributes.outputPadding.length !== spatialRank && attributes.outputPadding.length !== 0) {\n    throw new Error(`output_padding should be ${spatialRank}D`);\n  }\n\n  // if kernelShape is specified, it's data length must be 2 less than dims length of the weights tensor\n  // (the first 2 dims are batch_size and channels)\n  const kernelShapeSet = attributes.kernelShape.reduce((a, b) => a + b, 0) > 0;\n  if (kernelShapeSet && attributes.kernelShape.length !== 0 &&\n      attributes.kernelShape.length !== inputs[1].dims.length - 2) {\n    throw new Error('invalid kernel shape');\n  }\n\n  // as with kernelShape, must have same number of spatial dims as input\n  if (attributes.outputShape.length !== 0 && attributes.outputShape.length !== inputs[0].dims.length - 2) {\n    throw new Error('invalid output shape');\n  }\n};\n\n// for transposing weight tensor from [C, M/group, KH, KW] to [KH, KW, M/group, C]\nconst weightTransposePerm = [2, 3, 1, 0];\n\nconst convTranspose2d =\n    (context: ComputeContext, inputs: readonly TensorView[], attributes: ConvTransposeAttributes): void => {\n      const adjustedAttributes = getAdjustedConvTransposeAttributes(attributes, inputs);\n      const isChannelsLast = attributes.format === 'NHWC';\n      const outputShape = adjustedAttributes.outputShape;\n      const outChannels = outputShape[isChannelsLast ? 3 : 1];\n      const inputChannels = inputs[0].dims[isChannelsLast ? 3 : 1];\n      // Switch to naive method when outChannels and inputChannels are very small. It's because that in this case it's\n      // not suitable for matmul version since matmul uses tile size 32x32 resulting the underlying execution unit\n      // utilization rate is very low.\n      if (adjustedAttributes.group !== 1 || (outChannels === 1 && inputChannels === 1)) {\n        context.compute(createConvTranspose2DProgramInfo(inputs, adjustedAttributes));\n        return;\n      }\n      const outHeight = outputShape[isChannelsLast ? 1 : 2];\n      const outWidth = outputShape[isChannelsLast ? 2 : 3];\n      const weightHeight = inputs[1].dims[2];\n      const weightWidth = inputs[1].dims[3];\n\n      const dimAOuter = isChannelsLast ? outHeight * outWidth : outChannels;\n      const dimBOuter = isChannelsLast ? outChannels : outHeight * outWidth;\n      const dimInner = weightHeight * weightWidth * inputChannels;\n\n      const sequentialAccessByThreads = /* backend.adapterInfo.isIntel() */ true;\n\n\n      // STEP.1: transpose weight\n      const transposedWeight = (context.kernelCustomData.wT as TensorView | undefined) ??\n          context.compute(\n              createTransposeProgramInfo(inputs[1], weightTransposePerm),\n              {inputs: [1], outputs: [attributes.wIsConst ? -2 : -1]})[0];\n      if (attributes.wIsConst && !context.kernelCustomData.wT) {\n        context.kernelCustomData.wT = transposedWeight;\n      }\n\n      // STEP.2: prepare reshaped inputs\n      const convTransposeInputs = [inputs[0], transposedWeight];\n      const hasBias = inputs.length === 3;\n      if (hasBias) {\n        if (!isChannelsLast && inputs[2].dims.length === 1) {\n          convTransposeInputs.push(inputs[2].reshape([inputs[2].dims[0], 1, 1]));\n        } else {\n          convTransposeInputs.push(inputs[2]);\n        }\n      }\n\n      // STEP.3: compute matmul\n      context.compute(\n          createConv2DTransposeMatMulProgramInfo(\n              convTransposeInputs, adjustedAttributes, outputShape, dimAOuter, dimBOuter, dimInner, hasBias,\n              sequentialAccessByThreads),\n          {inputs: convTransposeInputs});\n    };\n\nconst convTranspose1d = (context: ComputeContext, attributes: ConvTransposeAttributes): void => {\n  // extend the input to 2D by adding H dimension\n  const isChannelLast = attributes.format === 'NHWC';\n\n  const inputs = [\n    context.inputs[0].reshape(\n        isChannelLast ?\n            // [N, W, C] -> [N, H=1, W, C]\n            [context.inputs[0].dims[0], 1, context.inputs[0].dims[1], context.inputs[0].dims[2]] :\n            // [N, C, W] -> [N, C, H=1, W]\n            [context.inputs[0].dims[0], context.inputs[0].dims[1], 1, context.inputs[0].dims[2]]),\n    //[FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kW] -> [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kH=1, kW]\n    context.inputs[1].reshape([context.inputs[1].dims[0], context.inputs[1].dims[1], 1, context.inputs[1].dims[2]])\n  ];\n  if (context.inputs.length === 3) {\n    inputs.push(context.inputs[2]);\n  }\n  let kernelShape = attributes.kernelShape;\n  if (kernelShape.length === 0 || kernelShape[0] === 0) {\n    kernelShape = [context.inputs[1].dims[2]];\n  }\n  let dilations = attributes.dilations;\n  if (dilations.length === 0 || dilations[0] === 0) {\n    dilations = [1];\n  }\n  let strides = attributes.strides;\n  if (strides.length === 0 || strides[0] === 0) {\n    strides = [1];\n  }\n  let pads = attributes.pads;\n  if (pads.length === 0) {\n    pads = [0, 0];\n  }\n  pads = [0, pads[0], 0, pads[1]];\n  strides = [1].concat(strides);\n  dilations = [1].concat(dilations);\n  kernelShape = [1].concat(kernelShape);\n  const adjustedAttributes =\n      getAdjustedConvTransposeAttributes({...attributes, pads, strides, dilations, kernelShape}, inputs);\n  context.compute(createConvTranspose2DProgramInfo(\n      inputs, adjustedAttributes,\n      outputShape => isChannelLast ? [outputShape[0], outputShape[2], outputShape[3]] :\n                                     [outputShape[0], outputShape[1], outputShape[3]]));\n};\n\nexport const convTranspose = (context: ComputeContext, attributes: ConvTransposeAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  if (context.inputs[0].dims.length === 3) {\n    convTranspose1d(context, attributes);\n  } else {\n    convTranspose2d(context, context.inputs, attributes);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, inputVariable, outputVariable, ShaderHelper} from './common';\n\n\nexport interface CumSumAttributes extends AttributeWithCacheKey {\n  readonly exclusive: boolean;\n  readonly reverse: boolean;\n}\nconst createCumsumProgramInfo =\n    (inputType: number, inputShape: readonly number[], axisInput: TensorView, attributes: CumSumAttributes):\n        ProgramInfo => {\n          const outputSize = ShapeUtil.size(inputShape);  // outputShape is same as inputShape.\n          const rank = inputShape.length;                 // input/output rank\n          const input = inputVariable('input', inputType, rank);\n          const output = outputVariable('output', inputType, rank);\n          const axisValue = axisInput.dataType === DataType.int32 ? axisInput.getInt32Array()[0] :\n                                                                    Number(axisInput.getBigInt64Array()[0]);\n          const axis = ShapeUtil.normalizeAxis(axisValue, rank);\n          const getShaderSource = (shaderHelper: ShaderHelper) => {\n            const index = ` i32(${input.indicesGet('inputIndices', 'uniforms.axis')}) `;\n            const max = getElementAt('uniforms.input_shape', 'uniforms.axis', rank);\n            const lowerLimit = attributes.reverse ? index + (attributes.exclusive ? ' + 1' : '') : '0';\n            const upperLimit = attributes.reverse ? max : index + (attributes.exclusive ? '' : ' + 1');\n            return `\n                ${\n                shaderHelper.registerUniform('outputSize', 'u32')\n                    .registerUniform('axis', 'u32')\n                    .declareVariables(input, output)}\n                ${shaderHelper.mainStart()}\n                  ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n                  var inputIndices = ${output.offsetToIndices('global_idx')};\n                  var sum = ${output.type.value}(0);\n                  let first : i32 = ${lowerLimit};\n                  let last : i32 = ${upperLimit};\n                  for (var i : i32 = first; i < last; i++) {\n                    ${input.indicesSet('inputIndices', 'uniforms.axis', 'u32(i)')};\n                    sum = sum + ${input.getByIndices('inputIndices')};\n                  }\n                  ${output.setByOffset('global_idx', 'sum')};\n                }`;\n          };\n          return {\n            name: 'CumSum',\n            shaderCache: {hint: attributes.cacheKey, inputDependencies: ['rank']},\n            getRunData: () => ({\n              outputs: [{dims: inputShape, dataType: inputType}],\n              dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n              programUniforms: [\n                {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: axis},\n                ...createTensorShapeVariables(inputShape, inputShape)\n              ]\n\n            }),\n            getShaderSource\n          };\n        };\n\n\nexport const cumsum = (context: ComputeContext, attributes: CumSumAttributes): void => {\n  const inputShape = context.inputs[0].dims;\n  const inputType = context.inputs[0].dataType;\n  const axis = context.inputs[1];\n  context.compute(createCumsumProgramInfo(inputType, inputShape, axis, attributes), {inputs: [0]});\n};\n\nexport const parseCumSumAttributes = (attributes: Record<string, unknown>): CumSumAttributes => {\n  const exclusive = attributes.exclusive as number === 1;\n  const reverse = attributes.reverse as number === 1;\n  return createAttributeWithCacheKey({exclusive, reverse});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface FormatAttributes {\n  readonly format: 'NHWC'|'NCHW';\n}\n\nexport interface DepthToSpaceAttributes extends FormatAttributes, AttributeWithCacheKey {\n  readonly blocksize: number;\n  readonly mode: string;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('DepthToSpace requires 1 input.');\n  }\n  if (inputs[0].dims.length !== 4) {\n    throw new Error('DepthToSpace requires 4D input.');\n  }\n};\n\nconst permFunctionBody = (perm: number[], rank: number, input: IndicesHelper, output: IndicesHelper): string => {\n  const reverseFunc = [];\n  reverseFunc.push(`fn perm(i: ${output.type.indices}) -> ${input.type.indices} {\n    var a: ${input.type.indices};`);\n  for (let i = 0; i < rank; ++i) {\n    reverseFunc.push(input.indicesSet('a', perm[i], `i[${i}]`));\n  }\n  reverseFunc.push('return a;}');\n  return reverseFunc.join('\\n');\n};\n\nconst createDepthToSpaceProgramInfo = (inputTensor: TensorView, attributes: DepthToSpaceAttributes): ProgramInfo => {\n  let n: number, h: number, w: number, c: number;\n  let shape: number[];\n  let perm: number[];\n  const isChannelLast = attributes.format === 'NHWC';\n  const blocksize = attributes.blocksize;\n  const isDCRmode = attributes.mode === 'DCR';\n  if (isChannelLast) {\n    [n, h, w, c] = inputTensor.dims;\n    shape = isDCRmode ? [n, h, w, blocksize, blocksize, c / (blocksize ** 2)] :\n                        [n, h, w, c / (blocksize ** 2), blocksize, blocksize];\n    perm = isDCRmode ? [0, 1, 3, 2, 4, 5] : [0, 1, 4, 2, 5, 3];\n  } else {\n    [n, h, w, c] = [inputTensor.dims[0], inputTensor.dims[2], inputTensor.dims[3], inputTensor.dims[1]];\n    shape = isDCRmode ? [n, blocksize, blocksize, c / (blocksize ** 2), h, w] :\n                        [n, c / (blocksize ** 2), blocksize, blocksize, h, w];\n    perm = isDCRmode ? [0, 3, 4, 1, 5, 2] : [0, 1, 4, 2, 5, 3];\n  }\n  const reshapedInputTensor = inputTensor.reshape(shape);\n  const reshapedInputRank = reshapedInputTensor.dims.length;\n  const inputDataType = inputTensor.dataType;\n\n  const reshapedInput = inputVariable('a', inputDataType, reshapedInputRank);\n  const permedOutput = outputVariable('output', inputDataType, reshapedInputRank);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(reshapedInput, permedOutput)}\n\n  ${permFunctionBody(perm, reshapedInputRank, reshapedInput, permedOutput)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n    let indices = ${permedOutput.offsetToIndices('global_idx')};\n    let aIndices = perm(indices);\n\n    ${permedOutput.setByOffset('global_idx', reshapedInput.getByIndices('aIndices'))}\n  }`;\n\n  return {\n    name: 'DepthToSpace',\n    shaderCache: {hint: `${inputTensor.dims};${attributes.blocksize};${attributes.mode}`, inputDependencies: ['rank']},\n    getRunData: (inputs) => {\n      const outputShape = isChannelLast ? [n, h * blocksize, w * blocksize, c / (blocksize ** 2)] :\n                                          [n, c / (blocksize ** 2), h * blocksize, w * blocksize];\n      const outputSize = ShapeUtil.size(outputShape);\n      const shapeBeforePerm = reshapedInputTensor.dims;\n      const shapeAfterPerm = ShapeUtil.sortBasedOnPerm(shapeBeforePerm, perm);\n      return {\n        outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n        dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n        programUniforms:\n            [{type: DataType.uint32, data: outputSize}, ...createTensorShapeVariables(shapeBeforePerm, shapeAfterPerm)],\n      };\n    },\n    getShaderSource,\n  };\n};\n\nexport const depthToSpace = (context: ComputeContext, attributes: DepthToSpaceAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createDepthToSpaceProgramInfo(context.inputs[0], attributes));\n};\n\nexport const parseDepthToSpaceAttributes = (attributes: Record<string, unknown>): DepthToSpaceAttributes =>\n    createAttributeWithCacheKey({\n      blocksize: attributes.blocksize as number,\n      mode: attributes.mode as string,\n      format: attributes.format as 'NHWC' | 'NCHW'\n    });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface EinsumAttributes extends AttributeWithCacheKey {\n  readonly equation: string;\n}\n// The equation attribute value is a string which consists of left hand side (LHS) and optionally right hand side (RHS)\n// separated by '->'. Ex. \"ij,jk -> ik\" expresses matrix multiplication\n//     \"ij->ji\" expresses matrix transpose\n//      \"ii->i\" diagonal elements of a square matrix\n// LHS consists of a sequence of terms separated by commas. Each term corresponds to an input variable.\n// Each symbol corresponds to a dimension in the input variable. The symbol can be either a letter, 'a' to 'z' or 'A' to\n// 'Z' or '...' to represent arbitrary dimensions.\n\nconst symbolPattern =\n    '[a-zA-Z]|\\\\.\\\\.\\\\.';  // The pattern each symbol in each term in the symbolic equation should match\nconst termPattern = '(' + symbolPattern + ')+';   // The pattern each term in the symbolic equation should match\nconst termPatternOnly = '^' + termPattern + '$';  // The patterns only matchs a term begin to end.\nconst lhsPattern = '(' + termPattern + ',)*' + termPattern;  // The pattern the LHS should match\nconst lhsPatternOnly = '^' + lhsPattern + '$';               // The patterns only matchs a LHS begin to end.\n\ninterface SymbolInfo {\n  count: number;           // Symbol corresponding to a dimmension of an input\n  inputIndices: number[];  // Number of input variables the symbol corresponds to\n  dimValue: number;        // Number of dimensions the symbol corresponds to\n}\n\nclass EinsumTerm {\n  constructor(inputIndex = -1) {\n    this.symbolToIndices = new Map<string, number[]>();\n    this.inputIndex = inputIndex;\n  }\n\n  // Add a symbol to the term\n  addSymbol(symbol: string, index: number) {\n    let value = this.symbolToIndices.get(symbol);\n    if (value === undefined) {\n      value = [index];\n    } else {\n      value.push(index);\n    }\n    this.symbolToIndices.set(symbol, value);\n  }\n\n  symbolToIndices: Map<string, number[]>;  // Map from symbol to dimensions of the input corresponding to the term\n  inputIndex: number;                      // -1 for output and 0, 1, 2, ... for inputs\n}\n\nclass EinsumEquation {\n  constructor(inputs: readonly TensorView[], public readonly equation: string) {\n    this.hasEllipsis = false;\n    this.symbolToInfo = new Map<string, SymbolInfo>();\n    this.lhs = new Array<EinsumTerm>();\n    this.outputDims = [];\n    // As rhs needs to be updated allow using let instead of const for both lhs and rhs.\n    // eslint-disable-next-line prefer-const\n    let [lhs, rhs] = equation.includes('->') ? equation.split('->', 2) : [equation, ''];\n    if (!lhs.match(RegExp(lhsPatternOnly))) {\n      throw new Error('Invalid LHS term');\n    }\n    const inputTerms = lhs.split(',');\n    inputTerms.forEach((inputTerm, index) => {\n      const dims = inputs[index].dims.slice();\n      if (!inputTerm.match(RegExp(termPatternOnly))) {\n        throw new Error('Invalid LHS term');\n      }\n      const einsumTerm = this.processTerm(inputTerm, true, dims, index);\n      this.lhs.push(einsumTerm);\n    });\n\n    // Initialize the RHS if not specified\n    if (rhs === '') {\n      // Construct RHS from LHS terms/symbols\n      rhs += [...this.symbolToInfo.entries()]\n                 .filter(([sym, info]) => (info.count === 1 || sym === '...'))\n                 .map(([sym]) => sym)\n                 .join('');\n    } else {\n      if (!rhs.match(RegExp(termPattern))) {\n        throw new Error('Invalid RHS');\n      }\n    }\n\n    // Compute output dims\n    const rhsSymbols = rhs.match(RegExp(symbolPattern, 'g'));\n    rhsSymbols?.forEach((symbol) => {\n      if (symbol === '...') {\n        this.outputDims = this.outputDims.concat(this.ellipsisDims);\n      } else {\n        const info = this.symbolToInfo.get(symbol);\n        if (info === undefined) {\n          throw new Error('Invalid RHS symbol');\n        }\n        this.outputDims.push(info.dimValue);\n      }\n    });\n    this.rhs = this.processTerm(rhs, false, this.outputDims);\n  }  // End of EinsumEqation constructor\n\n  // Add a symbol to the equation\n  addSymbol(symbol: string, dimValue: number, inputIndex: number) {\n    let info = this.symbolToInfo.get(symbol);\n    if (info !== undefined) {\n      if (info.dimValue !== dimValue && info.count !== 1) {\n        throw new Error('Dimension mismatch');\n      } else {\n        info.count++;\n        info.inputIndices.push(inputIndex);\n      }\n    } else {\n      info = {count: 1, dimValue, inputIndices: [inputIndex]};\n    }\n    this.symbolToInfo.set(symbol, info);\n  }\n\n  // Process one input/output term\n  processTerm(term: string, isInput: boolean, dims: readonly number[], index = -1): EinsumTerm {\n    const rank = dims.length;\n    let ellipsis = false;\n    let ellipsisDims = [];\n    let nextDim = 0;\n    // For output empty string is allowed because the output may be reduced to a scalar value\n    if (!term.match(RegExp(termPatternOnly)) && (!isInput && term !== '')) {\n      throw new Error('Invalid LHS term');\n    }\n    const indexSymbols = term.match(RegExp(symbolPattern, 'g'));\n    const einsumTerm = new EinsumTerm(index);\n    // symbol can be either a lettre, 'a' to 'z' or 'A' to 'Z', or '...'\n    indexSymbols?.forEach((symbol: string, i: number) => {\n      if (symbol === '...') {\n        if (ellipsis) {\n          throw new Error('Only one ellipsis is allowed per input term');\n        }\n        ellipsis = true;\n        const ellipsisDimLength = rank - indexSymbols.length + 1;\n        if (ellipsisDimLength < 0) {\n          throw new Error('Ellipsis out of bounds');\n        }\n        ellipsisDims = dims.slice(nextDim, nextDim + ellipsisDimLength);\n        if (this.hasEllipsis) {\n          if (this.ellipsisDims.length !== ellipsisDims.length ||\n              this.ellipsisDims.toString() !== ellipsisDims.toString()) {\n            throw new Error('Ellipsis dimensions mismatch');\n          }\n        } else if (isInput) {\n          this.hasEllipsis = true;\n          this.ellipsisDims = ellipsisDims;\n        } else {\n          throw new Error('Ellipsis must be specified in the LHS');\n        }\n        // Add '0', '1', '2', '3', '4', etc to represent ellipsis dimensions to avoid special handling\n        for (let j = 0; j < ellipsisDims.length; j++) {\n          const symbol = String.fromCharCode('0'.charCodeAt(0) + j);\n          einsumTerm.addSymbol(symbol, i + j);\n          this.addSymbol(symbol, dims[nextDim++], index);\n        }\n      } else {\n        einsumTerm.addSymbol(symbol, i + (this.hasEllipsis ? this.ellipsisDims.length - 1 : 0));\n        this.addSymbol(symbol, dims[nextDim++], index);\n      }\n    });\n    return einsumTerm;\n  }\n\n  symbolToInfo: Map<string, SymbolInfo>;  // All symbols in the equation\n  hasEllipsis: boolean;                   // The equation has ellipsis or not\n  ellipsisDims: number[];                 // The dimensions of the equation ellipsis corresponds to.\n  lhs: EinsumTerm[];                      // Terms on the left-hand side of the equation\n  rhs: EinsumTerm;                        // Term on the right-hand side of the equation\n  outputDims: number[];                   // Output dimensions of the equation\n}  // End of class EinsumEquation\n\nconst appendMax = (name: string): string => name + '_max';\n\nconst createEinsumProgramInfo =\n    (inputShapes: Array<readonly number[]>, dataType: number, einsumEquation: EinsumEquation,\n     outputShape: readonly number[]): ProgramInfo => {\n      const ranks = inputShapes.map((dims) => dims.length);\n      const inputVars = ranks.map((rank, index) => inputVariable(`input${index}`, dataType, rank));\n      const outputSize = ShapeUtil.size(outputShape);\n      const output = outputVariable('output', dataType, outputShape.length);\n      const uniformsSymbols =\n          [...einsumEquation.symbolToInfo.keys()].filter((symbol) => !einsumEquation.rhs.symbolToIndices.has(symbol));\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const idxCopy: string[] = [];\n        const initProd = 'var prod = 1.0;';\n        const initSum = 'var sum = 0.0;';\n        const updateSum = 'sum += prod;';\n        const reduceOpsSetIndices: string[] = [];\n        const reduceOpsLoopHeaders: string[] = [];\n        const reduceOpsLoopFooters: string[] = [];\n        const reduceOpCompute: string[] = [];\n        const isReduceOpsWithoutLoop = einsumEquation.symbolToInfo.size === einsumEquation.rhs.symbolToIndices.size;\n        einsumEquation.symbolToInfo.forEach((info, symbol) => {\n          if (einsumEquation.rhs.symbolToIndices.has(symbol)) {\n            const outputIndex = einsumEquation.rhs.symbolToIndices.get(symbol)?.[0];\n            if (outputIndex !== undefined) {\n              einsumEquation.lhs.forEach((term, i) => {\n                if (info.inputIndices.includes(i)) {\n                  const indices = term.symbolToIndices.get(symbol);\n                  if (indices === undefined) {\n                    throw new Error('Invalid symbol error');\n                  }\n                  indices.forEach((index) => {\n                    idxCopy.push(`${\n                        inputVars[i].indicesSet(\n                            `input${i}Indices`, index, output.indicesGet('outputIndices', outputIndex))}`);\n                  });\n                }\n              });\n            }\n          } else {\n            einsumEquation.lhs.forEach((term, i) => {\n              if (info.inputIndices.includes(i)) {\n                const indices = term.symbolToIndices.get(symbol);\n                if (indices === undefined) {\n                  throw new Error('Invalid symbol error');\n                }\n                indices.forEach((index) => {\n                  reduceOpsSetIndices.push(`${inputVars[i].indicesSet(`input${i}Indices`, index, `${symbol}`)}`);\n                });\n                reduceOpCompute.push(`prod *= ${inputVars[i].getByIndices(`input${i}Indices`)};`);\n              }\n            });\n            reduceOpsLoopHeaders.push(\n                `for(var ${symbol}: u32 = 0; ${symbol} < uniforms.${appendMax(symbol)}; ${symbol}++) {`);\n            reduceOpsLoopFooters.push('}');\n          }\n        });\n        const reduceOps = isReduceOpsWithoutLoop ?\n            [\n              ...idxCopy,\n              `let sum = ${inputVars.map((inputVar, i) => inputVar.getByIndices(`input${i}Indices`)).join(' * ')};`\n            ] :\n            [\n              ...idxCopy,\n              initSum,\n              ...reduceOpsLoopHeaders,\n              ...reduceOpsSetIndices,\n              initProd,\n              ...reduceOpCompute,\n              updateSum,\n              ...reduceOpsLoopFooters,\n            ];\n        return `\n            ${\n            shaderHelper\n                .registerUniforms(uniformsSymbols.map((symbol) => ({name: `${appendMax(symbol)}`, type: 'u32'})))\n                .registerUniform('outputSize', 'u32')\n                .declareVariables(...inputVars, output)}\n\n            ${shaderHelper.mainStart()}\n            ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n            var outputIndices = ${output.offsetToIndices('global_idx')};\n            ${inputVars.map((_var, i) => `var input${i}Indices: ${inputVars[i].type.indices};`).join('\\n')}\n            ${reduceOps.join('\\n')};\n            ${output.setByOffset('global_idx', 'sum')};\n          }`;\n      };\n      return {\n        name: 'Einsum',\n        shaderCache: {hint: einsumEquation.equation, inputDependencies: inputShapes.map(() => 'rank')},\n        getRunData: () => {\n          // The symbols from uniformSymbols array are guaranteed to exist in einsumEquations.symbolToInfo map. The\n          // filter is added to make sure that dimValue is never 0.\n          const programUniformsInit: ProgramUniform[] =\n              uniformsSymbols.filter((symbol) => einsumEquation.symbolToInfo.has(symbol))\n                  .map(\n                      (symbol) =>\n                          ({type: DataType.uint32, data: einsumEquation.symbolToInfo.get(symbol)?.dimValue || 0}));\n          programUniformsInit.push({type: DataType.uint32, data: outputSize});\n          const programUniforms: ProgramUniform[] =\n              inputShapes.map((dims, _) => [...createTensorShapeVariables(dims)])\n                  .reduce((acc, inputProgramUniforms) => acc.concat(inputProgramUniforms), programUniformsInit);\n          programUniforms.push(...createTensorShapeVariables(outputShape));\n          return ({\n            outputs: [{dims: outputShape, dataType}],\n            dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n            programUniforms\n          });\n        },\n        getShaderSource,\n      };\n    };\n\nexport const einsum = (context: ComputeContext, attributes: EinsumAttributes): void => {\n  const einsumEquation = new EinsumEquation(context.inputs, attributes.equation);\n  const outputShape = einsumEquation.outputDims;\n  const inputShapes = context.inputs.map((input, _) => input.dims);\n  context.compute(createEinsumProgramInfo(inputShapes, context.inputs[0].dataType, einsumEquation, outputShape));\n};\n\nexport const parseEinsumAttributes = (attributes: Record<string, unknown>): EinsumAttributes => {\n  const equation = (attributes.equation as string).replace(/\\s+/g, '');\n  return createAttributeWithCacheKey({equation});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('Expand requires 2 input.');\n  }\n  const inputShape = inputs[0].dims;\n  const shape = Array.from(inputs[1].getBigInt64Array(), Number);\n\n  let shapeIndex = shape.length < inputShape.length ? 0 : shape.length - inputShape.length;\n  let inputShapeIndex = inputShape.length < shape.length ? 0 : inputShape.length - shape.length;\n  for (; shapeIndex < shape.length && inputShapeIndex < inputShape.length; ++shapeIndex, ++inputShapeIndex) {\n    if (shape[shapeIndex] !== inputShape[inputShapeIndex] && shape[shapeIndex] !== 1 &&\n        inputShape[inputShapeIndex] !== 1) {\n      throw new Error('Expand requires shape to be broadcastable to input');\n    }\n  }\n};\n\nconst getAdjustedShape = (shape1: readonly number[], shape2: readonly number[]): number[] => {\n  const diff = shape1.length - shape2.length;\n  const shape: number[] = [];\n  for (let i = 0; i < diff; ++i) {\n    shape.push(shape1[i]);\n  }\n  for (let i = 0; i < shape2.length; ++i) {\n    shape.push(shape2[i] === 1 ? shape1[i + diff] : shape2[i]);\n  }\n  return shape;\n};\n\nconst calculateOutputShape = (inputShape: readonly number[], shape: readonly number[]): number[] =>\n    (inputShape.length > shape.length) ? getAdjustedShape(inputShape, shape) : getAdjustedShape(shape, inputShape);\n\n\nconst createExpandProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const shape = Array.from(inputs[1].getBigInt64Array(), Number);\n  const outputShape: number[] = calculateOutputShape(inputShape, shape);\n  const dataType = inputs[0].dataType;\n  const components = dataType === DataType.bool ? 4 : 1;\n  const outputSize = Math.ceil(ShapeUtil.size(outputShape) / components);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const input = inputVariable('input', dataType, inputShape.length, components);\n    const output = outputVariable('output', dataType, outputShape.length, components);\n    let assignment: string;\n    if (dataType === DataType.bool) {\n      const singleAssignment = (resStr: string, x: number, typeCast = '') => `\n          let outputIndices${x} = ${output.offsetToIndices(`outputOffset + ${x}u`)};\n          let offset${x} = ${input.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n          let index${x} = offset${x} / 4u;\n          let component${x} = offset${x} % 4u;\n          ${resStr}[${x}] = ${typeCast}(${input.getByOffset(`index${x}`)}[component${x}]);\n        `;\n      assignment = `\n        let outputOffset = global_idx * ${components};\n        var data = vec4<u32>(0);\n        ${singleAssignment('data', 0, 'u32')}\n        ${singleAssignment('data', 1, 'u32')}\n        ${singleAssignment('data', 2, 'u32')}\n        ${singleAssignment('data', 3, 'u32')}\n        ${output.setByOffset('global_idx', 'data')}\n      }`;\n    } else {\n      assignment = `\n        let outputIndices = ${output.offsetToIndices('global_idx')};\n        let inputOffset = ${input.broadcastedIndicesToOffset('outputIndices', output)};\n        ${output.setByOffset('global_idx', input.getByOffset('inputOffset'))}\n      }`;\n    }\n    return `\n    ${shaderHelper.registerUniform('vec_size', 'u32').declareVariables(input, output)}\n    ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.vec_size')}\n    ${assignment}`;\n  };\n\n  const programUniforms: ProgramUniform[] =\n      [{type: DataType.uint32, data: outputSize}, ...createTensorShapeVariables(inputShape, outputShape)];\n  return {\n    name: 'Expand',\n    shaderCache: {hint: `${outputShape.length}`, inputDependencies: ['rank']},\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n      programUniforms\n    })\n  };\n};\n\nexport const expand = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  context.compute(createExpandProgramInfo(context.inputs), {inputs: [0]});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglValueType, UniformsArrayType, WORKGROUP_SIZE} from './common';\nimport * as unary from './unary-op';\n\n// GELU is defined as Y=0.5*X*(1+tanh(0.797885*X+0.035677*X*X*X)), where X may pre-add a bias.\n\nconst createFastGeluProgramInfo = (inputTensors: readonly TensorView[]): ProgramInfo => {\n  const dataType = inputTensors[0].dataType;\n  const outputSize = ShapeUtil.size(inputTensors[0].dims);\n  const biasLength = ShapeUtil.size(inputTensors[1].dims);\n  // can only use vec4 when bias length is multiple of 4\n  const useVec4 = biasLength % 4 === 0;\n  const getShaderSource = (shaderHelper: ShaderHelper): string => {\n    const x = inputVariable('x', dataType, [1], 4);\n    const bias = inputVariable('bias', dataType, [1], 4);\n    const y = outputVariable('y', dataType, [1], 4);\n\n    const uniforms: UniformsArrayType = [{name: 'output_vec_size', type: 'u32'}, {name: 'bias_size', type: 'u32'}];\n\n    const singleElementBias = (i: 0|1|2|3) => `\n      let bias${i}_offset: u32 = (global_idx * 4 + ${i}) % uniforms.bias_size;\n      let bias${i} = ${bias.getByOffset(`bias${i}_offset / 4`)}[bias${i}_offset % 4];`;\n    const biasGetExpression = useVec4 ?\n        `\n      let bias = ${bias.getByOffset('global_idx % (uniforms.bias_size / 4)')};` :\n        `${singleElementBias(0)}${singleElementBias(1)}${singleElementBias(2)}${singleElementBias(3)}\n      let bias = ${x.type.value}(bias0, bias1, bias2, bias3);`;\n\n    return `${shaderHelper.registerUniforms(uniforms).declareVariables(x, bias, y)}\n\n    ${unary.fastGeluImpl(tensorTypeToWsglValueType(dataType))}\n\n    ${shaderHelper.mainStart(WORKGROUP_SIZE)}\n      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_vec_size')}\n\n      let x = ${x.getByOffset('global_idx')};\n      ${biasGetExpression}\n      let x_in = x + bias;\n      ${y.setByOffset('global_idx', unary.fastGeluExpression('x_in'))}\n    }`;\n  };\n\n  return {\n    name: 'FastGeluWithBias',\n    shaderCache: {hint: `${useVec4}`, inputDependencies: ['type', 'type']},\n    getShaderSource,\n    getRunData: (inputs) => ({\n      outputs: [{dims: inputs[0].dims, dataType: inputs[0].dataType}],\n      programUniforms:\n          [{type: DataType.uint32, data: Math.ceil(outputSize / 4)}, {type: DataType.uint32, data: biasLength}],\n      dispatchGroup: {x: Math.ceil(outputSize / WORKGROUP_SIZE / 4)}\n    })\n  };\n};\n\nexport const fastGelu = (context: ComputeContext): void => {\n  if (context.inputs.length < 2 || ShapeUtil.size(context.inputs[1].dims) === 0) {\n    unary.fastGelu(context);\n  } else {\n    context.compute(createFastGeluProgramInfo(context.inputs));\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface GatherAttributes extends AttributeWithCacheKey {\n  axis: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('Gather requires 2 inputs.');\n  }\n};\n\nconst createGatherProgramInfo = (inputs: readonly TensorView[], attributes: GatherAttributes): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const indicesShape = inputs[1].dims;\n\n  const inputRank = inputShape.length;\n  const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank);\n\n  const outputShape = inputShape.slice(0);\n  outputShape.splice(axis, 1, ...indicesShape);\n\n  const axisDimLimit = inputShape[axis];\n  const components = inputs[0].dataType === DataType.bool ? 4 : 1;\n  const outputSize = Math.ceil(ShapeUtil.size(outputShape) / components);\n\n  const programUniforms: ProgramUniform[] = [\n    {type: DataType.uint32, data: outputSize}, {type: DataType.int32, data: axisDimLimit},\n    {type: DataType.uint32, data: axis}, ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims, outputShape)\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const data = inputVariable('data', inputs[0].dataType, inputs[0].dims.length, components);\n    const indices = inputVariable('inputIndices', inputs[1].dataType, inputs[1].dims.length);\n    const output = outputVariable('output', inputs[0].dataType, outputShape.length, components);\n\n    const calcDataIndices = (x: number|string): string => {\n      const indicesRank = indicesShape.length;\n      let calcStr = `var indicesIndices${x}  = ${indices.type.indices}(0);`;\n      for (let i = 0; i < indicesRank; i++) {\n        calcStr += `${indicesRank > 1 ? `indicesIndices${x}[${i}]` : `indicesIndices${x}`} = ${\n            outputShape.length > 1 ? `outputIndices${x}[uniforms.axis + ${i}]` : `outputIndices${x}`};`;\n      }\n      calcStr += `\n          var idx${x} = ${indices.getByIndices(`indicesIndices${x}`)};\n          if (idx${x} < 0) {\n            idx${x} = idx${x} + uniforms.axisDimLimit;\n          }\n          var dataIndices${x} : ${data.type.indices};\n        `;\n      for (let i = 0, j = 0; i < inputRank; i++) {\n        if (i === axis) {\n          calcStr += `${inputRank > 1 ? `dataIndices${x}[${i}]` : `dataIndices${x}`} = u32(idx${x});`;\n          j += indicesRank;\n        } else {\n          calcStr += `${inputRank > 1 ? `dataIndices${x}[${i}]` : `dataIndices${x}`} = ${\n              outputShape.length > 1 ? `outputIndices${x}[${j}]` : `outputIndices${x}`};`;\n          j++;\n        }\n      }\n      return calcStr;\n    };\n    let assignment: string;\n    if (inputs[0].dataType === DataType.bool) {\n      const singleAssignment = (resStr: string, x: number, typeCast = '') => `\n          let outputIndices${x} = ${output.offsetToIndices(`outputOffset + ${x}u`)};\n          ${calcDataIndices(x)};\n          let offset${x} = ${data.indicesToOffset(`dataIndices${x}`)};\n          let index${x} = offset${x} / 4u;\n          let component${x} = offset${x} % 4u;\n          ${resStr}[${x}] = ${typeCast}(${data.getByOffset(`index${x}`)}[component${x}]);\n        `;\n      assignment = `\n        let outputOffset = global_idx * ${components};\n        var value = vec4<u32>(0);\n        ${singleAssignment('value', 0, 'u32')}\n        ${singleAssignment('value', 1, 'u32')}\n        ${singleAssignment('value', 2, 'u32')}\n        ${singleAssignment('value', 3, 'u32')}\n        ${output.setByOffset('global_idx', 'value')}\n      `;\n    } else {\n      assignment = `\n      let outputIndices = ${output.offsetToIndices('global_idx')};\n      ${calcDataIndices('')};\n      let value = ${data.getByIndices('dataIndices')};\n      ${output.setByOffset('global_idx', 'value')};\n      `;\n    }\n    return `\n      ${\n        shaderHelper.registerUniform('outputSize', 'u32')\n            .registerUniform('axisDimLimit', 'i32')\n            .registerUniform('axis', 'u32')\n            .declareVariables(data, indices, output)}\n      ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n        ${assignment}\n      }`;\n  };\n  return {\n    name: 'Gather',\n    shaderCache: {hint: attributes.cacheKey, inputDependencies: ['rank', 'rank']},\n    getRunData: () => ({\n      outputs: [\n        {dims: outputShape, dataType: inputs[0].dataType},\n      ],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n      programUniforms\n    }),\n    getShaderSource,\n  };\n};\n\nexport const parseGatherAttributes = (attributes: Record<string, unknown>): GatherAttributes =>\n    createAttributeWithCacheKey({axis: attributes.axis as number});\n\nexport const gather = (context: ComputeContext, attributes: GatherAttributes): void => {\n  const inputs = context.inputs;\n  validateInputs(inputs);\n  context.compute(createGatherProgramInfo(context.inputs, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface GatherElementsAttributes extends AttributeWithCacheKey {\n  axis: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('GatherElements requires 2 inputs.');\n  }\n\n  if (inputs[0].dims.length < 1) {\n    throw new Error('GatherElements requires that the data input be rank >= 1.');\n  }\n\n  if (inputs[0].dims.length !== inputs[1].dims.length) {\n    throw new Error(`GatherElements requires that the data input and\n                     indices input tensors be of same rank.`);\n  }\n};\n\nconst createGatherElementsProgramInfo =\n    (inputs: readonly TensorView[], attributes: GatherElementsAttributes): ProgramInfo => {\n      const inputShape = inputs[0].dims;\n      const inputOutputDataType = inputs[0].dataType;\n      const inputRank = inputShape.length;\n\n      const indicesShape = inputs[1].dims;\n      const indicesDataType = inputs[1].dataType;\n      const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank);\n      const axisDimLimit = inputShape[axis];\n\n      const outputShape = indicesShape.slice(0);\n      const outputSize = ShapeUtil.size(outputShape);\n\n      const input = inputVariable('input', inputOutputDataType, inputRank);\n      const indices = inputVariable('indicesInput', indicesDataType, indicesShape.length);\n      const output = outputVariable('output', inputOutputDataType, outputShape.length);\n\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize}, {type: DataType.int32, data: axisDimLimit},\n        {type: DataType.uint32, data: axis}\n      ];\n      programUniforms.push(...createTensorShapeVariables(inputShape, indicesShape, outputShape));\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n\n      // int64 indices would be treated as little endian i32 with assumption they fall in i32 limits\n      // That assumption is safe as it's not possible to allocate >2gb buffer for input tensor\n      // Input data will be treated as u32 or two u32 for 8-byte tensors\n      const getShaderSource = (shaderHelper: ShaderHelper) => `\n      ${\n          shaderHelper.registerUniform('outputSize', 'u32')\n              .registerUniform('axisDimLimit', 'i32')\n              .registerUniform('axis', 'u32')\n              .declareVariables(input, indices, output)}\n      ${shaderHelper.mainStart()}\n      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n\n      let outputIndices = ${output.offsetToIndices('global_idx')};\n\n      var idx = ${indices.getByOffset('global_idx')};\n      if (idx < 0) {\n        idx = idx + uniforms.axisDimLimit;\n      }\n      var inputIndices = ${input.type.indices}(outputIndices);\n      ${input.indicesSet('inputIndices', 'uniforms.axis', 'u32(idx)')};\n      let value = ${input.getByIndices('inputIndices')};\n\n      ${output.setByOffset('global_idx', 'value')};\n  }`;\n\n      return {\n        name: 'GatherElements',\n        shaderCache: {inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n\nexport const parseGatherElementsAttributes = (attributes: Record<string, unknown>): GatherElementsAttributes =>\n    createAttributeWithCacheKey({axis: attributes.axis as number});\n\nexport const gatherElements = (context: ComputeContext, attributes: GatherElementsAttributes): void => {\n  const inputs = context.inputs;\n  validateInputs(inputs);\n  context.compute(createGatherElementsProgramInfo(context.inputs, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {GemmUtil, ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper, UniformsArrayType} from './common';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs) {\n    throw new Error('Input is missing');\n  }\n  if (inputs.length < 2 || inputs.length > 3) {\n    throw new Error('Invaid input number.');\n  }\n\n  // 'C' can be of dimensionality 0, 1 or 2 only\n  if (inputs.length === 3 && inputs[2].dims.length > 2) {\n    throw new Error('Invalid input shape of C');\n  }\n\n  if ((inputs[0].dataType !== inputs[1].dataType) ||\n      (inputs.length === 3 && inputs[0].dataType !== inputs[2].dataType)) {\n    throw new Error('Input types are mismatched');\n  }\n};\n\nexport interface GemmAttributes extends AttributeWithCacheKey {\n  transA: boolean;\n  transB: boolean;\n  alpha: number;\n  beta: number;\n}\n\nconst createGemmProgramInfo = (inputs: readonly TensorView[], attributes: GemmAttributes): ProgramInfo => {\n  const aShape = inputs[0].dims.slice();\n  const bShape = inputs[1].dims.slice();\n  const [M, N, K] = GemmUtil.getShapeOfGemmResult(\n      aShape, attributes.transA, bShape, attributes.transB, inputs.length === 3 ? inputs[2].dims : undefined);\n  const outputShape = [M, N];\n  if (!outputShape) {\n    throw new Error('Can\\'t use gemm on the given tensors');\n  }\n  const outputSize = ShapeUtil.size(outputShape);\n  const programUniforms: ProgramUniform[] = [\n    {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: M}, {type: DataType.uint32, data: N},\n    {type: DataType.uint32, data: K}, {type: DataType.float, data: attributes.alpha},\n    {type: DataType.float, data: attributes.beta}\n  ];\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n  if (inputs.length === 3) {\n    programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n    inputDependencies.push('rank');\n  }\n  programUniforms.push(...createTensorShapeVariables(outputShape));\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    let line = '';\n    if (attributes.transA && attributes.transB) {\n      line = 'value += a[k * uniforms.M + m] * b[n * uniforms.K + k];';\n    } else if (attributes.transA && !attributes.transB) {\n      line = 'value += a[k * uniforms.M + m] * b[k * uniforms.N + n];';\n    } else if (!attributes.transA && attributes.transB) {\n      line = 'value += a[m * uniforms.K + k] * b[n * uniforms.K + k];';\n    } else if (!attributes.transA && !attributes.transB) {\n      line = 'value += a[m * uniforms.K + k] * b[k * uniforms.N + n];';\n    }\n\n    const calculateAlpha = attributes.alpha === 1 ? '' : 'value *= uniforms.alpha;';\n    const a = inputVariable('a', inputs[0].dataType, inputs[0].dims);\n    const b = inputVariable('b', inputs[1].dataType, inputs[1].dims);\n    const dataType = a.type.value;\n    let c: IndicesHelper|null = null;\n    const variables = [a, b];\n    if (inputs.length === 3) {\n      c = inputVariable('c', inputs[2].dataType, inputs[2].dims.length);\n      variables.push(c);\n    }\n    const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n    variables.push(output);\n    const uniforms: UniformsArrayType = [\n      {name: 'output_size', type: 'u32'}, {name: 'M', type: 'u32'}, {name: 'N', type: 'u32'}, {name: 'K', type: 'u32'},\n      {name: 'alpha', type: 'f32'}, {name: 'beta', type: 'f32'}\n    ];\n    return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n    let m = global_idx / uniforms.N;\n    let n = global_idx % uniforms.N;\n\n    var value = ${dataType}(0);\n    for (var k: u32 = 0u; k < uniforms.K; k++) {\n      ${line}\n    }\n\n    ${calculateAlpha}\n    ${(() => {\n      if (c != null) {\n        return `let cOffset = ${c.broadcastedIndicesToOffset('vec2(m, n)', output)}; value += ${\n            dataType}(uniforms.beta) * ${c.getByOffset('cOffset')};`;\n      }\n      return '';\n    })()}\n    output[global_idx] = value;\n  }`;\n  };\n\n  return {\n    name: 'Gemm',\n    shaderCache: {hint: `${attributes.cacheKey}`, inputDependencies},\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n      programUniforms\n    }),\n    getShaderSource,\n  };\n};\n\nexport const parseGemmAttributes = (attributes: Record<string, unknown>): GemmAttributes => {\n  const transA = attributes.transA as boolean;\n  const transB = attributes.transB as boolean;\n  const alpha = attributes.alpha as number;\n  const beta = attributes.beta as number;\n  return {transA, transB, alpha, beta, cacheKey: `${attributes.transA};${attributes.transB};${attributes.alpha === 1}`};\n};\n\nexport const gemm = (context: ComputeContext, attributes: GemmAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createGemmProgramInfo(context.inputs, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, fillVector, getMaxComponents, inputVariable, outputVariable, ShaderHelper, sumVector, tensorTypeToWsglStorageType, UniformsArrayType} from './common';\n\nexport interface InstanceNormAttributes {\n  epsilon: number;\n  format: 'NHWC'|'NCHW';\n}\n\nconst createInstanceNormProgramInfo =\n    (inputs: readonly TensorView[], attributes: InstanceNormAttributes): ProgramInfo => {\n      const xShape = inputs[0].dims;\n      const outputShape = xShape;\n      const axis = 2;\n      const normCount = ShapeUtil.sizeToDimension(xShape, axis);\n      const normSize = ShapeUtil.sizeFromDimension(xShape, axis);\n      const components = getMaxComponents(normSize);\n      const normPackedSize = normSize / components;\n      const inputShape = [xShape[0], xShape[1], normPackedSize];\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'type', 'type'];\n      const programUniforms: ProgramUniform[] =\n          [{type: DataType.uint32, data: normSize}, {type: DataType.uint32, data: normPackedSize}];\n      programUniforms.push(...createTensorShapeVariables(inputShape, inputShape));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const x = inputVariable('x', inputs[0].dataType, inputShape.length, components);\n        const scale = inputVariable('scale', inputs[1].dataType, inputs[1].dims);\n        const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims);\n        const output = outputVariable('output', inputs[0].dataType, inputShape.length, components);\n        const variables = [x, scale, bias, output];\n        const dataType = x.type.value;\n        const f32Type = components === 1 ? 'f32' : `vec${components}<f32>`;\n        const workgroupSize = 64;\n\n        const uniforms: UniformsArrayType = [{name: 'normSize', type: 'u32'}, {name: 'normPackedSize', type: 'u32'}];\n        return `\n  var<workgroup> meanShared : f32;\n  var<workgroup> squaredNormShared : f32;\n  var<workgroup> workgroupShared : array<${f32Type}, ${workgroupSize}>;\n  const workgroupSize = ${workgroupSize}u;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n  ${shaderHelper.mainStart(workgroupSize)}\n    let norm = global_idx / workgroupSize;\n    let batch = norm / uniforms.x_shape[1];\n    let channel = norm % uniforms.x_shape[1];\n    let localIndex = local_id.x;\n\n    // initialize workgroup memory\n    var initial = ${f32Type}(0);\n    for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) {\n      initial = initial + ${f32Type}(${x.get('batch', 'channel', 'h')});\n    }\n    workgroupShared[localIndex] = initial;\n    workgroupBarrier();\n\n    // Calculate the mean of current channel data.\n    for (var currSize = workgroupSize >> 1;  currSize > 0; currSize = currSize >> 1) {\n      if (localIndex < currSize) {\n        workgroupShared[localIndex] = workgroupShared[localIndex] + workgroupShared[localIndex + currSize];\n      }\n      workgroupBarrier();\n    }\n    if (localIndex == 0) {\n      meanShared = ${sumVector('workgroupShared[0]', components)} / f32(uniforms.normSize);\n    }\n    workgroupBarrier();\n\n    // reinitialize workgroup memory.\n    initial = ${f32Type}(0);\n    for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) {\n      let deviation =  ${f32Type}(${x.get('batch', 'channel', 'h')}) - ${f32Type}(meanShared);\n      initial = initial + deviation * deviation;\n    }\n    workgroupShared[localIndex] = initial;\n    workgroupBarrier();\n\n    // Calculate the sum of square of deviation of current channel data.\n    for (var currSize = workgroupSize >> 1;  currSize > 0; currSize = currSize >> 1) {\n      if (localIndex < currSize) {\n        workgroupShared[localIndex] = workgroupShared[localIndex] + workgroupShared[localIndex + currSize];\n      }\n      workgroupBarrier();\n    }\n    if (localIndex == 0) {\n      squaredNormShared = ${sumVector('workgroupShared[0]', components)};\n    }\n    workgroupBarrier();\n\n    let invStdDev = inverseSqrt(squaredNormShared / f32(uniforms.normSize) + f32(${attributes.epsilon}));\n    let channelScale = invStdDev * f32(${scale.getByOffset('channel')});\n    let channelShift = f32(${bias.getByOffset('channel')}) - meanShared * channelScale;\n    for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) {\n      let value = ${x.get('batch', 'channel', 'h')} * ${dataType}(${f32Type}(channelScale)) + ${dataType}(${\n            f32Type}(channelShift));\n      ${output.set('batch', 'channel', 'h', 'value')};\n    }\n  }`;\n      };\n      return {\n        ...{name: 'InstanceNormalization'},\n        // TODO: use epsilon as uniform. Currently epsilon as uniform fails test_instancenorm_epsilon.\n        shaderCache: {hint: `${attributes.epsilon};${components}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [\n            {dims: outputShape, dataType: inputs[0].dataType},\n          ],\n          dispatchGroup: {x: normCount},\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n\nconst computeMean =\n    (context: ComputeContext, input: TensorView, scale: TensorView, bias: TensorView, n: number, h: number, c: number,\n     epsilon: number) => {\n      const components = getMaxComponents(c);\n      const WG = 64;\n      // we will store channel scale and channel shift in [2, components] matrix\n      // or in vec2 when components == 1\n      const outputType = components === 1 ? 'vec2f' : `mat2x${components}f`;\n      const sumCastType = components === 1 ? 'f32' : `vec${components}f`;\n      const setOutputValue = (var1: string, var2: string) => `${outputType}(${var1}, ${var2})`;\n      const unitsOfWork = n * c / components;\n      const wgSize = Math.ceil(h / WG);\n\n      const meanInputDependencies: ProgramInputTensorInfoDependency[] = ['type'];\n      const meanProgramUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: wgSize}, {type: DataType.uint32, data: h},\n        {type: DataType.uint32, data: Math.floor(c / components)},\n        {type: DataType.uint32, data: Math.floor(h * c / components)}\n      ];\n\n      const getMeanShaderSource = (shaderHelper: ShaderHelper) => {\n        const inputHelper = inputVariable('input', input.dataType, input.dims, components);\n        return `\n  ${shaderHelper.declareVariables(inputHelper)}\n  @group(0) @binding(1) var<storage, read_write> output : array<${outputType}>;\n  struct Uniforms {wg_size:u32, H:u32, C:u32, image_size:u32};\n  @group(0) @binding(2) var<uniform> uniforms: Uniforms;\n\n  ${shaderHelper.mainStart(WG)}\n    let currentImageNumber = global_idx / ${WG} / uniforms.C;\n    let currentChannelNumber = (global_idx / ${WG}) % uniforms.C;\n    let wgOffset = local_id.x * uniforms.wg_size;\n    if (wgOffset >= uniforms.H) {\n        return;\n    }\n    let wgMax = min(wgOffset + uniforms.wg_size, uniforms.H);\n\n    let offset = currentImageNumber * uniforms.image_size + currentChannelNumber;\n    var sum = ${fillVector('f32', components)};\n    var squaredSum = ${fillVector('f32', components)};\n    for (var i: u32 = wgOffset; i < wgMax; i++) {\n        let value = ${sumCastType}(input[offset + i * uniforms.C]);\n        sum += value;\n        squaredSum += value * value;\n    }\n    output[global_idx] = ${setOutputValue('sum', 'squaredSum')};\n  }`;\n      };\n\n      const meanValues = context.compute(\n          {\n            name: 'InstanceNormComputeMean',\n            shaderCache: {hint: `${components}`, inputDependencies: meanInputDependencies},\n            getRunData: () => ({\n              outputs: [\n                {dims: [n, c, WG, 2], dataType: DataType.float},\n              ],\n              dispatchGroup: {x: n * c / components},\n              programUniforms: meanProgramUniforms\n            }),\n            getShaderSource: getMeanShaderSource,\n          },\n          {inputs: [input], outputs: [-1]})[0];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: unitsOfWork}, {type: DataType.uint32, data: h},\n        {type: DataType.uint32, data: Math.floor(c / components)},\n        {type: DataType.uint32, data: Math.floor(WG * c / components)}\n      ];\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type', 'type'];\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const scaleHelper = inputVariable('scale', scale.dataType, scale.dims, components);\n        const biasHelper = inputVariable('bias', bias.dataType, bias.dims, components);\n        return `\n  @group(0) @binding(0) var<storage, read> input : array<${outputType}>;\n  @group(0) @binding(1) var<storage, read> scale : array<${scaleHelper.type.storage}>;\n  @group(0) @binding(2) var<storage, read> bias : array<${biasHelper.type.storage}>;\n  @group(0) @binding(3) var<storage, read_write> output : array<${outputType}>;\n  struct Uniforms {units_of_work : u32, H: u32, C : u32, image_size : u32};\n  @group(0) @binding(4) var<uniform> uniforms: Uniforms;\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.units_of_work')}\n    let currentImageNumber = global_idx / uniforms.C;\n    let currentChannelNumber = global_idx % uniforms.C;\n\n    let offset = currentImageNumber * uniforms.image_size;\n    var sum = ${fillVector('f32', components)};\n    var squaredSum = ${fillVector('f32', components)};\n    for (var i: u32 = 0; i < min(${WG}, uniforms.H); i++) {\n        let value = input[offset + i + currentChannelNumber * ${WG}];\n        sum += value[0];\n        squaredSum += value[1];\n    }\n    sum = sum / f32(uniforms.H);\n    squaredSum = squaredSum / f32(uniforms.H);\n    let invStdDev = inverseSqrt(squaredSum - sum * sum + f32(${epsilon}));\n    let channelScale = invStdDev * ${sumCastType}(scale[currentChannelNumber]);\n    let channelShift = ${sumCastType}(bias[currentChannelNumber]) - sum * channelScale;\n\n    output[global_idx] = ${setOutputValue('channelScale', 'channelShift')};\n  }`;\n      };\n      return context.compute(\n          {\n            name: 'InstanceNormComputeChannelScaleShift',\n            // TODO: use epsilon as uniform. Currently epsilon as uniform fails test_instancenorm_epsilon.\n            shaderCache: {hint: `${components};${epsilon}`, inputDependencies},\n            getRunData: () => ({\n              outputs: [\n                {dims: [n, c, 2], dataType: DataType.float},\n              ],\n              dispatchGroup: {x: Math.ceil(unitsOfWork / 64 /* workgroup size */)},\n              programUniforms\n            }),\n            getShaderSource,\n          },\n          {inputs: [meanValues, scale, bias], outputs: [-1]})[0];\n    };\n\nconst createInstanceNormNHWCProgramInfo =\n    (context: ComputeContext, inputs: readonly TensorView[], attributes: InstanceNormAttributes) => {\n      const xShape = inputs[0].dims;\n      const outputShape = xShape;\n      const N = xShape[0];\n      const C = xShape[xShape.length - 1];\n      const H = ShapeUtil.sizeFromDimension(xShape, 1) / C;\n      const components = getMaxComponents(C);\n      const outputSize = ShapeUtil.size(outputShape) / components;\n      const programUniforms: ProgramUniform[] =\n          [{type: DataType.uint32, data: H}, {type: DataType.uint32, data: Math.floor(C / components)}];\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n      // first compute mean\n      const channelScaleShift = computeMean(context, inputs[0], inputs[1], inputs[2], N, H, C, attributes.epsilon);\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n        const scaleType = components === 1 ? 'vec2f' : `mat2x${components}f`;\n        const scaleCastType = components === 1 ? dataType : `vec${components}<${dataType}>`;\n\n        const inputHelper = inputVariable('input', inputs[0].dataType, inputs[0].dims, components);\n        const outputHelper = outputVariable('output', inputs[0].dataType, outputShape, components);\n\n        return `\n  @group(0) @binding(0) var<storage, read> input : array<${inputHelper.type.storage}>;\n  @group(0) @binding(1) var<storage, read> scaleInput : array<${scaleType}>;\n  @group(0) @binding(2) var<storage, read_write> output : array<${outputHelper.type.storage}>;\n  struct Uniforms {H: u32, C : u32};\n  @group(0) @binding(3) var<uniform> uniforms: Uniforms;\n\n  ${shaderHelper.mainStart()}\n    let currentImageNumber = global_idx / (uniforms.C * uniforms.H);\n    let currentChannelNumber = global_idx % uniforms.C;\n\n    let scaleOffset = currentImageNumber * uniforms.C + currentChannelNumber;\n    let scale = scaleInput[scaleOffset];\n    output[global_idx] = fma(input[global_idx], ${scaleCastType}(scale[0]), ${scaleCastType}(scale[1]));\n  }`;\n      };\n      context.compute(\n          {\n            name: 'InstanceNormalizationNHWC',\n            shaderCache: {hint: `${components}`, inputDependencies},\n            getRunData: () => ({\n              outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n              dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n              programUniforms\n            }),\n            getShaderSource,\n          },\n          {inputs: [inputs[0], channelScaleShift]});\n    };\n\nexport const instanceNorm = (context: ComputeContext, attributes: InstanceNormAttributes): void => {\n  if (attributes.format === 'NHWC') {\n    createInstanceNormNHWCProgramInfo(context, context.inputs, attributes);\n  } else {\n    context.compute(createInstanceNormProgramInfo(context.inputs, attributes));\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {castToF32, fillVector, getMaxComponents, inputVariable, outputVariable, ShaderHelper, sumVector, tensorTypeToWsglStorageType, UniformsArrayType,} from './common';\n\ninterface LayerNormAttributes {\n  simplified: boolean;\n  axis: number;\n  epsilon: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length < 2) {\n    throw new Error('layerNorm requires at least 2 inputs.');\n  }\n};\n\nconst createLayerNormProgramInfo =\n    (inputs: readonly TensorView[], attributes: LayerNormAttributes, outputCount: number): ProgramInfo => {\n      const simplified = attributes.simplified;\n\n      const xShape = inputs[0].dims;\n      const scale = inputs[1];\n      const bias = !simplified && inputs[2];\n\n      const outputShape = xShape;\n      const axis = ShapeUtil.normalizeAxis(attributes.axis, xShape.length);\n      const normCount = ShapeUtil.sizeToDimension(xShape, axis);\n      const normSize = ShapeUtil.sizeFromDimension(xShape, axis);\n\n      const scaleSize = ShapeUtil.size(scale.dims);\n      const biasSize = bias ? ShapeUtil.size(bias.dims) : 0;\n      if (scaleSize !== normSize || (bias && biasSize !== normSize)) {\n        throw new Error(`Size of X.shape()[axis:] == ${normSize}.\n       Size of scale and bias (if provided) must match this.\n       Got scale size of ${scaleSize} and bias size of ${biasSize}`);\n      }\n\n      const meanInvStdDevDim: number[] = [];\n      for (let i = 0; i < xShape.length; ++i) {\n        if (i < axis) {\n          meanInvStdDevDim.push(xShape[i]);\n        } else {\n          meanInvStdDevDim.push(1);\n        }\n      }\n      const components = getMaxComponents(normSize);\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: normCount}, {type: DataType.float, data: normSize},\n        {type: DataType.uint32, data: Math.floor(normSize / components)},\n        {type: DataType.float, data: attributes.epsilon}\n      ];\n      if (bias) {\n        inputDependencies.push('type');\n      }\n      const hasMeanDataOutput = outputCount > 1;\n      const hasInvStdOutput = outputCount > 2;\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n        const variables = [\n          inputVariable('x', inputs[0].dataType, inputs[0].dims, components),\n          inputVariable('scale', scale.dataType, scale.dims, components),\n        ];\n        if (bias) {\n          variables.push(inputVariable('bias', bias.dataType, bias.dims, components));\n        }\n        variables.push(outputVariable('output', inputs[0].dataType, outputShape, components));\n        if (hasMeanDataOutput) {\n          variables.push(outputVariable('mean_data_output', DataType.float, meanInvStdDevDim));\n        }\n        if (hasInvStdOutput) {\n          variables.push(outputVariable('inv_std_output', DataType.float, meanInvStdDevDim));\n        }\n\n        const uniforms: UniformsArrayType = [\n          {name: 'norm_count', type: 'u32'}, {name: 'norm_size', type: 'f32'},\n          {name: 'norm_size_vectorized', type: 'u32'}, {name: 'epsilon', type: 'f32'}\n        ];\n        return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.norm_count')}\n    let offset = global_idx * uniforms.norm_size_vectorized;\n    var mean_vector = ${fillVector('f32', components)};\n    var mean_square_vector = ${fillVector('f32', components)};\n\n    for (var h: u32 = 0u; h < uniforms.norm_size_vectorized; h++) {\n      let value = ${castToF32(dataType, components, 'x[h + offset]')};\n      mean_vector += value;\n      mean_square_vector += value * value;\n    }\n    let mean = ${sumVector('mean_vector', components)} / uniforms.norm_size;\n    let inv_std_dev = inverseSqrt(${sumVector('mean_square_vector', components)} / uniforms.norm_size ${\n            simplified ? '' : '- mean * mean'} + uniforms.epsilon);\n\n    for (var j: u32 = 0; j < uniforms.norm_size_vectorized; j++) {\n      let f32input = ${castToF32(dataType, components, 'x[j + offset]')};\n      let f32scale = ${castToF32(dataType, components, 'scale[j]')};\n      output[j + offset] = ${variables[0].type.value}((f32input ${simplified ? '' : '- mean'}) * inv_std_dev * f32scale\n        ${bias ? `+ ${castToF32(dataType, components, 'bias[j]')}` : ''}\n      );\n    }\n\n    ${hasMeanDataOutput ? 'mean_data_output[global_idx] = mean' : ''};\n    ${hasInvStdOutput ? 'inv_std_output[global_idx] = inv_std_dev' : ''};\n  }`;\n      };\n      const outputs = [{dims: outputShape, dataType: inputs[0].dataType}];\n      if (hasMeanDataOutput) {\n        outputs.push({dims: meanInvStdDevDim, dataType: DataType.float});\n      }\n      if (hasInvStdOutput) {\n        outputs.push({dims: meanInvStdDevDim, dataType: DataType.float});\n      }\n\n      return {\n        name: 'LayerNormalization',\n        shaderCache: {hint: `${components};${outputCount};${simplified}`, inputDependencies},\n        getRunData: () =>\n            ({outputs, dispatchGroup: {x: Math.ceil(normCount / 64 /* workgroup size */)}, programUniforms}),\n        getShaderSource,\n      };\n    };\n\nexport const layerNorm = (context: ComputeContext, attributes: LayerNormAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createLayerNormProgramInfo(context.inputs, attributes, context.outputCount));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType, getTensorElementSize} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, getMaxComponents, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from './common';\n\n//  TODO support quantization bits not equal to 4\nexport interface MatMulNBitsAttributes extends AttributeWithCacheKey {\n  k: number;\n  n: number;\n  accuracyLevel: number;\n  bits: number;\n  blockSize: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: MatMulNBitsAttributes): void => {\n  if (inputs.length < 3 || inputs.length > 4) {\n    throw new Error('MatMulNBits requires 3 or 4 inputs');\n  }\n  const a = inputs[0];\n  const aRank = a.dims.length;\n  if (a.dims[aRank - 1] !== attributes.k) {\n    throw new Error('The last dim of input shape does not match the k value');\n  }\n  const nBlocksPerCol = Math.floor((attributes.k + attributes.blockSize - 1) / attributes.blockSize);\n  const blobSize = attributes.blockSize / 8 * attributes.bits;\n  const b = inputs[1];\n  if (!ShapeUtil.areEqual(b.dims, [attributes.n, nBlocksPerCol, blobSize])) {\n    throw new Error('The second inputs must be 3D tensor with shape N X nBlocksPerCol X blobSize');\n  }\n  const scales = inputs[2];\n  const scalesShape = scales.dims;\n  if (ShapeUtil.size(scalesShape) !== attributes.n * nBlocksPerCol) {\n    throw new Error('scales input size error.');\n  }\n  if (inputs.length === 4) {\n    const zeroPoints = inputs[3];\n    const zeroPointsShape = zeroPoints.dims;\n    const expectedZeroPointsSize =\n        attributes.bits > 4 ? (attributes.n * nBlocksPerCol) : attributes.n * Math.floor((nBlocksPerCol + 1) / 2);\n    if (ShapeUtil.size(zeroPointsShape) !== expectedZeroPointsSize) {\n      throw new Error('zeroPoints input size error.');\n    }\n  }\n};\n\nexport const createMatMulNBitsProgramInfo =\n    (inputs: readonly TensorView[], attributes: MatMulNBitsAttributes,\n     maxComputeWorkgroupSizes: [number, number, number], maxComputeWorkgroupStorageSize: number): ProgramInfo => {\n      const inputShape = inputs[0].dims;\n      const aRank = inputShape.length;\n      const nBlocksPerCol = Math.floor((attributes.k + attributes.blockSize - 1) / attributes.blockSize);\n      const dimAOuter = inputShape[aRank - 2];\n      const dimInner = attributes.k;\n      const dimBOuter = attributes.n;\n      const batchDims = inputShape.slice(0, aRank - 2);\n      const batchSize = ShapeUtil.size(batchDims);\n      const blobSize = attributes.blockSize / 8 * attributes.bits;\n      const blobSizeInWords = blobSize / 4;\n      const dataType = inputs[0].dataType;\n      const outputNumber = getMaxComponents(dimAOuter);\n      const aComponents = getMaxComponents(attributes.k);\n      const bComponents = getMaxComponents(blobSizeInWords);\n      const elementSize = getTensorElementSize(dataType)!;\n      const workgroupOutputSize = dimAOuter * nBlocksPerCol * elementSize;\n      const maxNumberOfComponents = Math.floor(maxComputeWorkgroupStorageSize / workgroupOutputSize);\n      const useBlockwiseMatMulNBits = nBlocksPerCol <= maxComputeWorkgroupSizes[0] && maxNumberOfComponents > 0;\n      const components = (!useBlockwiseMatMulNBits || maxNumberOfComponents >= 4) ? getMaxComponents(dimBOuter) :\n          ((maxNumberOfComponents >= 2) && getMaxComponents(dimBOuter) >= 2)      ? 2 :\n                                                                                    1;\n      const outputShape = batchDims.concat([dimAOuter, dimBOuter]);\n      const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;\n\n      const programUniforms: ProgramUniform[] = useBlockwiseMatMulNBits ?\n          [] :\n          [{type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: attributes.blockSize}];\n      const inputShapeTemp = [batchSize, dimAOuter, dimInner / aComponents];\n      const bShape = ShapeUtil.convertShape(inputs[1].dims).slice();\n      bShape.splice(-1, 1, blobSizeInWords / bComponents);\n      programUniforms.push(...createTensorShapeVariables(inputShapeTemp));\n      programUniforms.push(...createTensorShapeVariables(bShape));\n      programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n      if (inputs.length === 4) {\n        programUniforms.push(...createTensorShapeVariables(ShapeUtil.convertShape(inputs[3].dims)));\n      }\n      const outputShapeTemp = [batchSize, dimAOuter, dimBOuter / components];\n      programUniforms.push(...createTensorShapeVariables(outputShapeTemp));\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const inputRank = inputShapeTemp.length;\n        const a = inputVariable('a', inputs[0].dataType, inputRank, aComponents);\n        const b = inputVariable('b', DataType.uint32, bShape.length, bComponents);\n        const scales = inputVariable('scales', inputs[2].dataType, inputs[2].dims.length);\n        const inputVariables = [a, b, scales];\n        const zeroPoints =\n            inputs.length === 4 ? inputVariable('zero_points', DataType.uint32, inputs[3].dims.length) : undefined;\n        if (zeroPoints) {\n          inputVariables.push(zeroPoints);\n        }\n        const outputRank = outputShapeTemp.length;\n        const output = outputVariable('output', inputs[0].dataType, outputRank, components);\n        const uniforms: UniformsArrayType = [{name: 'output_size', type: 'u32'}, {name: 'block_size', type: 'u32'}];\n        const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n\n        const qDqDataType = (() => {\n          switch (aComponents) {\n            case 1:\n              return `array<${dataType}, 8>`;\n            case 2:\n              return `mat4x2<${dataType}>`;\n            case 4:\n              return `mat2x4<${dataType}>`;\n            default:\n              throw new Error(`${aComponents}-component is not supported.`);\n          }\n        })();\n\n        const processOneBlock = `\n        for (var word: u32 = 0; word < ${blobSizeInWords}; word += ${bComponents}) {\n          ${b.indicesSet('b_indices', '2', 'word')};\n          let b_data = ${b.getByIndices('b_indices')};\n          for (var i: u32 = 0; i < ${bComponents}; i++) {\n            let b_value: u32 = ${bComponents === 1 ? 'b_data' : 'b_data[word + i]'};\n            let b_mask: u32 = 0x0F0F0F0Fu;\n            let b_value_lower: vec4<u32> = unpack4xU8(b_value & b_mask);\n            let b_value_upper: vec4<u32> = unpack4xU8((b_value >> 4) & b_mask);\n            let b_quantized_values = ${qDqDataType}(${\n            Array.from({length: 4}, (_, i) => `${dataType}(b_value_lower[${i}]), ${dataType}(b_value_upper[${i}])`)\n                .join(', ')});\n            let b_dequantized_values = ${(() => {\n          if (aComponents === 1) {\n            return `${qDqDataType}(${\n                Array.from({length: 8}, (_, i) => `(b_quantized_values[${i}] - zero_point) * scale`).join(', ')});`;\n          } else {\n            return `(b_quantized_values - ${qDqDataType}(${Array(8).fill('zero_point').join(',')})) * scale;`;\n          }\n        })()};\n            // Number of B elements per 32-bit word is 32/bits = 32/4 = 8\n            for (var m: u32 = 0; m < ${useBlockwiseMatMulNBits ? dimAOuter : outputNumber}u; m++) {\n              ${a.indicesSet('a_indices', inputRank - 2, useBlockwiseMatMulNBits ? 'm' : `row * ${outputNumber} + m`)};\n              ${a.indicesSet('a_indices', inputRank - 1, 'word_offset')};\n              var input_offset = ${a.indicesToOffset('a_indices')};\n              var a_data: ${qDqDataType};\n              for (var j: u32 = 0; j < ${8 / aComponents}; j++) {\n                a_data[j] = ${a.getByOffset('input_offset')};\n                input_offset++;\n              }\n              ${useBlockwiseMatMulNBits ? 'workgroup_shared[workgroup_shared_offset + m]' : 'output_values[m]'}${\n            components > 1 ? '[c]' : ''} += ${\n            Array\n                .from(\n                    {length: 8 / aComponents},\n                    (_, i) => `${\n                        aComponents === 1 ? `a_data[${i}] * b_dequantized_values[${i}]` :\n                                            `dot(a_data[${i}], b_dequantized_values[${i}])`}`)\n                .join(' + ')};\n            }\n            word_offset += ${8 / aComponents};\n          }\n        }`;\n        const updateZeroPointIndex = zeroPoints ? `\n          zero_point_offset += 4;\n          if (zero_point_offset == 32) {\n            zero_point_offset = 0;\n            zero_point_index++;\n            zero_point_word = ${zeroPoints.getByOffset('zero_point_index')};\n          }` :\n                                                  '';\n\n        return useBlockwiseMatMulNBits ? `\n        var<workgroup> workgroup_shared: array<${output.type.value}, ${dimAOuter * nBlocksPerCol}>;\n        ${shaderHelper.declareVariables(...inputVariables, output)}\n        ${shaderHelper.mainStart([\n          nBlocksPerCol, 1, 1\n        ])}\n          var a_indices: ${a.type.indices};\n          var block = local_id.x;\n          var col = workgroup_id.y;\n          var batch = workgroup_id.z;\n          ${a.indicesSet('a_indices', '0', 'batch')};\n          // Two zero points are packed into one byte when uniforms.bits is 4.\n          for (var c: u32 = 0; c < ${components}; c++) {\n            let col_times_components_plus_c = col * ${components} + c;\n              ${\n                                             zeroPoints ? `\n            var zero_point_bytes_per_col: u32 = (${nBlocksPerCol} + 1) / 2;\n            var zero_point_byte_count: u32 = col_times_components_plus_c * zero_point_bytes_per_col + (block >> 0x1u);\n            var zero_point_word_index: u32 = zero_point_byte_count >> 0x2u;\n            var zero_point_byte_offset: u32 = zero_point_byte_count & 0x3u;\n            var zero_point_nibble_offset: u32 = block & 0x1u;\n            var zero_point_bits_offset: u32 = (zero_point_byte_offset << 3) + (zero_point_nibble_offset << 2);\n            var zero_point_word: u32 = ${zeroPoints.getByOffset('zero_point_word_index')} >> zero_point_bits_offset;` :\n                                                          ''}\n            var b_indices: ${b.type.indices};\n            ${b.indicesSet('b_indices', '0', 'col_times_components_plus_c')};\n            // The scale and zero points are computed per block.\n            var scales_index = col_times_components_plus_c * ${nBlocksPerCol} + block;\n            let scale = ${scales.getByOffset('scales_index')};\n            // The default zero point is 8 for unsigned 4-bit quantization.\n            let zero_point = ${dataType}(${zeroPoints ? '(zero_point_word) & 0xFu' : 8.0});\n            ${b.indicesSet('b_indices', '1', 'block')};\n            var word_offset: u32 = block * ${attributes.blockSize / aComponents};\n            var workgroup_shared_offset: u32 = block * ${dimAOuter};\n            ${processOneBlock}\n          }\n          workgroupBarrier();\n          if (local_id.x == 0u) {\n            var output_indices: ${output.type.indices};\n            ${output.indicesSet('output_indices', '0', 'batch')};\n            ${output.indicesSet('output_indices', outputRank - 1, 'col')};\n            ${output.indicesSet('output_indices', outputRank - 2, '0')};\n            var output_offset = ${output.indicesToOffset('output_indices')};\n            for (var m: u32 = 0u; m < ${dimAOuter}u; m++) {\n              var output_value: ${output.type.value} = ${output.type.value}(0);\n              var workgroup_shared_offset: u32 = m;\n              for (var b: u32 = 0u; b < ${nBlocksPerCol}u; b++) {\n                output_value += workgroup_shared[workgroup_shared_offset];\n                workgroup_shared_offset += ${dimAOuter};\n              }\n              ${output.setByOffset('output_offset', 'output_value')};\n              output_offset += ${dimBOuter / components};\n            }\n          }\n        }` :\n                                         `\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n        ${shaderHelper.mainStart()}\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n          var output_values: array<${output.type.value}, ${outputNumber}>;\n          var output_indices = ${output.offsetToIndices('global_idx')};\n          var col = ${output.indicesGet('output_indices', outputRank - 1)};\n          var row = ${output.indicesGet('output_indices', outputRank - 2)};\n          var a_indices: ${a.type.indices} = output_indices;\n          // Two zero points are packed into one byte because uniforms.bits <= 4.\n          // zero_point_offset is either 0 or 4. It is bit offset within one byte.\n          // TODO support zero_point_offset for bits > 4\n          ${\n                                             zeroPoints ? `\n          var zero_point_abs_offset = col * ${components} * ((${nBlocksPerCol} + 1) / 2);\n          var zero_point_index: u32 = zero_point_abs_offset / 4;\n          var zero_point_word: u32 = ${zeroPoints.getByOffset('zero_point_index')};\n          var zero_point_offset: u32 = (zero_point_abs_offset % 4) * 8;` :\n                                                          ''}\n          var scale_index = col * ${nBlocksPerCol * components};\n          var b_indices: ${b.type.indices};\n          for (var c: u32 = 0; c < ${components}; c++) {\n            ${b.indicesSet('b_indices', '0', `col * ${components} + c`)};\n            var block_offset: u32 = 0;\n            for (var block: u32 = 0; block < ${nBlocksPerCol}; block++) {\n              // The scale and zero points are computed per block.\n              let scale = ${scales.getByOffset('scale_index')};\n              // The default zero point is 8 for unsigned 4-bit quantization.\n              let zero_point = ${dataType}(${zeroPoints ? 'extractBits(zero_point_word, zero_point_offset, 4)' : 8.0});\n              ${b.indicesSet('b_indices', '1', 'block')};\n              var word_offset: u32 = block_offset;\n              ${processOneBlock}\n              scale_index++;\n              ${updateZeroPointIndex}\n              block_offset += uniforms.block_size / ${aComponents};\n            }\n            // Drop the trailing 4 bits if the zero_poit_offset is not a byte boundary to align with the next byte.\n            ${\n                                             zeroPoints ? `if (zero_point_offset % 8 > 0) {\n                ${updateZeroPointIndex}\n              }` :\n                                                          ''}\n            }\n            for (var k: u32 = 0u; k < ${outputNumber}u; k++) {\n              ${output.indicesSet('output_indices', outputRank - 2, `${outputNumber} * row + k`)};\n              ${output.setByIndices('output_indices', 'output_values[k]')}\n            }\n        }`;\n      };\n      return {\n        name: useBlockwiseMatMulNBits ? 'BlockwiseMatMulNBits' : 'MatMulNBits',\n        shaderCache: {\n          hint: `${attributes.cacheKey};${dimAOuter};${dataType};${inputs.length}`,\n          inputDependencies: Array(inputs.length).fill('rank')\n        },\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType}],\n          name: useBlockwiseMatMulNBits ? 'BlockwiseMatMulNBits' : 'MatMulNBits',\n          dispatchGroup: useBlockwiseMatMulNBits ? {x: 1, y: Math.ceil(dimBOuter / components), z: batchSize} :\n                                                   {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource\n      };\n    };\n\nexport const matMulNBits = (context: ComputeContext, attributes: MatMulNBitsAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  const maxComputeWorkgroupSizes: [number, number, number] = context.getMaxComputeWorkgroupSizes();\n  const maxComputeWorkgroupStorageSize = context.getMaxComputeWorkgroupStoragesize();\n  context.compute(createMatMulNBitsProgramInfo(\n      context.inputs, attributes, maxComputeWorkgroupSizes, maxComputeWorkgroupStorageSize));\n};\n\nexport const parseMatMulNBitsAttributes = (attributes: Record<string, unknown>): MatMulNBitsAttributes =>\n    createAttributeWithCacheKey(attributes as Omit<MatMulNBitsAttributes, keyof AttributeWithCacheKey>);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, GpuDataType, ProgramUniform} from '../types';\n\nimport {applyAttention, AttentionAttrs, AttentionMaskType, AttentionParameters, AttentionQkvFormat} from './attention';\nimport {inputVariable, outputVariable, ShaderHelper, UniformsArrayType} from './common';\nimport {createTransposeProgramInfo, TransposeAttributes} from './transpose';\n\nconst getInput = (inputs: readonly TensorView[], i: number) =>\n    (inputs.length > i) && (inputs[i].dims.length > 0) && (ShapeUtil.size(inputs[i].dims)) > 0 ? inputs[i] : undefined;\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: AttentionAttrs): AttentionParameters => {\n  const query = inputs[0];\n  const key = getInput(inputs, 1);\n  const value = getInput(inputs, 2);\n  const bias = getInput(inputs, 3);\n  const keyPaddingMask = getInput(inputs, 4);\n  const relativePositionBias = getInput(inputs, 5);\n  const pastKey = getInput(inputs, 6);\n  const pastValue = getInput(inputs, 7);\n\n  // Abbreviation and Meanings:\n  //   B:    batch_size\n  //   S:    sequence_length (input sequence length of query)\n  //   P:    past_sequence_length (past sequence length of key or value)\n  //   L:    kv_sequence_length (input sequence length of key or value)\n  //   M:    max_sequence_length\n  //   T:    total_sequence_length = past_sequence_length + kv_sequence_length\n  //   N:    num_heads\n  //   H:    head size for Q and K, aka q_head_size or k_head_size or qk_head_size\n  //   H_v:  v_head_size\n  //   D_i:  input hidden size\n  //   D:    hidden size for Q and K (D = N * H), aka q_hidden_size or k_hidden_size or qk_hidden_size\n  //   D_v:  v_hidden_size = num_heads * v_head_size\n\n  //     key_padding_mask (K/V)     : (B) or (2*B + 1) or (B, L) or None\n  //     relative_position_bias     : (B, 1, S, L)\n  //     past_key                   : (B, N, S*, H)\n  //     past_value                 : (B, N, S*, H)\n  // When no packing for q/k/v:\n  //     query            (Q)       : (B, S, D)\n  //     key              (K)       : (B, L, D) or (B, N, S*, H)\n  //     value            (V)       : (B, L, D_v) or (B, N, S*, H)\n  //     bias             (Q/K/V)   : (D + D + D_v)\n  // When packed kv is used:\n  //     query            (Q)       : (B, S, D)\n  //     key              (K)       : (B, L, N, 2, H)\n  //     value            (V)       : None\n  //     bias             (Q/K/V)   : None\n  // When packed qkv is used:\n  //     query            (Q)       : (B, L, N, 3, H) or (B, S, 3*D)\n  //     key              (K)       : None\n  //     value            (V)       : None\n  //     bias             (Q/K/V)   : None or (D + D + D_v)\n\n  if (query.dims.length !== 3 && query.dims.length !== 5) {\n    throw new Error('Input query is expected to have 3 or 5 dimensions');\n  }\n\n  const dmmhaPacking = false;\n  const batchSize = query.dims[0];\n  const sequenceLength = query.dims[1];\n  const hiddenSize = query.dims.length === 3 ? (dmmhaPacking ? query.dims[2] / 3 : query.dims[2]) :\n                                               attributes.numHeads * query.dims[4];\n  let kvSequenceLength = sequenceLength;\n\n  let pastSequenceLength = 0;\n  let maxSequenceLength = 0;\n  const headSize = Math.floor(hiddenSize / attributes.numHeads);\n  if (pastKey && pastValue) {\n    if (pastKey.dims.length !== 4) {\n      throw new Error('Input \"past_key\" is expected to have 4 dimensions');\n    }\n    if (pastKey.dims[0] !== batchSize || pastKey.dims[1] !== attributes.numHeads || pastKey.dims[3] !== headSize) {\n      throw new Error('Input \"past_key\" shape (batch_size, num_heads, past_sequence_length, head_size)');\n    }\n    if (pastValue.dims[0] !== batchSize || pastValue.dims[1] !== attributes.numHeads ||\n        pastValue.dims[3] !== headSize) {\n      throw new Error('Input \"past_value\" shape (batch_size, num_heads, past_sequence_length, head_size)');\n    }\n    if (pastKey.dims[2] !== pastValue.dims[2]) {\n      throw new Error('Input \"past_key\" and \"past_value\" shall have same dim 2 (past_sequence_length)');\n    }\n    if (pastValue.dims.length !== 4) {\n      throw new Error('Input \"past_value\" is expected to have 4 dimensions');\n    }\n    pastSequenceLength = pastKey.dims[2];\n    maxSequenceLength = pastKey.dims[2];\n  } else if (pastKey || pastValue) {\n    throw new Error('Input \"past_key\" and \"past_value\" shall be both present or both absent');\n  }\n\n  let qkvFormat: AttentionQkvFormat;\n  if (key) {\n    if (query.dims.length !== 3) {\n      throw new Error('Input \"query\" is expected to have 3 dimensions when key is given');\n    }\n    if (key.dims.length < 3 || key.dims.length > 5) {\n      throw new Error('Input \"key\" is expected to have 3, 4, or 5 dimensions');\n    }\n    if (query.dims[0] !== key.dims[0]) {\n      throw new Error('Input \"query\" and \"key\" shall have same dim 0 (batch size)');\n    }\n\n    if (key.dims.length === 3) {\n      if (key.dims[2] !== query.dims[2]) {\n        throw new Error('Input \"query\" and \"key\" shall have same dim 2 (hidden_size)');\n      }\n      qkvFormat = AttentionQkvFormat.qkvBSNH;\n      kvSequenceLength = key.dims[1];\n    } else if (key.dims.length === 5) {\n      if (key.dims[2] !== attributes.numHeads || key.dims[3] !== 2 || key.dims[4] !== headSize) {\n        throw new Error('Expect \"key\" shape (batch_size, kv_sequence_length, num_heads, 2, head_size) for packed kv');\n      }\n      if (value) {\n        throw new Error('Expect \"value\" be none when \"key\" has packed kv format.');\n      }\n      qkvFormat = AttentionQkvFormat.qKvBSNHxBSN2H;\n      kvSequenceLength = key.dims[1];\n    } else {  // key_dims.size() == 4 (cross-attention with past_key)\n      if (key.dims[1] !== attributes.numHeads || key.dims[3] !== headSize) {\n        throw new Error('Expect \"key\" shape (batch_size, num_heads, kv_sequence_length, head_size) for past_key');\n      }\n\n      qkvFormat = AttentionQkvFormat.unknown;\n      kvSequenceLength = key.dims[2];\n    }\n  } else {  // packed QKV\n    if (query.dims.length !== 3 && query.dims.length !== 5) {\n      throw new Error('Input \"query\" is expected to have 3 or 5 dimensions when key is empty');\n    }\n    if (query.dims.length === 5 && (query.dims[2] !== attributes.numHeads || query.dims[3] !== 3)) {\n      throw new Error('Expect \"query\" shape (batch_size, kv_sequence_length, num_heads, 3, head_size) for packed kv');\n    }\n\n    qkvFormat = AttentionQkvFormat.qkvBSN3H;\n  }\n\n  if (bias) {\n    if (bias.dims.length !== 1) {\n      throw new Error('Input \"bias\" is expected to have 1 dimension');\n    }\n\n    if (value) {\n      if (query.dims.length === 5 && query.dims[3] === 2) {\n        throw new Error('bias is not allowed for packed kv.');\n      }\n    }\n  }\n\n  let maskType: AttentionMaskType = AttentionMaskType.none;\n  if (keyPaddingMask) {\n    maskType = AttentionMaskType.maskUnknown;\n    const maskDims = keyPaddingMask.dims;\n    if (maskDims.length === 1) {\n      if (maskDims[0] === batchSize) {\n        maskType = AttentionMaskType.mask1dKeySeqLen;\n      } else if (maskDims[0] === 3 * batchSize + 2) {\n        maskType = AttentionMaskType.mask1DKeySeqLenStart;\n      }\n    } else if (maskDims.length === 2 && maskDims[0] === batchSize && maskDims[1] === kvSequenceLength) {\n      maskType = AttentionMaskType.mask2dKeyPadding;\n    }\n    if (maskType === AttentionMaskType.maskUnknown) {\n      throw new Error('Input \"key_padding_mask\" shape shall be (batch_size) or (batch_size, kv_sequence_length)');\n    }\n    throw new Error('Mask not supported');\n  }\n\n  let passPastInKv = false;\n  let vHiddenSize = hiddenSize;\n  if (value) {\n    if (value.dims.length !== 3 && value.dims.length !== 4) {\n      throw new Error('Input \"value\" is expected to have 3 or 4 dimensions');\n    }\n\n    if (query.dims[0] !== value.dims[0]) {\n      throw new Error('Input \"query\" and \"value\" shall have same dim 0 (batch_size)');\n    }\n\n    if (value.dims.length === 3) {\n      if (kvSequenceLength !== value.dims[1]) {\n        throw new Error('Input \"key\" and \"value\" shall have the same dim 1 (kv_sequence_length)');\n      }\n      vHiddenSize = value.dims[2];\n    } else {\n      if (kvSequenceLength !== value.dims[2]) {\n        throw new Error('Input \"past_key\" and \"past_value\" shall have the same dim 2 (kv_sequence_length)');\n      }\n      vHiddenSize = value.dims[1] * value.dims[3];\n      passPastInKv = true;\n    }\n  }\n\n  const totalSequenceLength = pastSequenceLength + kvSequenceLength;\n  const broadcastResPosBias = false;\n\n  if (keyPaddingMask) {\n    throw new Error('Key padding mask is not supported');\n  }\n\n  if (relativePositionBias) {\n    if (relativePositionBias.dims.length !== 4) {\n      throw new Error('Input \"relative_position_bias\" is expected to have 4 dimensions');\n    }\n    if ((relativePositionBias.dims[0] !== batchSize && relativePositionBias.dims[0] !== 1) ||\n        relativePositionBias.dims[1] !== attributes.numHeads || relativePositionBias.dims[2] !== sequenceLength ||\n        relativePositionBias.dims[3] !== totalSequenceLength) {\n      throw new Error('Input \"relative_position_bias\" shape (batch_size, 1, sequence_length, kv_sequence_length)');\n    }\n  }\n\n  return {\n    batchSize,\n    sequenceLength,\n    pastSequenceLength,\n    kvSequenceLength,\n    totalSequenceLength,\n    maxSequenceLength,\n    inputHiddenSize: 0,\n    hiddenSize,\n    vHiddenSize,\n    headSize,\n    vHeadSize: Math.floor(vHiddenSize / attributes.numHeads),\n    numHeads: attributes.numHeads,\n    isUnidirectional: false,\n    pastPresentShareBuffer: false,\n    maskFilterValue: attributes.maskFilterValue,\n    maskType,\n    scale: attributes.scale,\n    broadcastResPosBias,\n    passPastInKv,\n    qkvFormat,\n  };\n};\n\nexport const parseMultiHeadAttentionAttributes = (attributes: AttentionAttrs): AttentionAttrs =>\n    createAttributeWithCacheKey({...attributes});\n\nconst weightTransposeAttribute: TransposeAttributes = createAttributeWithCacheKey({perm: [0, 2, 1, 3]});\n\nconst addBiasTranspose =\n    (context: ComputeContext, qkv: TensorView, bias: TensorView, batchSize: number, sequenceLength: number,\n     hiddenSize: number, biasOffset: number) => {\n      const outputShape = [batchSize, sequenceLength, hiddenSize];\n      const outputSize = ShapeUtil.size(outputShape);\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: biasOffset},\n        {type: DataType.uint32, data: hiddenSize}\n      ];\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const output = outputVariable('qkv_with_bias', qkv.dataType, outputShape);\n        const qkvInput = inputVariable('qkv', qkv.dataType, outputShape);\n        const biasInput = inputVariable('bias', bias.dataType, outputShape);\n\n        const uniforms: UniformsArrayType = [\n          {name: 'output_size', type: 'u32'}, {name: 'bias_offset', type: 'u32'}, {name: 'hidden_size', type: 'u32'}\n        ];\n        return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(qkvInput, biasInput, output)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n    let bias_offset_idx = (global_idx % uniforms.hidden_size) + uniforms.bias_offset;\n\n    qkv_with_bias[global_idx] = qkv[global_idx] + bias[bias_offset_idx];\n  }`;\n      };\n\n      return context.compute(\n          {\n            name: 'MultiHeadAttentionAddBias',\n            shaderCache: {inputDependencies: ['type', 'type']},\n            getRunData: () => ({\n              outputs: [{dims: outputShape, dataType: qkv.dataType, gpuDataType: GpuDataType.default}],\n              dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n              programUniforms\n            }),\n            getShaderSource,\n          },\n          {inputs: [qkv, bias], outputs: [-1]})[0];\n    };\n\nconst maybeTransposeToBNSHAndAddBias =\n    (context: ComputeContext, batchSize: number, numHeads: number, sequenceLength: number, headSize: number,\n     input: TensorView, bias?: TensorView, biasOffset?: number) => {\n      // const newDims = [];\n\n      let reshapedInput = input;\n      if (!bias) {\n        if (input.dims.length === 3) {\n          reshapedInput = input.reshape([batchSize, sequenceLength, numHeads, headSize]);\n        }\n        return context.compute(\n            createTransposeProgramInfo(reshapedInput, weightTransposeAttribute.perm),\n            {inputs: [reshapedInput], outputs: [-1]})[0];\n      } else {\n        if (sequenceLength === 1) {\n          throw new Error('AddBiasReshape is not implemented. Please export your model with packed QKV or KV');\n        } else {\n          reshapedInput =\n              addBiasTranspose(context, input, bias, batchSize, sequenceLength, numHeads * headSize, biasOffset!);\n          reshapedInput = reshapedInput.reshape([batchSize, sequenceLength, numHeads, headSize]);\n          return context.compute(\n              createTransposeProgramInfo(reshapedInput, weightTransposeAttribute.perm),\n              {inputs: [reshapedInput], outputs: [-1]})[0];\n        }\n      }\n    };\n\nexport const multiHeadAttention = (context: ComputeContext, attributes: AttentionAttrs): void => {\n  const params = validateInputs(context.inputs, attributes);\n  const query = context.inputs[0];\n  const key = getInput(context.inputs, 1);\n  const value = getInput(context.inputs, 2);\n  const bias = getInput(context.inputs, 3);\n  const keyPaddingMask = getInput(context.inputs, 4);\n  const relativePositionBias = getInput(context.inputs, 5);\n  const pastKey = getInput(context.inputs, 6);\n  const pastValue = getInput(context.inputs, 7);\n  if (query.dims.length === 5) {\n    throw new Error('Packed QKV is not implemented');\n  }\n\n  if (key?.dims.length === 5) {\n    throw new Error('Packed KV is not implemented');\n  }\n\n  // applyAttention expects BNSH inputs\n  const kvBNSH = key && value && key.dims.length === 4 && value.dims.length === 4;\n\n  const Q = maybeTransposeToBNSHAndAddBias(\n      context, params.batchSize, params.numHeads, params.sequenceLength, params.headSize, query, bias, 0);\n\n  if (kvBNSH) {\n    return applyAttention(\n        context, Q, key, value, keyPaddingMask, undefined, pastKey, pastValue, relativePositionBias, params,\n        attributes);\n  }\n  if (!key || !value) {\n    throw new Error('key and value must be provided');\n  }\n  const K = maybeTransposeToBNSHAndAddBias(\n      context, params.batchSize, params.numHeads, params.kvSequenceLength, params.headSize, key, bias,\n      params.hiddenSize);\n\n  const V = maybeTransposeToBNSHAndAddBias(\n      context, params.batchSize, params.numHeads, params.kvSequenceLength, params.vHeadSize, value, bias,\n      2 * params.hiddenSize);\n\n  applyAttention(\n      context, Q, K, V, keyPaddingMask, undefined, pastKey, pastValue, relativePositionBias, params, attributes);\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, IndicesHelper, inputVariable, outputVariable, ShaderHelper, UniformDataElementType, UniformsArrayType} from './common';\n\ninterface PadAttributes {\n  // 0-constant, 1-reflect, 2-edge, 3-wrap\n  readonly mode: number;\n  readonly value: number;\n  readonly pads: number[];\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length < 1) {\n    throw new Error('Too few inputs');\n  }\n  if (inputs[0].dataType !== DataType.float && inputs[0].dataType !== DataType.float16) {\n    throw new Error('Input type must be float or float16.');\n  }\n\n  if (inputs.length >= 2) {\n    let validPads = inputs[0].dims.length * 2 === inputs[1].dims[0];\n    if (inputs.length === 4) {\n      validPads = inputs[3].dims[0] * 2 === inputs[1].dims[0];\n    }\n    if (!validPads) {\n      throw new Error('The pads should be a 1D tensor of shape [2 * input_rank] or [2 * num_axes].');\n    }\n  }\n};\n\nconst getPadConstant = (output: IndicesHelper, inputRank: number, padsLength: number): string => {\n  let block = '';\n  for (let i = inputRank - 1; i >= 0; --i) {\n    block += `\n            k = i32(${output.indicesGet('indices', i)}) - ${getElementAt('uniforms.pads', i, padsLength)};\n            if (k < 0) {\n              break;\n            }\n            if (k >= i32(${getElementAt('uniforms.x_shape', i, inputRank)})) {\n              break;\n            }\n            offset += k * i32(${getElementAt('uniforms.x_strides', i, inputRank)});\n        `;\n  }\n\n  return `\n          value = ${output.type.value}(uniforms.constant_value);\n          for (var i = 0; i < 1; i++) {\n            var offset = 0;\n            var k = 0;\n            ${block}\n            value = x[offset];\n          }\n      `;\n};\n\nconst getPadReflect = (output: IndicesHelper, inputRank: number, padsLength: number): string => {\n  let block = '';\n  for (let i = inputRank - 1; i >= 0; --i) {\n    block += `\n                k = i32(${output.indicesGet('indices', i)}) - ${getElementAt('uniforms.pads', i, padsLength)};\n                if (k < 0) {\n                  k = -k;\n                }\n                {\n                  let _2n_1 = 2 * (i32(${getElementAt('uniforms.x_shape', i, inputRank)}) - 1);\n                  k = k % _2n_1;\n                  if(k >= i32(${getElementAt('uniforms.x_shape', i, inputRank)})) {\n                    k = _2n_1 - k;\n                  }\n                }\n                offset += k * i32(${getElementAt('uniforms.x_strides', i, inputRank)});\n            `;\n  }\n\n  return `\n              var offset = 0;\n              var k = 0;\n              ${block}\n              value = x[offset];\n          `;\n};\n\nconst getPadEdge = (output: IndicesHelper, inputRank: number, padsLength: number): string => {\n  let block = '';\n  for (let i = inputRank - 1; i >= 0; --i) {\n    block += `\n                k = i32(${output.indicesGet('indices', i)}) - ${getElementAt('uniforms.pads', i, padsLength)};\n                if (k < 0) {\n                  k = 0;\n                }\n                if (k >= i32(${getElementAt('uniforms.x_shape', i, inputRank)})) {\n                  k = i32(${getElementAt('uniforms.x_shape', i, inputRank)}) - 1;\n                }\n                offset += k * i32(${getElementAt('uniforms.x_strides', i, inputRank)});\n            `;\n  }\n\n  return `\n              var offset = 0;\n              var k = 0;\n              ${block}\n              value = x[offset];\n          `;\n};\n\nconst getPadWrap = (output: IndicesHelper, inputRank: number, padsLength: number): string => {\n  let block = '';\n  for (let i = inputRank - 1; i >= 0; --i) {\n    block += `\n                k = i32(${output.indicesGet('indices', i)}) - ${getElementAt('uniforms.pads', i, padsLength)};\n                if (k < 0)  {\n                  k += i32(${getElementAt('uniforms.x_shape', i, inputRank)}]);\n                }\n                if (k >= i32(${getElementAt('uniforms.x_shape', i, inputRank)})) {\n                  k -= i32(${getElementAt('uniforms.x_shape', i, inputRank)});\n                }\n                offset += k * i32(${getElementAt('uniforms.x_strides', i, inputRank)});\n            `;\n  }\n\n  return `\n              var offset = 0;\n              var k = 0;\n              ${block}\n              value = x[offset];\n          `;\n};\n\nconst getPadSnippet = (output: IndicesHelper, inputRank: number, attributes: PadAttributes): string => {\n  switch (attributes.mode) {\n    case 0:\n      return getPadConstant(output, inputRank, attributes.pads.length);\n    case 1:\n      return getPadReflect(output, inputRank, attributes.pads.length);\n    case 2:\n      return getPadEdge(output, inputRank, attributes.pads.length);\n    case 3:\n      return getPadWrap(output, inputRank, attributes.pads.length);\n    default:\n      throw new Error('Invalid mode');\n  }\n};\n\nconst createPadProgramInfo = (inputs: readonly TensorView[], attributes: PadAttributes): ProgramInfo => {\n  const outputShape = ShapeUtil.padShape(inputs[0].dims.slice(), attributes.pads);\n  const inputDims = inputs[0].dims;\n  const outputSize = ShapeUtil.size(outputShape);\n  const programUniforms: ProgramUniform[] =\n      [{type: DataType.uint32, data: outputSize}, {type: DataType.int32, data: attributes.pads}];\n  if (attributes.mode === 0) {\n    programUniforms.push({type: inputs[0].dataType, data: attributes.value});\n  }\n\n  programUniforms.push(...createTensorShapeVariables(inputs[0].dims, outputShape));\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank'];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n    const input = inputVariable('x', inputs[0].dataType, inputDims.length);\n    const dataType = input.type.value;\n    const padSnippet = getPadSnippet(output, inputDims.length, attributes);\n    const uniforms: UniformsArrayType =\n        [{name: 'output_size', type: 'u32'}, {name: 'pads', type: 'i32', length: attributes.pads.length}];\n    if (attributes.mode === 0) {\n      uniforms.push({name: 'constant_value', type: dataType as UniformDataElementType});\n    }\n\n    return `\n            ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)}\n            ${shaderHelper.mainStart()}\n            ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n            let indices = ${output.offsetToIndices('global_idx')};\n\n            var value = ${dataType}(0);\n            ${padSnippet}\n            output[global_idx] = value;\n        }`;\n  };\n\n  return {\n    name: 'Pad',\n    shaderCache: {hint: `${attributes.mode}`, inputDependencies},\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(ShapeUtil.size(outputShape) / 64 /* workgroup size */)},\n      programUniforms\n    }),\n    getShaderSource,\n  };\n};\n\nconst createPadAttributesFromInputs = (inputs: readonly TensorView[], attributes: PadAttributes): PadAttributes => {\n  if (inputs.length > 1) {\n    const bigInt64Pads = inputs[1].getBigInt64Array();\n    const value = (inputs.length >= 3 && inputs[2].data) ? inputs[2].getFloat32Array()[0] : 0.0;\n\n    const inputRank = inputs[0].dims.length;\n    const updatePads = new Int32Array(2 * inputRank).fill(0);\n    if (inputs.length >= 4) {\n      const axes = inputs[3].getBigInt64Array();\n      for (let i = 0; i < axes.length; i++) {\n        updatePads[Number(axes[i])] = Number(bigInt64Pads[i]);\n        updatePads[Number(axes[i]) + inputRank] = Number(bigInt64Pads[i + axes.length]);\n      }\n    } else {\n      bigInt64Pads.forEach((v, i) => updatePads[Number(i)] = (Number(v)));\n    }\n\n    const pads: number[] = [];\n    updatePads.forEach(v => pads.push(v));\n\n    return {mode: attributes.mode, value, pads};\n  } else {\n    return attributes;\n  }\n};\n\nexport const pad = (context: ComputeContext, attributes: PadAttributes): void => {\n  validateInputs(context.inputs);\n  const updatedAttributes = createPadAttributesFromInputs(context.inputs, attributes);\n  context.compute(createPadProgramInfo(context.inputs, updatedAttributes), {inputs: [0]});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {env} from 'onnxruntime-common';\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {PoolConvUtil, ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, IndicesHelper, inputVariable, outputVariable, ShaderHelper, UniformsArrayType} from './common';\n\n// TODO: support:\n// - ceil_mode                 \"test_maxpool_2d_ceil\"\n// - storage_order             \"test_maxpool_with_argmax_2d_precomputed_strides\"\n// - [MaxPool] dilations       \"test_maxpool_2d_dilations\"\n// - [MaxPool] output[1]       \"test_maxpool_with_argmax_2d_precomputed_pads\"\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (env.webgpu.validateInputContent && (!inputs || inputs.length !== 1)) {\n    throw new Error('Pool ops requires 1 input.');\n  }\n};\n\nconst getAdjustedPoolAttributesAndOutputShape = <AttributeType extends AveragePoolAttributes|MaxPoolAttributes>(\n    input: TensorView, attributes: AttributeType, isGlobalOperator: boolean): [AttributeType, number[]] => {\n  const isChannelsLast = attributes.format === 'NHWC';\n  const inputShapeAsChannelFirst = input.dims.slice();\n  if (isChannelsLast) {\n    inputShapeAsChannelFirst.splice(1, 0, inputShapeAsChannelFirst.pop()!);  // Move channel to the second position.\n  }\n  const hasDilations = Object.hasOwnProperty.call(attributes, 'dilations');\n  const kernelShape = attributes.kernelShape.slice();\n  const strides = attributes.strides.slice();\n  const dilations: number[] = hasDilations ? (attributes as MaxPoolAttributes).dilations.slice() : [];\n  const pads = attributes.pads.slice();\n  PoolConvUtil.adjustPoolAttributes(isGlobalOperator, inputShapeAsChannelFirst, kernelShape, strides, dilations, pads);\n\n  const outputShapeAsChannelFirst = PoolConvUtil.computePoolOutputShape(\n      isGlobalOperator, inputShapeAsChannelFirst, strides, dilations, kernelShape, pads, attributes.autoPad);\n\n  const newAttributes = Object.assign({}, attributes);\n  if (hasDilations) {\n    Object.assign(newAttributes, {kernelShape, strides, pads, dilations, cacheKey: attributes.cacheKey});\n  } else {\n    Object.assign(newAttributes, {kernelShape, strides, pads, cacheKey: attributes.cacheKey});\n  }\n  const outputShapeAsChannelLast = outputShapeAsChannelFirst.slice();\n  outputShapeAsChannelLast.push(outputShapeAsChannelLast.splice(1, 1)[0]);\n  return [newAttributes, isChannelsLast ? outputShapeAsChannelLast : outputShapeAsChannelFirst];\n};\n\nconst getUniformAndPadInfo = <AttributeType extends AveragePoolAttributes|MaxPoolAttributes>(\n    outputShape: readonly number[],\n    attributes: AttributeType): [ProgramUniform[], UniformsArrayType, boolean, boolean, boolean] => {\n  const isChannelsLast = attributes.format === 'NHWC';\n  const outputSize = ShapeUtil.size(outputShape);\n  const kernelSize = ShapeUtil.size(attributes.kernelShape);\n  const programUniforms: ProgramUniform[] =\n      [{type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: kernelSize}];\n  const uniforms: UniformsArrayType = [{name: 'outputSize', type: 'u32'}, {name: 'kernelSize', type: 'u32'}];\n  if (attributes.kernelShape.length <= 2) {\n    const kw = attributes.kernelShape[attributes.kernelShape.length - 1];\n    const sw = attributes.strides[attributes.strides.length - 1];\n    const pwStart = attributes.pads[attributes.pads.length / 2 - 1];\n    const pwEnd = attributes.pads[attributes.pads.length - 1];\n    const pwStartEndNotZero = !!(pwStart + pwEnd);\n    programUniforms.push(\n        {type: DataType.uint32, data: kw},\n        {type: DataType.uint32, data: sw},\n        {type: DataType.uint32, data: pwStart},\n        {type: DataType.uint32, data: pwEnd},\n    );\n    uniforms.push(\n        {name: 'kw', type: 'u32'}, {name: 'sw', type: 'u32'}, {name: 'pwStart', type: 'u32'},\n        {name: 'pwEnd', type: 'u32'});\n\n    let phStartEndNotZero = false;\n    if (attributes.kernelShape.length === 2) {\n      const kh = attributes.kernelShape[attributes.kernelShape.length - 2];\n      const sh = attributes.strides[attributes.strides.length - 2];\n      const phStart = attributes.pads[attributes.pads.length / 2 - 2];\n      const phEnd = attributes.pads[attributes.pads.length - 2];\n      phStartEndNotZero = !!(phStart + phEnd);\n      programUniforms.push(\n          {type: DataType.uint32, data: kh}, {type: DataType.uint32, data: sh}, {type: DataType.uint32, data: phStart},\n          {type: DataType.uint32, data: phEnd});\n\n      uniforms.push(\n          {name: 'kh', type: 'u32'}, {name: 'sh', type: 'u32'}, {name: 'phStart', type: 'u32'},\n          {name: 'phEnd', type: 'u32'});\n    }\n    return [programUniforms, uniforms, true, pwStartEndNotZero, phStartEndNotZero];\n  } else {\n    if (isChannelsLast) {\n      throw new Error('Pooling with kernelShape.length > 2 is not supported for NHWC format.');\n    }\n    const kernelStrides = ShapeUtil.computeStrides(attributes.kernelShape);\n    programUniforms.push(\n        {type: DataType.uint32, data: kernelStrides}, {type: DataType.uint32, data: attributes.pads},\n        {type: DataType.uint32, data: attributes.strides});\n    uniforms.push(\n        {name: 'kernelStrides', type: 'u32', length: kernelStrides.length},\n        {name: 'pads', type: 'u32', length: attributes.pads.length},\n        {name: 'strides', type: 'u32', length: attributes.strides.length});\n\n    const hasPads = attributes.pads.reduce((sum, cur) => sum + cur);\n    return [programUniforms, uniforms, !!hasPads, false, false];\n  }\n};\n\nconst generatePoolingCode = <AttributeType extends AveragePoolAttributes|MaxPoolAttributes>(\n    shaderHelper: ShaderHelper, x: IndicesHelper, rank: number, outputShapeRank: number, attributes: AttributeType,\n    op1: string, op2: string, start: number, uniforms: UniformsArrayType, hasPads: boolean, pwStartEndNotZero: boolean,\n    phStartEndNotZero: boolean): string => {\n  const isChannelsLast = attributes.format === 'NHWC';\n  const dataType = x.type.value;\n  const output = outputVariable('output', x.type.tensor, outputShapeRank);\n\n  if (attributes.kernelShape.length <= 2) {\n    let codeW = '';\n    let codeH = '';\n    let codeHEnd = '';\n    const dimIdxW = rank - (isChannelsLast ? 2 : 1);\n    if (pwStartEndNotZero) {\n      codeW = `\n                for (var i: u32 = 0u; i < uniforms.kw; i++) {\n                  xIndices[${dimIdxW}] = indices[${dimIdxW}] * uniforms.sw - uniforms.pwStart + i;\n                  if (xIndices[${dimIdxW}] < 0 || xIndices[${dimIdxW}]\n                      >= uniforms.x_shape[${dimIdxW}]) {\n                    pad++;\n                    continue;\n                  }\n                  let x_val = x[${x.indicesToOffset('xIndices')}];\n                  ${op1}\n                }`;\n    } else {\n      codeW = `\n                for (var i: u32 = 0u; i < uniforms.kw; i++) {\n                  xIndices[${dimIdxW}] = indices[${dimIdxW}] * uniforms.sw - uniforms.pwStart + i;\n                  let x_val = x[${x.indicesToOffset('xIndices')}];\n                  ${op1}\n                }`;\n    }\n\n    if (attributes.kernelShape.length === 2) {\n      const dimIdxH = rank - (isChannelsLast ? 3 : 2);\n      if (phStartEndNotZero) {\n        codeH = `\n                for (var j: u32 = 0u; j < uniforms.kh; j++) {\n                  xIndices[${dimIdxH}] = indices[${dimIdxH}] * uniforms.sh - uniforms.phStart + j;\n                  if (xIndices[${dimIdxH}] < 0 || xIndices[${dimIdxH}] >= uniforms.x_shape[${dimIdxH}]) {\n                    pad += i32(uniforms.kw);\n                    continue;\n                  }\n              `;\n      } else {\n        codeH = `\n                for (var j: u32 = 0u; j < uniforms.kh; j++) {\n                  xIndices[${dimIdxH}] = indices[${dimIdxH}] * uniforms.sh - uniforms.phStart + j;\n                `;\n      }\n      codeHEnd = `\n              }\n            `;\n    }\n\n    const poolingCode = `\n            ${shaderHelper.registerUniforms(uniforms).declareVariables(x, output)}\n\n            ${shaderHelper.mainStart()}\n              ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n\n              let indices = ${output.offsetToIndices('global_idx')};\n              var xIndices = ${output.offsetToIndices('global_idx')};\n\n              var value = ${dataType}(${start});\n              var pad = 0;\n              ${codeH}\n              ${codeW}\n              ${codeHEnd}\n              ${op2}\n\n              output[global_idx] = value;\n            }`;\n    return poolingCode;\n  } else {\n    if (isChannelsLast) {\n      throw new Error('Pooling with kernelShape.length > 2 is not supported for NHWC format.');\n    }\n    const stridesRank = attributes.kernelShape.length;\n    const padsRank = attributes.pads.length;\n    let padCode = '';\n    if (hasPads) {\n      padCode = `\n                if (xIndices[j] >= uniforms.x_shape[j]) {\n                  pad++;\n                  isPad = true;\n                  break;\n                }\n              }\n              if (!isPad) {\n                let x_val = x[${x.indicesToOffset('xIndices')}];\n                ${op1}\n              }`;\n    } else {\n      padCode = `\n              }\n              let x_val = x[${x.indicesToOffset('xIndices')}];\n              ${op1}\n            `;\n    }\n    const poolingCode = `\n            ${shaderHelper.registerUniforms(uniforms).declareVariables(x, output)}\n\n            ${shaderHelper.mainStart()}\n              ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n              let indices = ${output.offsetToIndices('global_idx')};\n              var xIndices = ${output.offsetToIndices('global_idx')};\n\n              var offsets: array<u32, ${stridesRank}>;\n\n              var value = ${dataType}(${start});\n              var pad = 0;\n              var isPad = false;\n\n              for (var i: u32 = 0u; i < uniforms.kernelSize; i++) {\n                var offset = i;\n                for (var j = 0u; j < ${stridesRank - 1}u; j++) {\n                  offsets[j] = offset / ${getElementAt('uniforms.kernelStrides', 'j', stridesRank)};\n                  offset -= offsets[j] * ${getElementAt('uniforms.kernelStrides', 'j', stridesRank)};\n                }\n                offsets[${stridesRank - 1}] = offset;\n\n                isPad = false;\n                for (var j = ${rank - stridesRank}u; j < ${rank}u; j++) {\n                  xIndices[j] = indices[j] * ${\n        getElementAt('uniforms.strides', `j - ${rank - stridesRank}u`, stridesRank)}\n                    + offsets[j - ${rank - stridesRank}u] - ${getElementAt('uniforms.pads', 'j - 2u', padsRank)};\n                  ${padCode}\n              }\n              ${op2}\n\n              output[global_idx] = value;\n            }`;\n    return poolingCode;\n  }\n};\n\nexport interface FormatAttributes {\n  readonly format: 'NHWC'|'NCHW';\n}\n\nexport interface PoolCommonAttributes extends FormatAttributes {\n  readonly autoPad: string;\n  readonly ceilMode: number;\n  readonly kernelShape: readonly number[];\n  readonly strides: readonly number[];\n  readonly pads: readonly number[];\n}\n\nconst createShaderKeyFromAttributes = (attributes: PoolCommonAttributes): string =>\n    (`${attributes.format};${attributes.ceilMode};${attributes.autoPad};${attributes.kernelShape.length}`);\n\nconst createAveragePoolShaderKeyFromAttributes = (attributes: AveragePoolAttributes): string =>\n    (`${createShaderKeyFromAttributes(attributes)};${attributes.countIncludePad}`);\n\nconst createMaxPoolShaderKeyFromAttributes = (attributes: MaxPoolAttributes): string =>\n    (`${createShaderKeyFromAttributes(attributes)};${attributes.storageOrder};${attributes.dilations}`);\n\nconst parsePoolCommonAttributes = (attributes: Record<string, unknown>): PoolCommonAttributes => ({\n  format: attributes.format as FormatAttributes['format'],\n  autoPad: ['NOTSET', 'VALID', 'SAME_UPPER', 'SAME_LOWER'][attributes.auto_pad as number],\n  ceilMode: attributes.ceil_mode as number,\n  kernelShape: attributes.kernel_shape as [number, number],\n  strides: attributes.strides as [number, number],\n  pads: attributes.pads as [number, number, number, number]\n});\n\nexport interface AveragePoolAttributes extends PoolCommonAttributes, AttributeWithCacheKey {\n  readonly countIncludePad: boolean;\n}\n\nconst createAveragePoolProgramInfo =\n    (name: string, input: TensorView, isGlobalOperator: boolean, attributes: AveragePoolAttributes): ProgramInfo => {\n      const [adjustedAttributes, outputShape] =\n          getAdjustedPoolAttributesAndOutputShape(input, attributes, isGlobalOperator);\n      const x = inputVariable('x', input.dataType, input.dims.length);\n      const dataType = x.type.value;\n\n      const op1 = 'value += x_val;';\n      let op2 = '';\n      if (adjustedAttributes.countIncludePad) {\n        op2 += `value /= ${dataType}(uniforms.kernelSize);`;\n      } else {\n        op2 += `value /= ${dataType}(i32(uniforms.kernelSize) - pad);`;\n      }\n      const [programUniforms, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero] =\n          getUniformAndPadInfo(outputShape, adjustedAttributes);\n      programUniforms.push(...createTensorShapeVariables(input.dims, outputShape));\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank'];\n      return {\n        name,\n        shaderCache:\n            {hint: `${attributes.cacheKey};${hasPads};${pwStartEndNotZero};${phStartEndNotZero}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: input.dataType}],\n          dispatchGroup: {x: Math.ceil(ShapeUtil.size(outputShape) / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource: shaderHelper => generatePoolingCode(\n            shaderHelper, x, input.dims.length, outputShape.length, adjustedAttributes, op1, op2, 0.0, uniforms,\n            hasPads, pwStartEndNotZero, phStartEndNotZero),\n      };\n    };\n\nexport const parseAveragePoolAttributes = (attributes: Record<string, unknown>): AveragePoolAttributes => {\n  const countIncludePad = (attributes.count_include_pad as number) === 0 ? false : true;\n\n  const attr = parsePoolCommonAttributes(attributes);\n  // TODO: support attribute 'ceil_mode'\n  if (attr.ceilMode !== 0) {\n    throw new Error('using ceil() in shape computation is not yet supported for AveragePool');\n  }\n  const averagePoolAttributes = {countIncludePad, ...attr, cacheKey: ''};\n  return {...averagePoolAttributes, cacheKey: createAveragePoolShaderKeyFromAttributes(averagePoolAttributes)};\n};\n\nexport const averagePool = (context: ComputeContext, attributes: AveragePoolAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createAveragePoolProgramInfo('AveragePool', context.inputs[0], false, attributes));\n};\n\nconst globalPoolAttributes = {\n  autoPad: '',\n  ceilMode: 0,\n  countIncludePad: false,\n  kernelShape: [],\n  strides: [],\n  pads: [],\n  storageOrder: 0,\n  dilations: []\n};\n\nexport const parseGlobalAveragePoolAttributes = (attributes: Record<string, unknown>): AveragePoolAttributes => {\n  const format = attributes.format as FormatAttributes['format'];\n  return {format, ...globalPoolAttributes, cacheKey: format};\n};\n\nexport const globalAveragePool = (context: ComputeContext, attributes: AveragePoolAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createAveragePoolProgramInfo('GlobalAveragePool', context.inputs[0], true, attributes));\n};\n\nexport interface MaxPoolAttributes extends PoolCommonAttributes, AttributeWithCacheKey {\n  readonly storageOrder: number;\n  readonly dilations: number[];\n}\n\nconst createMaxPoolProgramInfo =\n    (name: string, input: TensorView, isGlobalOperator: boolean, attributes: MaxPoolAttributes): ProgramInfo => {\n      const [adjustedAttributes, outputShape] =\n          getAdjustedPoolAttributesAndOutputShape(input, attributes, isGlobalOperator);\n      const op1 = `\n      value = max(x_val, value);\n    `;\n      const op2 = '';\n      const x = inputVariable('x', input.dataType, input.dims.length);\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank'];\n      const [programUniforms, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero] =\n          getUniformAndPadInfo(outputShape, adjustedAttributes);\n      programUniforms.push(...createTensorShapeVariables(input.dims, outputShape));\n      return {\n        name,\n        shaderCache:\n            {hint: `${attributes.cacheKey};${hasPads};${pwStartEndNotZero};${phStartEndNotZero}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: input.dataType}],\n          dispatchGroup: {x: Math.ceil(ShapeUtil.size(outputShape) / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource: shaderHelper => generatePoolingCode(\n            shaderHelper, x, input.dims.length, outputShape.length, adjustedAttributes, op1, op2,\n            (input.dataType === DataType.float16) ? -65504 : -1e5, uniforms, hasPads, pwStartEndNotZero,\n            phStartEndNotZero),\n      };\n    };\n\nexport const maxPool = (context: ComputeContext, attributes: MaxPoolAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createMaxPoolProgramInfo('MaxPool', context.inputs[0], false, attributes));\n};\n\nexport const parseMaxPoolAttributes = (attributes: Record<string, unknown>): MaxPoolAttributes => {\n  const storageOrder = attributes.storage_order as number;\n  const dilations = attributes.dilations as [number, number];\n\n  const attr = parsePoolCommonAttributes(attributes);\n  // TODO: support attribute 'ceil_mode' and 'storage_order'\n  if (storageOrder !== 0) {\n    throw new Error('column major storage order is not yet supported for MaxPool');\n  }\n  if (attr.ceilMode !== 0) {\n    throw new Error('using ceil() in shape computation is not yet supported for MaxPool');\n  }\n  const maxPoolAttributes = {storageOrder, dilations, ...attr, cacheKey: ''};\n  return {...maxPoolAttributes, cacheKey: createMaxPoolShaderKeyFromAttributes(maxPoolAttributes)};\n};\n\nexport const parseGlobalMaxPoolAttributes = (attributes: Record<string, unknown>): MaxPoolAttributes => {\n  const format = attributes.format as FormatAttributes['format'];\n  return {format, ...globalPoolAttributes, cacheKey: format};\n};\n\nexport const globalMaxPool = (context: ComputeContext, attributes: MaxPoolAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createMaxPoolProgramInfo('GlobalMaxPool', context.inputs[0], true, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {env} from 'onnxruntime-common';\n\nimport {DataType} from '../../../wasm-common';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, outputVariable, ShaderHelper, UniformDataElementType, UniformsArrayType} from './common';\n\nconst validateInputsContent = (start: number, limit: number, delta: number): void => {\n  const sameStartLimit = start === limit;\n  const increasingRangeNegativeStep = start < limit && delta < 0;\n  const decreasingRangePositiveStep = start > limit && delta > 0;\n\n  if (sameStartLimit || increasingRangeNegativeStep || decreasingRangePositiveStep) {\n    throw new Error('Range these inputs\\' contents are invalid.');\n  }\n};\n\nconst createRangeProgramInfo = (start: number, limit: number, delta: number, dataType: DataType): ProgramInfo => {\n  const numElements = Math.abs(Math.ceil((limit - start) / delta));\n  const outputShape: number[] = [numElements];\n  const outputSize = numElements;\n  const programUniforms: ProgramUniform[] = [\n    {type: DataType.uint32, data: outputSize}, {type: dataType, data: start}, {type: dataType, data: delta},\n    ...createTensorShapeVariables(outputShape)\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const output = outputVariable('output', dataType, outputShape.length);\n    const wgslType = output.type.value;\n    const uniforms: UniformsArrayType = [\n      {name: 'outputSize', type: 'u32'}, {name: 'start', type: wgslType as UniformDataElementType},\n      {name: 'delta', type: wgslType as UniformDataElementType}\n    ];\n    return `\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(output)}\n        ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n        output[global_idx] = uniforms.start + ${wgslType}(global_idx) * uniforms.delta;\n      }`;\n  };\n\n  return {\n    name: 'Range',\n    shaderCache: {hint: `${dataType}`},\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n      programUniforms\n    })\n  };\n};\n\nexport const range = (context: ComputeContext): void => {\n  let start = 0;\n  let limit = 0;\n  let delta = 0;\n  if (context.inputs[0].dataType === DataType.int32) {\n    start = context.inputs[0].getInt32Array()[0];\n    limit = context.inputs[1].getInt32Array()[0];\n    delta = context.inputs[2].getInt32Array()[0];\n  } else if (context.inputs[0].dataType === DataType.float) {\n    start = context.inputs[0].getFloat32Array()[0];\n    limit = context.inputs[1].getFloat32Array()[0];\n    delta = context.inputs[2].getFloat32Array()[0];\n  }\n  if (env.webgpu.validateInputContent) {\n    validateInputsContent(start, limit, delta);\n  }\n\n  context.compute(createRangeProgramInfo(start, limit, delta, context.inputs[0].dataType), {inputs: []});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\n\ntype CoordinateTransformMode = 'half_pixel'|'asymmetric'|'pytorch_half_pixel'|'tf_half_pixel_for_nn'|'align_corners'|\n    'tf_crop_and_resize'|'half_pixel_symmetric';\n\ntype KeepAspectRatioPolicy = 'stretch'|'not_smaller'|'not_larger';\n\ntype Mode = 'nearest'|'linear'|'cubic';\n\ntype NearestMode = 'round_prefer_floor'|'round_prefer_ceil'|'floor'|'ceil'|'simple';\n\nexport interface ResizeAttributes extends AttributeWithCacheKey {\n  antialias: number;\n  axes: number[];\n  coordinateTransformMode: CoordinateTransformMode;\n  cubicCoeffA: number;\n  excludeOutside: boolean;\n  extrapolationValue: number;\n  keepAspectRatioPolicy: KeepAspectRatioPolicy;\n  mode: Mode;\n  nearestMode: NearestMode;\n}\n\nconst validateScales = (scales: number[], attributes: ResizeAttributes): void => {\n  scales.every((value) => value > 0 || (() => {\n                            throw new Error('Resize requires scales input values to be positive');\n                          }));\n  // Check scales dims based on mode: LINEAR, CUBIC\n  if (scales.length > 0) {\n    if (attributes.mode === 'linear') {\n      if (!(scales.length === 2 || scales.length === 3 || (scales.length === 4 && scales[0] === 1 && scales[1] === 1) ||\n            (scales.length === 4 && scales[0] === 1 && scales[3] === 1) ||\n            (scales.length === 5 && scales[0] === 1 && scales[1] === 1))) {\n        throw new Error(\n            `For linear mode, Resize requires scales to be 2D, 3D, 4D with either two outermost or one innermost and\n            one outermost scale values equal to 1, or 5D with two outermost scale values equal to 1`);\n      }\n    } else if (attributes.mode === 'cubic') {\n      if (!(scales.length === 2 || (scales.length === 4 && scales[0] === 1 && scales[1] === 1) ||\n            (scales.length === 4 && scales[0] === 1 && scales[3] === 1))) {\n        throw new Error('Resize requires scales input size to be 2 or 4 for cubic mode');\n      }\n    }\n  }\n};\n\nconst updateScales = (scales: readonly number[], axes: readonly number[], rank: number): number[] => {\n  axes.every((value) => value >= 0 && value < rank || (() => {\n                          throw new Error('Resize requires axes input values to be positive and less than rank');\n                        }));\n  const newScales = new Array(rank).fill(1.0);\n  axes.forEach((value, index) => newScales[value] = scales[index]);\n  return newScales;\n};\n\nconst validateInputs =\n    (inputs: readonly TensorView[], attributes: ResizeAttributes, opsetVersion: number, scales: number[],\n     sizes: number[], roi: number[]): void => {\n      const [roiInputIndex, scalesInputIndex, sizesInputIndex] =\n          (opsetVersion > 10) ? [1, 2, 3] : [-1, (inputs.length > 1) ? 1 : -1, -1];\n      const rank = inputs[0].dims.length;\n      if (roiInputIndex > 0 && inputs.length > roiInputIndex && inputs[roiInputIndex].dims.length > 0) {\n        inputs[roiInputIndex].getFloat32Array().forEach((value) => roi.push(value));\n      } else if (attributes.coordinateTransformMode === 'tf_crop_and_resize') {\n        throw new Error('Resize requires RoI input to be specified when coordinateTransformMode is tfCropAndResize');\n      }\n\n      if (scalesInputIndex > 0 && inputs.length > scalesInputIndex && inputs[scalesInputIndex].dims.length > 0) {\n        inputs[scalesInputIndex].getFloat32Array().forEach((value) => scales.push(value));\n        if (scales.length !== 0 &&\n            (scales.length !== rank && (opsetVersion >= 18 && scales.length !== attributes.axes.length))) {\n          throw new Error(\n              'Resize requires scales input size to be same as input rank or axes size for opset 18 and up');\n        }\n        validateScales(scales, attributes);\n        if (attributes.axes.length > 0) {\n          updateScales(scales, attributes.axes, rank).forEach((value, index) => scales[index] = value);\n        }\n      }\n      if (sizesInputIndex > 0 && inputs.length > sizesInputIndex) {\n        inputs[sizesInputIndex].getBigInt64Array().forEach((value) => sizes.push(Number(value)));\n        if (sizes.length !== rank || (opsetVersion >= 18 && sizes.length === attributes.axes.length)) {\n          throw new Error('Resize requires sizes input size to be same as input rank or axes size for opset 18 and up');\n        }\n      }\n\n      if (attributes.axes.length > 0) {\n        if (scales.length !== attributes.axes.length) {\n          throw new Error('Resize requires \"scales\" input size to be of axes rank when axes attributes is specified');\n        }\n        if (sizes.length !== attributes.axes.length) {\n          throw new Error(\n              'Resize requires \"sizes\" input size to be of rank axes rank when axes attributes is specified');\n        }\n      }\n      if (typeof scales !== 'undefined' && typeof sizes !== 'undefined' && scales.length > 0 && sizes.length > rank) {\n        throw new Error('Resize requires only of scales or sizes to be specified');\n      }\n    };\n\nconst getOriginalCoordinateFromResizedCoordinate =\n    (coordinateTransferMode: CoordinateTransformMode, dType: string): string =>\n        `fn getOriginalCoordinateFromResizedCoordinate(xResized: u32, xScale: f32, lengthResized: u32,\n     lengthOriginal: u32, roiStart: f32, roiEnd: f32) -> ${dType} { ` +\n    (() => {\n          switch (coordinateTransferMode) {\n            case 'asymmetric':\n              return `return ${dType}(xResized) / ${dType}(xScale);`;\n            case 'pytorch_half_pixel':\n              return `if (lengthResized > 1) {\n                    return (${dType}(xResized) + 0.5) / ${dType}(xScale) - 0.5;\n                  } else {\n                    return 0.0;\n                  }`;\n            case 'tf_half_pixel_for_nn':\n              return `return (${dType}(xResized) + 0.5) / ${dType}(xScale);`;\n            case 'align_corners':\n              return `if (lengthResized == 1) {\n                    return 0.0;\n                  } else {\n                    // The whole part and the fractional part are calculated separately due to inaccuracy of floating\n                    // point division. As an example, f32(21) / f32(7) may evaluate to 2.99... instead of 3, causing an\n                    // offset-by-one error later in floor().\n                    let whole = ${dType}(xResized * (lengthOriginal - 1) / (lengthResized - 1));\n                    let fract =\n                        ${dType}(xResized * (lengthOriginal - 1) % (lengthResized - 1)) / ${dType}(lengthResized - 1);\n                    return whole + fract;\n                  }`;\n            case 'tf_crop_and_resize':\n              return `if (lengthResized > 1) {\n                    return ${dType}(roiStart) * ${dType}(lengthOriginal - 1) +\n                        (${dType}(xResized) * ${dType}(roiEnd - roiStart) * ${dType}(lengthOriginal - 1)) /\n                        ${dType}(lengthResized - 1);\n                  } else {\n                    return 0.5 * ${dType}(roiStart + roiEnd) * ${dType}(lengthOriginal - 1);\n                  }`;\n            case 'half_pixel_symmetric':\n              return `const outputWidth = ${dType}xScale * ${dType}(lengthResized);\n                  const adjustment = ${dType}(lengthResized) / outputWidth;\n                  const center = ${dType}(lengthOriginal) / 2;\n                  const offset = center * (1 - adjustment);\n                  return offset + ((${dType}(xResized) + 0.5) / ${dType}(xScale)) - 0.5;`;\n            case 'half_pixel':\n              return `return ((${dType}(xResized) + 0.5) / ${dType}(xScale)) - 0.5;`;\n            default:\n              throw new Error(`Coordinate transform mode ${coordinateTransferMode} is not supported`);\n          }\n        })() +\n    '}';\n\nconst getNearestPixelFromOriginal = (nearestMode: NearestMode, opsetVersion: number, dType: string): string =>\n    `fn getNearestPixelFromOriginal(xOriginal: ${dType}, isDownSample: bool) -> ${dType} {` + (() => {\n      switch (nearestMode) {\n        case 'round_prefer_ceil':\n          return 'if (fract(xOriginal) == 0.5) { \\\n            return ceil(xOriginal); \\\n          } else { \\\n            return round(xOriginal); \\\n          }';\n        case 'floor':\n          return 'return floor(xOriginal);';\n        case 'ceil':\n          return 'return ceil(xOriginal);';\n        case 'round_prefer_floor':\n          return 'if (fract(xOriginal) == 0.5) { \\\n                    return floor(xOriginal); \\\n                  } else { \\\n                    return round(xOriginal); \\\n                  }';\n        case 'simple':\n        default:\n          if (opsetVersion < 11) {\n            return 'if (isDownSample) \\\n                    { \\\n                      return ceil(xOriginal); \\\n                    } else { \\\n                      return xOriginal; \\\n                    }';\n          }\n          throw new Error(`Nearest mode ${nearestMode} is not supported`);\n      }\n    })() +\n    '}';\n\nconst updateRoI = (roi: readonly number[], axes: readonly number[], rank: number): number[] => {\n  const roiTmp = new Array(rank).fill(0).concat(new Array(rank).fill(1));\n  const roiLocal = roi.length === 0 ? roiTmp : roi.slice();\n  if (axes.length > 0) {\n    axes.forEach((v, i) => {\n      roiTmp[v] = roiLocal[i];\n      roiTmp[i + rank] = roiLocal[axes.length + i];\n    });\n    return roiTmp;\n  }\n  return roiLocal;\n};\n\nconst initOutputShape =\n    (inputShape: readonly number[], scales: readonly number[], sizes: readonly number[], axes: readonly number[]):\n        number[] => {\n          let outputShape: number[] = [];\n          if (sizes.length > 0) {\n            if (axes.length > 0) {\n              inputShape.forEach((v) => outputShape.push(v));\n              if (Math.max(...axes) > inputShape.length) {\n                throw new Error('axes is out of bound');\n              }\n              axes.forEach((v, i) => outputShape[v] = sizes[i]);\n            } else {\n              sizes.forEach((v) => outputShape.push(v));\n            }\n          } else {\n            if (scales.length === 0) {\n              throw new Error('Resize requires either scales or sizes.');\n            } else {\n              outputShape = inputShape.map((value, index) => Math.round(value * scales[index]));\n            }\n          }\n          return outputShape;\n        };\n\nconst adjustOutputShape = (inputShape: readonly number[], scales: number[], attributes: ResizeAttributes) => {\n  const scaleInPolicy = (() => {\n    switch (attributes.keepAspectRatioPolicy) {\n      case 'not_larger':\n        return attributes.axes.length > 0 ? Math.min(...attributes.axes.map(i => scales[i]), Number.MAX_VALUE) :\n                                            Math.min(...scales, Number.MAX_VALUE);\n      case 'not_smaller':\n        return attributes.axes.length > 0 ? Math.max(...attributes.axes.map(i => scales[i]), Number.MIN_VALUE) :\n                                            Math.max(...scales, Number.MIN_VALUE);\n      default:\n        throw new Error(`Keep aspect ratio policy ${attributes.keepAspectRatioPolicy} is not supported`);\n    }\n  })();\n  scales.fill(1.0, 0, scales.length);\n  const adjustedOutputShape = inputShape.slice();\n  if (attributes.axes.length > 0) {\n    attributes.axes.forEach((v) => scales[v] = scaleInPolicy);\n    attributes.axes.forEach((v) => adjustedOutputShape[v] = Math.round(inputShape[v] * scales[v]));\n  } else {\n    scales.fill(scaleInPolicy, 0, scales.length);\n    adjustedOutputShape.forEach((v, i) => adjustedOutputShape[i] = Math.round(v * scales[i]));\n  }\n  return adjustedOutputShape;\n};\n\nconst calculateOriginalIndicesFromOutputIndices =\n    (output: IndicesHelper, inputShape: readonly number[], outputShape: readonly number[], scalesLength: number,\n     roiLength: number): string => `\n    fn calculateOriginalIndicesFromOutputIndices(output_indices: ${output.type.indices}) -> array<${\n        output.type.value}, ${outputShape.length}> {\n      var original_indices: array<${output.type.value}, ${outputShape.length}>;\n      for (var i:u32 = 0; i < ${outputShape.length}; i++) {\n        var output_index = ${output.indicesGet('output_indices', 'i')};\n        var scale = ${getElementAt('uniforms.scales', 'i', scalesLength)};\n        var roi_low = ${getElementAt('uniforms.roi', 'i', roiLength)};\n        var roi_hi = ${getElementAt('uniforms.roi', `i + ${inputShape.length}`, roiLength)};\n        if (scale == 1.0) {\n          original_indices[i] = ${output.type.value}(output_index);\n        } else {\n          var input_shape_i = ${getElementAt('uniforms.input_shape', 'i', inputShape.length)};\n          var output_shape_i = ${getElementAt('uniforms.output_shape', 'i', outputShape.length)};\n          original_indices[i] = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i,\n                                                                           input_shape_i, roi_low, roi_hi);\n        }\n      }\n      return original_indices;\n    }`;\n\nconst calculateInputIndicesFromOutputIndices =\n    (input: IndicesHelper, output: IndicesHelper, inputShape: readonly number[], outputShape: readonly number[],\n     scalesLength: number, roiLength: number, useExtrapolation: boolean): string => `\n    fn calculateInputIndicesFromOutputIndices(output_indices: ${output.type.indices}) -> ${input.type.indices} {\n      var input_indices: ${input.type.indices};\n      for (var i:u32 = 0; i < ${outputShape.length}; i++) {\n        var output_index = ${output.indicesGet('output_indices', 'i')};\n        var input_index: u32;\n        var scale = ${getElementAt('uniforms.scales', 'i', scalesLength)};\n        if (scale == 1.0) {\n          input_index = output_index;\n        } else {\n          var roi_low = ${getElementAt('uniforms.roi', 'i', roiLength)};\n          var roi_hi = ${getElementAt('uniforms.roi', `i + ${inputShape.length}`, roiLength)};\n          var input_shape_i = ${getElementAt('uniforms.input_shape', 'i', inputShape.length)};\n          var output_shape_i = ${getElementAt('uniforms.output_shape', 'i', outputShape.length)};\n          var original_idx = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i,\n                                                                        input_shape_i, roi_low, roi_hi);\n          if (!${useExtrapolation} || (original_idx >= 0 && original_idx < ${output.type.value}(input_shape_i))) {\n            if (original_idx < 0) {\n              input_index = 0;\n            } else if (original_idx > ${output.type.value}(input_shape_i - 1)) {\n              input_index = input_shape_i - 1;\n            } else {\n              input_index = u32(getNearestPixelFromOriginal(original_idx, scale < 1));\n            }\n          } else {\n            input_index = u32(original_idx);\n          }\n        }\n        ${input.indicesSet('input_indices', 'i', ' input_index')}\n      }\n      return input_indices;\n    }`;\nconst checkInputIndices = (input: IndicesHelper, inputShape: readonly number[]): string => `\n    fn checkInputIndices(input_indices: ${input.type.indices}) -> bool {\n      for (var i:u32 = 0; i < ${inputShape.length}; i++) {\n        var input_index = ${input.indicesGet('input_indices', 'i')};\n        if (input_index < 0 || input_index >= ${getElementAt('uniforms.input_shape', 'i', inputShape.length)}) {\n          return false;\n        }\n      }\n      return true;\n    }`;\n\nconst setChannelAndBatchIndices =\n    (input: IndicesHelper, channelIdx: number, batchIdx: number, spacialDims: number): string =>\n        input.rank > spacialDims ? `\n    ${input.indicesSet('input_indices', channelIdx, 'channel')};\n    ${input.indicesSet('input_indices', batchIdx, 'batch')};\n` :\n                                   '';\n\nconst bilinearInterpolation =\n    (input: IndicesHelper, output: IndicesHelper, inputShape: readonly number[], useExtrapolation: boolean,\n     extrapolationValue: number): string => {\n      const isNchw = true;\n      const [batchIdx, heightIdx, widthIdx, channelIdx] =\n          inputShape.length === 2 ? [-1, 0, 1, -1] : (isNchw ? [0, 2, 3, 1] : [0, 1, 2, 3]);\n      const dType = input.type.value;\n      return `\n    fn getInputValue(batch: u32, channel: u32, row: u32, col: u32) -> ${dType} {\n      var input_indices: ${input.type.indices};\n      ${input.indicesSet('input_indices', heightIdx, `max(0, min(row, ${inputShape[heightIdx]} - 1))`)};\n      ${input.indicesSet('input_indices', widthIdx, `max(0, min(col, ${inputShape[widthIdx]} - 1))`)};\n      ${setChannelAndBatchIndices(input, channelIdx, batchIdx, 2)}\n      return ${input.getByIndices('input_indices')};\n    }\n\n    fn bilinearInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n      var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices);\n      var row:${dType} = originalIndices[${heightIdx}];\n      var col:${dType} = originalIndices[${widthIdx}];\n      ${\n          useExtrapolation ?\n              `if (row < 0 || row > (${inputShape[heightIdx]} - 1) || col < 0 || col > (${inputShape[widthIdx]} - 1)) {\n        return ${extrapolationValue};\n      }` :\n              ''};\n      row = max(0, min(row, ${inputShape[heightIdx]} - 1));\n      col = max(0, min(col, ${inputShape[widthIdx]} - 1));\n      var row1: u32 = u32(row);\n      var col1: u32 = u32(col);\n      var row2: u32 = u32(row + 1);\n      var col2: u32 = u32(col + 1);\n      var channel: u32 = ${inputShape.length > 2 ? `u32(originalIndices[${channelIdx}])` : '0'};\n      var batch: u32 =  ${inputShape.length > 2 ? `u32(originalIndices[${batchIdx}])` : '0'};\n      var x11: ${dType} = getInputValue(batch, channel, row1, col1);\n      var x12: ${dType} = getInputValue(batch, channel, row1, col2);\n      var x21: ${dType} = getInputValue(batch, channel, row2, col1);\n      var x22: ${dType} = getInputValue(batch, channel, row2, col2);\n      var dx1: ${dType} = abs(row - ${dType}(row1));\n      var dx2: ${dType} = abs(${dType}(row2) - row);\n      var dy1: ${dType} = abs(col - ${dType}(col1));\n      var dy2: ${dType} = abs(${dType}(col2) - col);\n      if (row1 == row2) {\n        dx1 = 0.5;\n        dx2 = 0.5;\n      }\n      if (col1 == col2) {\n        dy1 = 0.5;\n        dy2 = 0.5;\n      }\n      return (x11 * dx2 * dy2 + x12 * dx2 * dy1 + x21 * dx1 * dy2 + x22 * dx1 * dy1);\n    }`;\n    };\n\nconst bicubicInterpolation =\n    (input: IndicesHelper, output: IndicesHelper, inputShape: readonly number[], outputShape: readonly number[],\n     scales: readonly number[], roi: readonly number[], cubicCoeffA: number, useExtrapolation: boolean,\n     extrapolationValue: number, excludeOutside: boolean): string => {\n      const is2D = inputShape.length === 2;\n      const isNchw = true;\n      const [heightIdx, widthIdx] = is2D ? [0, 1] : isNchw ? [2, 3] : [1, 2];\n      const dType = input.type.value;\n      const createCubicInterpolationFunction = (idx: number): string => {\n        const direction = idx === heightIdx ? 'row' : 'col';\n        return `\n      fn ${direction}CubicInterpolation(input_indices: ${input.type.indices}, output_indices: ${\n            output.type.indices}) -> ${dType} {\n        var output_index = ${output.indicesGet('output_indices', idx)};\n        var originalIdx: ${dType} = getOriginalCoordinateFromResizedCoordinate(output_index, ${scales[idx]},\n        ${outputShape[idx]}, ${inputShape[idx]}, ${roi[idx]}, ${roi[idx]} + ${inputShape.length});\n        var fractOriginalIdx: ${dType} = originalIdx - floor(originalIdx);\n        var coefs = getCubicInterpolationCoefs(fractOriginalIdx);\n\n        if (${useExtrapolation} && (originalIdx < 0 || originalIdx > (${inputShape[idx]} - 1))) {\n          return ${extrapolationValue};\n        }\n        var data: array<${dType}, 4> = array<${dType}, 4>(0.0, 0.0, 0.0, 0.0);\n        for (var i: i32 = -1; i < 3; i++) {\n          var ${direction}: ${dType} = originalIdx + ${dType}(i);\n          if (${direction} < 0 || ${direction} >= ${inputShape[idx]}) {\n            ${(() => {\n          if (excludeOutside) {\n            return `coefs[i + 1] = 0.0;\n                        continue;`;\n          } else if (useExtrapolation) {\n            return `return ${extrapolationValue};`;\n          } else {\n            return `${direction} = max(0, min(${direction}, ${inputShape[idx]} - 1));`;\n          }\n        })()};\n          }\n        var input_indices_copy: ${input.type.indices} = input_indices;\n          ${input.indicesSet('input_indices_copy', idx, `u32(${direction})`)};\n          data[i + 1] = ${\n            idx === heightIdx ? input.getByIndices('input_indices_copy') :\n                                'rowCubicInterpolation(input_indices_copy, output_indices)'};\n        }\n        return cubicInterpolation1D(data, coefs);\n      }`;\n      };\n\n      return `\n    ${createCubicInterpolationFunction(heightIdx)};\n    ${createCubicInterpolationFunction(widthIdx)};\n  fn getCubicInterpolationCoefs(s: ${dType}) -> array<${dType}, 4> {\n    var absS = abs(s);\n    var coeffs: array<${dType}, 4> = array<${dType}, 4>(0.0, 0.0, 0.0, 0.0);\n    var oneMinusAbsS: ${dType} = 1.0 - absS;\n    var twoMinusAbsS: ${dType} = 2.0 - absS;\n    var onePlusAbsS: ${dType} = 1.0 + absS;\n    coeffs[0] = ((${cubicCoeffA} * onePlusAbsS - 5 * ${cubicCoeffA}) * onePlusAbsS + 8 * ${\n          cubicCoeffA}) * onePlusAbsS - 4 * ${cubicCoeffA};\n    coeffs[1] = ((${cubicCoeffA} + 2) * absS - (${cubicCoeffA} + 3)) * absS * absS + 1;\n    coeffs[2] = ((${cubicCoeffA} + 2) * oneMinusAbsS - (${cubicCoeffA} + 3)) * oneMinusAbsS * oneMinusAbsS + 1;\n    coeffs[3] = ((${cubicCoeffA} * twoMinusAbsS - 5 * ${cubicCoeffA}) * twoMinusAbsS + 8 * ${\n          cubicCoeffA}) * twoMinusAbsS - 4 * ${cubicCoeffA};\n    return coeffs;\n  }\n\n  fn cubicInterpolation1D(x: array<${dType}, 4>, coefs: array<${dType}, 4>) -> ${dType} {\n    var coefsSum: ${dType} = coefs[0] + coefs[1] + coefs[2] + coefs[3];\n    return (x[0] * coefs[0] + x[1] * coefs[1]+ x[2] * coefs[2]+ x[3] * coefs[3]) / coefsSum;\n  }\n\n  fn bicubicInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n    var input_indices: ${input.type.indices} = output_indices;\n    return colCubicInterpolation(input_indices, output_indices);\n  }\n    `;\n    };\n\nconst trilinearInterpolation =\n    (input: IndicesHelper, output: IndicesHelper, inputShape: readonly number[], useExtrapolation: boolean,\n     extrapolationValue: number): string => {\n      const isNchw = true;\n      const [batchIdx, depthIdx, heightIdx, widthIdx, channelIdx] =\n          inputShape.length === 3 ? [-1, 0, 1, 2, -1] : (isNchw ? [0, 2, 3, 4, 1] : [0, 1, 2, 3, 4]);\n      const dType = input.type.value;\n      return `\n    fn getInputValue(batch: u32, channel: u32, depth:u32, height: u32, width: u32) -> ${dType} {\n      var input_indices: ${input.type.indices};\n      ${input.indicesSet('input_indices', depthIdx, `max(0, min(depth, ${inputShape[depthIdx]} - 1))`)};\n      ${input.indicesSet('input_indices', heightIdx, `max(0, min(height, ${inputShape[heightIdx]} - 1))`)};\n      ${input.indicesSet('input_indices', widthIdx, `max(0, min(width, ${inputShape[widthIdx]} - 1))`)};\n      ${setChannelAndBatchIndices(input, channelIdx, batchIdx, 3)}\n      return ${input.getByIndices('input_indices')};\n    }\n\n    fn trilinearInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n      var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices);\n      var depth:${dType} = originalIndices[${depthIdx}];\n      var height:${dType} = originalIndices[${heightIdx}];\n      var width:${dType} = originalIndices[${widthIdx}];\n      ${\n          useExtrapolation ? `if (depth < 0 || depth > (${inputShape[depthIdx]} - 1) || height < 0 || height > (${\n                                 inputShape[heightIdx]} - 1) || width < 0 || (width > ${inputShape[widthIdx]} - 1)) {\n      return ${extrapolationValue};\n        }` :\n                             ''};\n\n    depth = max(0, min(depth, ${inputShape[depthIdx]} - 1));\n      height = max(0, min(height, ${inputShape[heightIdx]} - 1));\n      width = max(0, min(width, ${inputShape[widthIdx]} - 1));\n      var depth1: u32 = u32(depth);\n      var height1: u32 = u32(height);\n      var width1: u32 = u32(width);\n      var depth2: u32 = u32(depth + 1);\n      var height2: u32 = u32(height + 1);\n      var width2: u32 = u32(width + 1);\n      var channel: u32 = ${inputShape.length > 3 ? `u32(originalIndices[${channelIdx}])` : '0'};\n      var batch: u32 =  ${inputShape.length > 3 ? `u32(originalIndices[${batchIdx}])` : '0'};\n\n      var x111: ${dType} = getInputValue(batch, channel, depth1, height1, width1);\n      var x112: ${dType} = getInputValue(batch, channel, depth1, height1, width2);\n      var x121: ${dType} = getInputValue(batch, channel, depth1, height2, width1);\n      var x122: ${dType} = getInputValue(batch, channel, depth1, height2, width2);\n      var x211: ${dType} = getInputValue(batch, channel, depth2, height1, width1);\n      var x212: ${dType} = getInputValue(batch, channel, depth2, height1, width2);\n      var x221: ${dType} = getInputValue(batch, channel, depth2, height2, width1);\n      var x222: ${dType} = getInputValue(batch, channel, depth2, height2, width2);\n      var dx1: ${dType} = abs(depth - ${dType}(depth1));\n      var dx2: ${dType} = abs(${dType}(depth2) - depth);\n      var dy1: ${dType} = abs(height - ${dType}(height1));\n      var dy2: ${dType} = abs(${dType}(height2) - height);\n      var dz1: ${dType} = abs(width - ${dType}(width1));\n      var dz2: ${dType} = abs(${dType}(width2) - width);\n      if (depth1 == depth2) {\n        dx1 = 0.5;\n        dx2 = 0.5;\n      }\n      if (height1 == height2) {\n        dy1 = 0.5;\n        dy2 = 0.5;\n      }\n      if (width1 == width2) {\n        dz1 = 0.5;\n        dz2 = 0.5;\n      }\n      return (x111 * dx2 * dy2 * dz2 + x112 * dx2 * dy2 * dz1 + x121 * dx2 * dy1 *dz2 + x122 * dx2 * dy1 * dz1 +\n              x211 * dx1 * dy2 * dz2 + x212 * dx1 * dy2 * dz1 + x221 * dx1 * dy1 *dz2 + x222 * dx1 * dy1 * dz1);\n    }`;\n    };\n\nconst createResizeProgramInfo =\n    (inputTensor: TensorView, attributes: ResizeAttributes, opsetVersion: number, scalesInput: readonly number[],\n     sizes: readonly number[], roiInput: readonly number[]): ProgramInfo => {\n      const inputShape = inputTensor.dims;\n      const roi = updateRoI(roiInput, attributes.axes, inputShape.length);\n\n      let outputShape = initOutputShape(inputShape, scalesInput, sizes, attributes.axes);\n      let scales = scalesInput.slice();\n      if (scalesInput.length === 0) {\n        scales = inputShape.map((value, index) => value === 0 ? 1.0 : outputShape[index] / value);\n        if (attributes.keepAspectRatioPolicy !== 'stretch') {\n          outputShape = adjustOutputShape(inputShape, scales, attributes);\n        }\n      }\n      const output = outputVariable('output', inputTensor.dataType, outputShape.length);\n      const input = inputVariable('input', inputTensor.dataType, inputShape.length);\n      const outputSize = ShapeUtil.size(outputShape);\n      const noScale = inputShape.length === outputShape.length && inputShape.every((d, i) => d === outputShape[i]);\n      const useExtrapolation = attributes.coordinateTransformMode === 'tf_crop_and_resize';\n      const extrapolationValue = attributes.extrapolationValue;\n      const dataType = input.type.value;\n      const getShaderSource = (shaderHelper: ShaderHelper) => `\n      ${noScale ? '' : `\n      ${getOriginalCoordinateFromResizedCoordinate(attributes.coordinateTransformMode, dataType)};\n      ${(() => {\n        switch (attributes.mode) {\n          case 'nearest':\n            return `\n              ${checkInputIndices(input, inputShape)};\n              ${getNearestPixelFromOriginal(attributes.nearestMode, opsetVersion, dataType)};\n              ${\n                calculateInputIndicesFromOutputIndices(\n                    input, output, inputShape, outputShape, scales.length, roi.length, useExtrapolation)};\n              `;\n          case 'linear':\n            return `\n              ${calculateOriginalIndicesFromOutputIndices(output, inputShape, outputShape, scales.length, roi.length)};\n              ${(() => {\n              if (inputShape.length === 2 || inputShape.length === 4) {\n                return `${bilinearInterpolation(input, output, inputShape, useExtrapolation, extrapolationValue)}`;\n              } else if (inputShape.length === 3 || inputShape.length === 5) {\n                return `${trilinearInterpolation(input, output, inputShape, useExtrapolation, extrapolationValue)}`;\n              } else {\n                throw Error('Linear mode only supports input dims 2, 3, 4 and 5 are supported in linear mode.');\n              }\n            })()};\n            `;\n          case 'cubic':\n            return `\n            ${(() => {\n              if (inputShape.length === 2 || inputShape.length === 4) {\n                return `${\n                    bicubicInterpolation(\n                        input, output, inputShape, outputShape, scales, roi, attributes.cubicCoeffA, useExtrapolation,\n                        attributes.extrapolationValue, attributes.excludeOutside)}`;\n              } else {\n                throw Error('Cubic mode only supports input dims 2 and 4 are supported in linear mode.');\n              }\n            })()};\n            `;\n          default:\n            throw Error('Invalid resize mode');\n        }\n      })()};\n      `}\n      ${\n          shaderHelper.registerUniform('output_size', 'u32')\n              .registerUniform('scales', 'f32', scales.length)\n              .registerUniform('roi', 'f32', roi.length)\n              .declareVariables(input, output)}\n      ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n        ${noScale ? 'output[global_idx] = input[global_idx];' : `\n        let output_indices = ${output.offsetToIndices('global_idx')};\n        var input_indices: ${input.type.indices};\n        ${(() => {\n        switch (attributes.mode) {\n          case 'nearest':\n            return `input_indices = calculateInputIndicesFromOutputIndices(output_indices);\n                if (checkInputIndices(input_indices)) {\n                  output[global_idx] = ${input.getByIndices('input_indices')};\n                } else {\n                  output[global_idx] = ${attributes.extrapolationValue};\n                }`;\n          case 'linear':\n            return `output[global_idx] = ${\n                (inputShape.length === 2 || inputShape.length === 4) ? 'bilinearInterpolation' :\n                                                                       'trilinearInterpolation'}(output_indices);`;\n          case 'cubic':\n            return 'output[global_idx] = bicubicInterpolation(output_indices);';\n          default:\n            throw Error(`Unsupported resize mode: ${attributes.mode}`);\n        }\n      })()};\n`}\n      }`;\n\n      return {\n        name: 'Resize',\n        shaderCache: {\n          hint: `${attributes.cacheKey}|${opsetVersion}|${scales.length > 0 ? scales : ''}|${\n              sizes.length > 0 ? sizes : ''}|${roi.length > 0 ? roi : ''}|${noScale}|${inputShape}`,\n          inputDependencies: ['rank']\n        },\n        getShaderSource,\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputTensor.dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms: [\n            {type: DataType.uint32, data: outputSize}, {type: DataType.float, data: scales},\n            {type: DataType.float, data: roi}, ...createTensorShapeVariables(inputShape, outputShape)\n          ]\n        })\n      };\n    };\n\nconst getOpsetVersionFromCustomDataBuffer = (context: ComputeContext): number => {\n  const customDataBuffer = context.customDataBuffer;\n  const customDataBuffer32 = new Uint32Array(customDataBuffer, customDataBuffer.byteOffset, 1);\n  const opsetVersion = customDataBuffer32[0];\n  return opsetVersion;\n};\n\nexport const resize = (context: ComputeContext, attributes: ResizeAttributes): void => {\n  const scales: number[] = [];\n  const sizes: number[] = [];\n  const roi: number[] = [];\n\n  // Note that scales in resize are always f32. roi can be f32 or f16.\n  // TODO: Currently this code does not support f16 for roi when passed as optional input.\n\n  const opsetVersion = getOpsetVersionFromCustomDataBuffer(context);\n  if (attributes.antialias !== 0) {\n    throw Error('Only default value (0) for Antialias attribute is supported');\n  }\n  validateInputs(context.inputs, attributes, opsetVersion, scales, sizes, roi);\n  context.compute(\n      createResizeProgramInfo(context.inputs[0], attributes, opsetVersion, scales, sizes, roi), {inputs: [0]});\n};\n\nexport const parseResizeAttributes = (attributes: Record<string, unknown>): ResizeAttributes => {\n  const antialias = attributes.antialias as number;\n  const axes = attributes.axes as number[];\n  const coordinateTransformMode: CoordinateTransformMode =\n      attributes.coordinateTransformMode as CoordinateTransformMode;\n  const cubicCoeffA = attributes.cubicCoeffA as number;\n  const excludeOutside = attributes.excludeOutside as number !== 0;\n  const extrapolationValue = attributes.extrapolationValue as number;\n  const keepAspectRatioPolicy: KeepAspectRatioPolicy = attributes.keepAspectRatioPolicy as KeepAspectRatioPolicy;\n  const mode: Mode = attributes.mode as Mode;\n  // If nearestMode is not specified, use simple mode.\n  const nearestMode: NearestMode = (attributes.nearestMode === '' ? 'simple' : attributes.nearestMode) as NearestMode;\n  return createAttributeWithCacheKey({\n    antialias,\n    axes,\n    coordinateTransformMode,\n    cubicCoeffA,\n    excludeOutside,\n    extrapolationValue,\n    keepAspectRatioPolicy,\n    mode,\n    nearestMode\n  });\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper, WORKGROUP_SIZE} from './common';\n\nexport interface RotaryEmbeddingAttributes {\n  readonly interleaved: boolean;\n  readonly numHeads: number;\n  readonly rotaryEmbeddingDim: number;\n  readonly scale: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: RotaryEmbeddingAttributes): void => {\n  const [input, positionIds, cosCache, sinCache] = inputs;\n  const {numHeads, rotaryEmbeddingDim} = attributes;\n\n  if (input.dims.length !== 3 && input.dims.length !== 4) {\n    throw new Error(`Input 'x' is expected to have 3 or 4 dimensions, got ${input.dims.length}`);\n  }\n  if (!ShapeUtil.areEqual(positionIds.dims, []) && !ShapeUtil.areEqual(positionIds.dims, [1]) &&\n      positionIds.dims.length !== 2) {\n    throw new Error(`Input 'position_ids' is expected to have 0, 1, or 2 dimensions, got ${positionIds.dims.length}`);\n  }\n  if (cosCache.dims.length !== 2) {\n    throw new Error(`Input 'cos_cache' is expected to have 2 dimensions, got ${cosCache.dims.length}`);\n  }\n  if (sinCache.dims.length !== 2) {\n    throw new Error(`Input 'sin_cache' is expected to have 2 dimensions, got ${sinCache.dims.length}`);\n  }\n  if (!ShapeUtil.areEqual(cosCache.dims, sinCache.dims)) {\n    throw new Error('Inputs \\'cos_cache\\' and \\'sin_cache\\' are expected to have the same shape');\n  }\n\n  if (rotaryEmbeddingDim > 0 && numHeads === 0) {\n    throw new Error('num_heads must be provided if rotary_embedding_dim is specified');\n  }\n\n  const batchSize = input.dims[0];\n  const sequenceLength = input.dims[input.dims.length - 2];\n  const maxSequenceLength = cosCache.dims[0];\n  const hiddenSize = ShapeUtil.sizeFromDimension(input.dims, 1) / sequenceLength;\n  const headSize = rotaryEmbeddingDim === 0 ? cosCache.dims[1] * 2 : hiddenSize / numHeads;\n  if (rotaryEmbeddingDim > headSize) {\n    throw new Error('rotary_embedding_dim must be less than or equal to head_size');\n  }\n\n  if (positionIds.dims.length === 2) {\n    if (batchSize !== positionIds.dims[0]) {\n      throw new Error(`Input 'position_ids' dimension 0 should be of size batch_size, got ${positionIds.dims[0]}`);\n    }\n    if (sequenceLength !== positionIds.dims[1]) {\n      throw new Error(`Input 'position_ids' dimension 1 should be of size sequence_length, got ${positionIds.dims[1]}`);\n    }\n  }\n\n  if (headSize / 2 !== cosCache.dims[1] && rotaryEmbeddingDim / 2 !== cosCache.dims[1]) {\n    throw new Error(`Input 'cos_cache' dimension 1 should be same as head_size / 2 or rotary_embedding_dim / 2, got ${\n        cosCache.dims[1]}`);\n  }\n\n  if (sequenceLength > maxSequenceLength) {\n    throw new Error('Updating cos_cache and sin_cache in RotaryEmbedding is not currently supported');\n  }\n};\n\nconst createRotaryEmbeddingProgramInfo =\n    (inputs: readonly TensorView[], attributes: RotaryEmbeddingAttributes): ProgramInfo => {\n      const {interleaved, numHeads, rotaryEmbeddingDim, scale} = attributes;\n      const batchSize = inputs[0].dims[0];\n      const batchStride = ShapeUtil.sizeFromDimension(inputs[0].dims, 1);\n      const sequenceLength = inputs[0].dims[inputs[0].dims.length - 2];\n      const hiddenSize = batchStride / sequenceLength;\n      const halfRotaryEmbeddingDim = inputs[2].dims[1];\n      const headSize = rotaryEmbeddingDim === 0 ? halfRotaryEmbeddingDim * 2 : hiddenSize / numHeads;\n\n      // Rotary embeddings will be calculated in a pair-wise fashion. In accordance, use the shape\n      // [batch size, sequence length, num of heads, num of pairs to rotate + num of dims to copy]\n      // to unfold the global index in shader.\n      const globalShape =\n          new Array<number>(batchSize, sequenceLength, hiddenSize / headSize, headSize - halfRotaryEmbeddingDim);\n      const globalStrides = ShapeUtil.computeStrides(globalShape);\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.float, data: scale},\n        {type: DataType.uint32, data: globalShape},\n        {type: DataType.uint32, data: globalStrides},\n\n        // strides for addressing the input/output tensor, in permutated order to align with the unfolded global index,\n        // i.e. BSNH\n        ...(inputs[0].dims.length === 3 ?\n                new Array<ProgramUniform>({type: DataType.uint32, data: [batchStride, hiddenSize, headSize, 1]}) :\n                []),\n        ...(inputs[0].dims.length === 4 ?\n                new Array<ProgramUniform>(\n                    {type: DataType.uint32, data: [batchStride, headSize, sequenceLength * headSize, 1]}) :\n                []),\n\n        ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims, inputs[2].dims, inputs[3].dims, inputs[0].dims),\n      ];\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const input = inputVariable('input', inputs[0].dataType, inputs[0].dims.length);\n        const positionIds = inputVariable('position_ids', inputs[1].dataType, inputs[1].dims.length);\n        const cosCache = inputVariable('cos_cache', inputs[2].dataType, inputs[2].dims.length);\n        const sinCache = inputVariable('sin_cache', inputs[3].dataType, inputs[3].dims.length);\n        const output = outputVariable('output', inputs[0].dataType, inputs[0].dims.length);\n\n        shaderHelper.registerUniforms([\n          {name: 'scale', type: 'f32'},\n          {name: 'global_shape', type: 'u32', length: globalShape.length},\n          {name: 'global_strides', type: 'u32', length: globalStrides.length},\n          {name: 'input_output_strides', type: 'u32', length: globalStrides.length},\n        ]);\n\n        return `\n        ${shaderHelper.declareVariables(input, positionIds, cosCache, sinCache, output)}\n\n        ${shaderHelper.mainStart(WORKGROUP_SIZE)}\n          let half_rotary_emb_dim = uniforms.${cosCache.name}_shape[1];\n          let bsnh = global_idx / uniforms.global_strides % uniforms.global_shape;\n          let size = uniforms.global_shape[0] * uniforms.global_strides[0];\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('size')}\n\n          if (bsnh[3] < half_rotary_emb_dim) {\n            let position_ids_idx =\n                ${positionIds.broadcastedIndicesToOffset('bsnh.xy', outputVariable('', positionIds.type.tensor, 2))};\n            let position_id =\n                u32(${positionIds.getByOffset('position_ids_idx')}) + select(0, bsnh[1], position_ids_idx == 0);\n            let i = dot(bsnh, uniforms.input_output_strides) + select(0, bsnh[3], ${interleaved});\n            let j = i + select(half_rotary_emb_dim, 1, ${interleaved});\n            let re = ${input.getByOffset('i')} * ${cosCache.get('position_id', 'bsnh[3]')} -\n                ${input.getByOffset('j')} * ${sinCache.get('position_id', 'bsnh[3]')};\n            ${output.setByOffset('i', 're')}\n            let im = ${input.getByOffset('i')} * ${sinCache.get('position_id', 'bsnh[3]')} +\n                ${input.getByOffset('j')} * ${cosCache.get('position_id', 'bsnh[3]')};\n            ${output.setByOffset('j', 'im')}\n          } else {\n            let k = dot(bsnh, uniforms.input_output_strides) + half_rotary_emb_dim;\n            ${output.setByOffset('k', input.getByOffset('k'))}\n          }\n        }`;\n      };\n\n      return {\n        name: 'RotaryEmbedding',\n        shaderCache: {\n          hint: createAttributeWithCacheKey({\n                  interleaved,\n                }).cacheKey,\n          inputDependencies: ['rank', 'rank', 'rank', 'rank'],\n        },\n        getShaderSource,\n        getRunData: () => ({\n          outputs: [{dims: inputs[0].dims, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: Math.ceil(ShapeUtil.size(globalShape) / WORKGROUP_SIZE)},\n          programUniforms,\n        }),\n      };\n    };\n\nexport const rotaryEmbedding = (context: ComputeContext, attributes: RotaryEmbeddingAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  context.compute(createRotaryEmbeddingProgramInfo(context.inputs, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {castToF32, fillVector, getMaxComponents, inputVariable, outputVariable, ShaderHelper, sumVector, tensorTypeToWsglStorageType, UniformsArrayType} from './common';\n\nexport interface SkipLayerNormAttributes {\n  simplified: boolean;\n  epsilon: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length < 3) {\n    throw new Error('layerNorm requires at least 3 inputs.');\n  }\n\n  const input: TensorView = inputs[0];\n  const skip: TensorView = inputs[1];\n  const gamma: TensorView = inputs[2];\n\n  if (input.dataType !== skip.dataType || input.dataType !== gamma.dataType) {\n    throw new Error('All inputs must have the same data type');\n  }\n\n  if (input.dims.length !== 3 && input.dims.length !== 2) {\n    throw new Error('Input must be 2D or 3D');\n  }\n\n  if (skip.dims.length !== 3 && skip.dims.length !== 2) {\n    throw new Error('Skip must be 2D or 3D');\n  }\n\n  const hiddenSize = input.dims[input.dims.length - 1];\n  const sequenceLength = input.dims[input.dims.length - 2];\n  if (skip.dims[skip.dims.length - 1] !== hiddenSize) {\n    throw new Error('Skip must have the same hidden size as input');\n  }\n  if (skip.dims[skip.dims.length - 2] !== sequenceLength) {\n    throw new Error('Skip must have the same sequence length as input');\n  }\n\n  if (gamma.dims.length !== 1) {\n    throw new Error('Gamma must be 1D');\n  }\n  if (gamma.dims[gamma.dims.length - 1] !== hiddenSize) {\n    throw new Error('Gamma must have the same hidden size as input');\n  }\n  if (inputs.length > 3) {\n    const beta: TensorView = inputs[3];\n    if (beta.dims.length !== 1) {\n      throw new Error('Beta must be 1D');\n    }\n    if (beta.dims[beta.dims.length - 1] !== hiddenSize) {\n      throw new Error('Beta must have the same hidden size as input');\n    }\n  }\n\n  if (inputs.length > 4) {\n    const bias: TensorView = inputs[4];\n    if (bias.dims.length !== 1) {\n      throw new Error('Bias must be 1D');\n    }\n    if (bias.dims[bias.dims.length - 1] !== hiddenSize) {\n      throw new Error('Bias must have the same hidden size as input');\n    }\n  }\n};\n\nconst createSkipLayerNormProgramInfo =\n    (inputs: readonly TensorView[], attributes: SkipLayerNormAttributes, outputCount: number, isTraining: boolean):\n        ProgramInfo => {\n          const simplified = attributes.simplified;\n\n          const inputShape = inputs[0].dims;\n          const inputSize = ShapeUtil.size(inputShape);\n          const outputShape = inputShape;\n          const outputSize = inputSize;\n          const hiddenSize = inputShape.slice(-1)[0];\n          const meanInvStdDevDim = isTraining ? inputShape.slice(0, -1).concat(1) : [];\n          const hasBetaInput = !simplified && inputs.length > 3;\n          const hasBiasInput = inputs.length > 4;\n          const hasMeanOutput = isTraining && outputCount > 1;\n          const hasInvStdDevOutput = isTraining && outputCount > 2;\n          const hasInputSkipBiasSumOutput = outputCount > 3;\n\n          const components = getMaxComponents(hiddenSize);\n\n          const programUniforms: ProgramUniform[] = [\n            {type: DataType.uint32, data: outputSize},\n            {type: DataType.uint32, data: components},\n            {type: DataType.uint32, data: hiddenSize},\n            {type: DataType.float, data: attributes.epsilon},\n          ];\n          const getShaderSource = (shaderHelper: ShaderHelper) => {\n            const uniformsArray: UniformsArrayType = [\n              {name: 'output_size', type: 'u32'},\n              {name: 'components', type: 'u32'},\n              {name: 'hidden_size', type: 'u32'},\n              {name: 'epsilon', type: 'f32'},\n            ];\n            const variables = [\n              inputVariable('x', inputs[0].dataType, inputs[0].dims, components),\n              inputVariable('skip', inputs[1].dataType, inputs[1].dims, components),\n              inputVariable('gamma', inputs[2].dataType, inputs[2].dims, components),\n            ];\n            if (hasBetaInput) {\n              variables.push(inputVariable('beta', inputs[3].dataType, inputs[3].dims, components));\n            }\n            if (hasBiasInput) {\n              variables.push(inputVariable('bias', inputs[4].dataType, inputs[4].dims, components));\n            }\n            variables.push(outputVariable('output', inputs[0].dataType, outputShape, components));\n            if (hasMeanOutput) {\n              variables.push(outputVariable('mean_output', DataType.float, meanInvStdDevDim));\n            }\n            if (hasInvStdDevOutput) {\n              variables.push(outputVariable('inv_std_output', DataType.float, meanInvStdDevDim));\n            }\n            if (hasInputSkipBiasSumOutput) {\n              variables.push(outputVariable('input_skip_bias_sum', inputs[0].dataType, outputShape, components));\n            }\n            const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n            return `\n\n      ${shaderHelper.registerUniforms(uniformsArray).declareVariables(...variables)}\n\n      ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size / uniforms.hidden_size')}\n        let hidden_size_vectorized: u32 = uniforms.hidden_size / uniforms.components;\n        let offset = global_idx * hidden_size_vectorized;\n        var sum = ${fillVector('f32', components)};\n        var squareSum = ${fillVector('f32', components)};\n        for (var i: u32 = 0; i < hidden_size_vectorized; i++) {\n          let skip_value = skip[offset + i];\n          let bias_value = ${hasBiasInput ? 'bias[i]' : dataType + '(0.0)'};\n          let input_value = x[offset + i];\n          let value = input_value + skip_value + bias_value;\n          ${hasInputSkipBiasSumOutput ? 'input_skip_bias_sum[offset + i] = value;' : ''}\n          output[offset + i] = value;\n          let f32_value = ${castToF32(dataType, components, 'value')};\n          sum += f32_value;\n          squareSum += f32_value * f32_value;\n        }\n        let mean = ${sumVector('sum', components)} / f32(uniforms.hidden_size);\n        let inv_std_dev = inverseSqrt(${sumVector('squareSum', components)} / f32(uniforms.hidden_size) ${\n                simplified ? '' : '- mean * mean'} + uniforms.epsilon);\n        ${hasMeanOutput ? 'mean_output[global_idx] = mean;' : ''}\n        ${hasInvStdDevOutput ? 'inv_std_output[global_idx] = inv_std_dev;' : ''}\n        for (var i: u32 = 0; i < hidden_size_vectorized; i++) {\n          output[offset + i] = (output[offset + i] ${simplified ? '' : `- ${dataType}(mean)`}) * ${\n                dataType}(inv_std_dev) * gamma[i] ${hasBetaInput ? '+ beta[i]' : ''};\n        }\n      }`;\n          };\n          const outputs = [{dims: outputShape, dataType: inputs[0].dataType}];\n          if (outputCount > 1) {\n            outputs.push({dims: meanInvStdDevDim, dataType: DataType.float});\n          }\n          if (outputCount > 2) {\n            outputs.push({dims: meanInvStdDevDim, dataType: DataType.float});\n          }\n          if (outputCount > 3) {\n            outputs.push({dims: inputShape, dataType: inputs[0].dataType});\n          }\n          return {\n            name: 'SkipLayerNormalization',\n            shaderCache: {\n              hint: `${components};${hasMeanOutput};${hasInvStdDevOutput};${hasInputSkipBiasSumOutput}`,\n              inputDependencies: inputs.map((_input, _index) => 'type')\n            },\n            getShaderSource,\n            getRunData: () => ({outputs, dispatchGroup: {x: Math.ceil(outputSize / hiddenSize / 64)}, programUniforms}),\n          };\n        };\n\nexport const skipLayerNorm = (context: ComputeContext, attributes: SkipLayerNormAttributes): void => {\n  // TODO: initialize isTraining from ComputeContext\n  const isTraining = false;\n  validateInputs(context.inputs);\n  // Mean and InvStdDev are only used in training mode and are not required for inference.\n  // They are added here for completeness only.\n  const outputs = [0];\n  if (context.outputCount > 1) {\n    outputs.push(isTraining ? 1 : -3);\n  }\n  if (context.outputCount > 2) {\n    outputs.push(isTraining ? 2 : -3);\n  }\n  if (context.outputCount > 3) {\n    outputs.push(3);\n  }\n  context.compute(\n      createSkipLayerNormProgramInfo(context.inputs, attributes, context.outputCount, isTraining), {outputs});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform, TensorInfo} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, IndicesHelper, inputVariable, outputVariable, ShaderHelper, UniformsArrayType} from './common';\n\nexport interface SliceAttributes extends AttributeWithCacheKey {\n  readonly starts: number[];\n  readonly ends: number[];\n  readonly axes: number[];\n}\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: SliceAttributes): void => {\n  if (!inputs || inputs.length < 1) {\n    throw new Error('too few inputs');\n  }\n  if (attributes.axes.length !== 0) {\n    if (attributes.axes.length !== attributes.starts.length || attributes.axes.length !== attributes.ends.length) {\n      throw new Error('axes, starts and ends must have the same length');\n    }\n  } else if (attributes.starts.length !== attributes.ends.length) {\n    throw new Error('starts and ends must have the same length');\n  }\n  inputs.slice(1).forEach((_, idx) => {\n    if (inputs[idx + 1].dataType !== DataType.int32 && inputs[idx + 1].dataType !== DataType.int64) {\n      throw new Error(`Input ${idx} must be an array of int32 or int64`);\n    }\n  });\n};\n\nconst readInput = (inputs: readonly TensorView[], idx: number): number[] => {\n  const input: number[] = [];\n  if (inputs.length > idx) {\n    if (inputs[idx].dataType === DataType.int64) {\n      inputs[idx].getBigInt64Array().forEach(v => input.push(Number(v)));\n    } else if (inputs[idx].dataType === DataType.int32) {\n      inputs[idx].getInt32Array().forEach(v => input.push(Number(v)));\n    } else {\n      throw new Error(`Input ${idx} must be an array of int32 or int64`);\n    }\n  }\n  return input;\n};\n\nconst createSliceAttributesFromInputs =\n    (inputs: readonly TensorView[], attributes: SliceAttributes): SliceAttributes => {\n      if (inputs.length > 1) {\n        const starts: number[] = readInput(inputs, 1);\n        const ends: number[] = readInput(inputs, 2);\n        let axes: number[] = readInput(inputs, 3);\n        if (axes.length === 0) {\n          axes = [...Array(inputs[0].dims.length).keys()];\n        }\n        return createAttributeWithCacheKey({starts, ends, axes});\n      } else {\n        return attributes;\n      }\n    };\n\nconst fixStartEndValues =\n    (value: number, index: number, inputShape: readonly number[], axes: readonly number[], steps: readonly number[]):\n        number => {\n          let newValue = value;\n          if (value < 0) {\n            newValue += inputShape[axes[index]];\n          }\n          if (steps[index] < 0) {\n            return Math.max(0, Math.min(newValue, inputShape[axes[index]] - 1));\n          } else {\n            return Math.max(0, Math.min(newValue, inputShape[axes[index]]));\n          }\n        };\n\nconst calculateInputIndicesImpl =\n    (input: IndicesHelper, output: IndicesHelper, inputShape: readonly number[]): string =>\n        `fn calculateInputIndices(output_indices: ${output.type.indices}) -> ${input.type.indices} {\n          var input_indices: ${input.type.indices};\n          var carry = 0u;\n          for (var i = ${inputShape.length}; i >= 0; i--) {\n            let input_shape_i = ${getElementAt('uniforms.input_shape', 'i', inputShape.length)};\n            let steps_i = ${getElementAt('uniforms.steps', 'i', inputShape.length)};\n            let signs_i = ${getElementAt('uniforms.signs', 'i', inputShape.length)};\n            let starts_i = ${getElementAt('uniforms.starts', 'i', inputShape.length)};\n            var output_index = ${output.indicesGet('output_indices', 'i')};\n            var input_index = output_index * steps_i + starts_i + carry;\n            carry = input_index / input_shape_i;\n            input_index = input_index % input_shape_i;\n            if (signs_i < 0) {\n              input_index = input_shape_i - input_index - 1u + starts_i;\n            }\n            ${input.indicesSet('input_indices', 'i', 'input_index')};\n          }\n          return input_indices;\n      }`;\n\nconst createSliceProgramInfo = (inputs: readonly TensorView[], attributes: SliceAttributes): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const inputSize = ShapeUtil.size(inputShape);\n  const axes = (attributes.axes.length > 0) ? ShapeUtil.normalizeAxes(attributes.axes, inputShape.length) :\n                                              [...Array(inputShape.length).keys()];\n  let steps = readInput(inputs, 4);\n  steps.forEach((step) => step !== 0 || (() => {\n                            throw new Error('step cannot be 0');\n                          }));\n  if (steps.length === 0) {\n    steps = Array(axes.length).fill(1);\n  }\n  const starts = attributes.starts.map((start, i) => fixStartEndValues(start, i, inputShape, axes, steps));\n\n  const ends = attributes.ends.map((end, i) => fixStartEndValues(end, i, inputShape, axes, steps));\n\n  if (axes.length !== starts.length || axes.length !== ends.length) {\n    throw new Error('start, ends and axes should have the same number of elements');\n  }\n\n  if (axes.length !== inputShape.length) {\n    for (let i = 0; i < inputShape.length; ++i) {\n      if (!axes.includes(i)) {\n        starts.splice(i, 0, 0);\n        ends.splice(i, 0, inputShape[i]);\n        steps.splice(i, 0, 1);\n      }\n    }\n  }\n  const signs = steps.map(step => Math.sign(step));\n  // Convert negative steps to positive steps and reverse starts and ends\n  steps.forEach((step, i, array) => {\n    if (step < 0) {\n      const numSteps = (ends[i] - starts[i]) / step;\n      const newEnd = starts[i];\n      const newStart = newEnd + numSteps * steps[i];\n      starts[i] = newStart;\n      ends[i] = newEnd;\n      array[i] = -step;\n    }\n  });\n  // Output rank is expected to be less than or equal to the input rank.\n  const outputShape = inputShape.slice(0);\n  axes.forEach((axis, _) => {\n    outputShape[axis] = Math.ceil((ends[axis] - starts[axis]) / steps[axis]);\n  });\n  const outputTensorInfo: TensorInfo = {dims: outputShape, dataType: inputs[0].dataType};\n\n  const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n  const input = inputVariable('input', inputs[0].dataType, inputs[0].dims.length);\n  const outputSize = ShapeUtil.size(outputShape);\n  const uniforms: UniformsArrayType = [\n    {name: 'outputSize', type: 'u32'}, {name: 'starts', type: 'u32', length: starts.length},\n    {name: 'signs', type: 'i32', length: signs.length}, {name: 'steps', type: 'u32', length: steps.length}\n  ];\n\n  const programUniforms: ProgramUniform[] = [\n    {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: starts},\n    {type: DataType.int32, data: signs}, {type: DataType.uint32, data: steps},\n    ...createTensorShapeVariables(inputs[0].dims, outputShape)\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n      ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)}\n        ${calculateInputIndicesImpl(input, output, inputShape)}\n        ${shaderHelper.mainStart()}\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n          let output_indices = ${output.offsetToIndices('global_idx')};\n          let input_indices = calculateInputIndices(output_indices);\n          ${output.setByOffset('global_idx', input.getByIndices('input_indices'))}\n      }`;\n  return {\n    name: 'Slice',\n    shaderCache: {hint: `${signs.length}_${starts.length}_${steps.length}`, inputDependencies: ['rank']},\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [outputTensorInfo],\n      dispatchGroup: {x: Math.ceil(inputSize / 64 /* workgroup size */)},\n      programUniforms\n    })\n  };\n};\n\nexport const slice = (context: ComputeContext, attributes: SliceAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  const updatedAttributes = createSliceAttributesFromInputs(context.inputs, attributes);\n  context.compute(createSliceProgramInfo(context.inputs, updatedAttributes), {inputs: [0]});\n  // if (ShapeUtil.size(program.outputs[0].dims) > 0) {\n  //   context.compute(programInfoLoader, {inputs: [0]});\n  // } else {\n  //   // TODO: support empty output\n  //   throw new Error('slice: output size is 0');\n  // }\n};\n\nexport const parseSliceAttributes = (attributes: Record<string, unknown>): SliceAttributes => {\n  const starts = attributes.starts as number[];\n  const ends = attributes.ends as number[];\n  const axes = attributes.axes as number[];\n  return createAttributeWithCacheKey({starts, ends, axes});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// TODO: this is the same naive implementation we use for reduce that has\n// performance limitations when the reduced axis is long. Need to add\n// a optimized codepath for this.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {getMaxComponents, inputVariable, outputVariable, ShaderHelper, sumVector, tensorTypeToWsglStorageType} from './common';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Softmax op requires 1 input.');\n  }\n};\n\nexport interface SoftmaxAttributes extends AttributeWithCacheKey {\n  readonly axis: number;\n}\n\nconst createSoftmaxProgramInfo = (input: TensorView, attributes: SoftmaxAttributes): ProgramInfo => {\n  const shape = input.dims;\n  const outputSize = ShapeUtil.size(shape);\n  const WG = 64;\n  let axis = attributes.axis;\n  if (axis < 0) {\n    axis = shape.length + axis;\n  }\n  if (axis < shape.length - 1) {\n    throw new Error('softmax only supports last axis for now.');\n  }\n\n  const cols = shape[axis];\n  const rows = outputSize / cols;\n  const components = getMaxComponents(cols);\n  const packedCols = cols / components;\n\n  const maxVector = (name: string, components: number) => {\n    if (components === 4) {\n      return `max(max(${name}.x, ${name}.y), max(${name}.z, ${name}.w))`;\n    } else if (components === 2) {\n      return `max(${name}.x, ${name}.y)`;\n    } else if (components === 3) {\n      return `max(max(${name}.x, ${name}.y), ${name}.z)`;\n    }\n\n    return name;\n  };\n  const x = inputVariable('x', input.dataType, input.dims, components);\n  const output = outputVariable('result', input.dataType, input.dims, components);\n  const valueType = x.type.value;\n  // 6.2.4 in wgsl spec\n  const threadMaxDecl = tensorTypeToWsglStorageType(input.dataType) === 'f32' ?\n      `var threadMax = ${valueType}(-3.402823e+38f);` :\n      `var threadMax = ${valueType}(-65504.0h);`;\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n      var<workgroup> rowMaxShared : ${valueType};\n      var<workgroup> rowSumShared : ${valueType};\n      var<workgroup> threadShared : array<${valueType}, ${WG}>;\n\n      fn getValue(row: i32, col: i32, row_stride: i32) -> ${valueType} {\n        let index = row * row_stride + col;\n        return x[index];\n      }\n\n      fn setValue(row: i32, col: i32, row_stride: i32, value: ${valueType}) {\n        let index = row * row_stride + col;\n        result[index] = value;\n      }\n      ${shaderHelper.registerUniform('packedCols', 'i32').declareVariables(x, output)}\n      ${shaderHelper.mainStart()}\n        let gindex = i32(global_idx);\n        let lindex = i32(local_idx);\n        const wg = ${WG};\n        let row = gindex / wg;\n        let cols = uniforms.packedCols;\n        let row_stride : i32 = uniforms.packedCols;\n\n        // find the rows max\n        ${threadMaxDecl}\n        for (var col = lindex; col < cols; col += wg) {\n          let value = getValue(row, col, row_stride);\n          threadMax = max(threadMax, value);\n        }\n        if (lindex < cols) {\n          threadShared[lindex] = threadMax;\n        }\n        workgroupBarrier();\n\n        var reduceSize = min(cols, wg);\n        for (var currSize = reduceSize >> 1;  currSize > 0; currSize = reduceSize >> 1) {\n          reduceSize = currSize + (reduceSize & 1);\n          if (lindex < currSize) {\n            threadShared[lindex] = max(threadShared[lindex], threadShared[lindex + reduceSize]);\n          }\n          workgroupBarrier();\n        }\n        if (lindex == 0) {\n          rowMaxShared = ${valueType}(${maxVector('threadShared[0]', components)});\n        }\n        workgroupBarrier();\n\n        // find the rows sum\n        var threadSum = ${valueType}(0.0);\n        for (var col = lindex; col < cols; col += wg) {\n          let subExp = exp(getValue(row, col, row_stride) - rowMaxShared);\n          threadSum += subExp;\n        }\n        threadShared[lindex] = threadSum;\n        workgroupBarrier();\n\n        for (var currSize = wg >> 1;  currSize > 0; currSize = currSize >> 1) {\n          if (lindex < currSize) {\n            threadShared[lindex] = threadShared[lindex] + threadShared[lindex + currSize];\n          }\n          workgroupBarrier();\n        }\n        if (lindex == 0) {\n          rowSumShared = ${valueType}(${sumVector('threadShared[0]', components)});\n        }\n        workgroupBarrier();\n\n        // calculate final value for each element in the row\n        for (var col = lindex; col < cols; col += wg) {\n          let value = exp(getValue(row, col, row_stride) - rowMaxShared) / rowSumShared;\n          setValue(row, col, row_stride, value);\n        }\n      }`;\n  return {\n    name: 'Softmax',\n    shaderCache: {hint: `${components}`, inputDependencies: ['type']},\n    getRunData: () => ({\n      outputs: [{dims: shape, dataType: input.dataType}],\n      dispatchGroup: {x: rows},\n      programUniforms: [{type: DataType.int32, data: packedCols}]\n    }),\n    getShaderSource,\n  };\n};\n\nexport const softmax = (context: ComputeContext, attributes: SoftmaxAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createSoftmaxProgramInfo(context.inputs[0], attributes));\n};\n\nexport const parseSoftmaxAttributes = (attributes: Record<string, unknown>): SoftmaxAttributes =>\n    createAttributeWithCacheKey({axis: attributes.axis as number});\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform, TensorInfo} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface SplitAttributes extends AttributeWithCacheKey {\n  readonly axis: number;\n  readonly numOutputs: number;\n  readonly splitSizes: number[];\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length < 1) {\n    throw new Error('too few inputs');\n  }\n};\n\nconst createSplitAttributesFromInputs =\n    (inputs: readonly TensorView[], attributes: SplitAttributes): SplitAttributes => {\n      const splitSizes: number[] = [];\n      let numOutputs: number = attributes.numOutputs;\n      if (inputs[1].dims[0] > 0) {\n        inputs[1].getBigInt64Array().forEach(v => splitSizes.push(Number(v)));\n        numOutputs = splitSizes.length;\n      }\n      return createAttributeWithCacheKey({numOutputs, axis: attributes.axis, splitSizes});\n    };\n\nconst calculateOutputIndexImpl = (numberOfTensors: number): string => `\nfn calculateOutputIndex(index: u32) -> u32 {\n    for (var i: u32 = 0u; i < ${numberOfTensors}u; i += 1u ) {\n    if (index < ${getElementAt('uniforms.size_in_split_axis', 'i', numberOfTensors)}) {\n        return i;\n    }\n    }\n    return ${numberOfTensors}u;\n}`;\nconst writeBufferDataImpl = (outputs: readonly IndicesHelper[]) => {\n  const numberOfTensors = outputs.length;\n  const codeLines: string[] = [];\n  for (let i = 0; i < numberOfTensors; ++i) {\n    const returnSnippet = outputs[i].setByIndices('indices', 'input[global_idx]');\n    if (numberOfTensors === 1) {\n      codeLines.push(returnSnippet);\n    } else if (i === 0) {\n      codeLines.push(`if (output_number == ${i}u) { ${returnSnippet} }`);\n    } else if (i === numberOfTensors - 1) {\n      codeLines.push(`else { ${returnSnippet} }`);\n    } else {\n      codeLines.push(`else if (output_number == ${i}) { ${returnSnippet} }`);\n    }\n  }\n  return `\n      fn writeBufferData(output_number: u32, indices: ${outputs[0].type.indices}, global_idx: u32) {\n        ${codeLines.join('\\n')}\n      }`;\n};\n\nconst createSplitProgramInfo = (inputs: readonly TensorView[], attributes: SplitAttributes): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const inputSize = ShapeUtil.size(inputShape);\n  const dataType = inputs[0].dataType;\n  const axis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);\n  const outputs = new Array<IndicesHelper>(attributes.numOutputs);\n  const input = inputVariable('input', dataType, inputShape.length);\n  const sizeInSplitAxis = new Array<number>(attributes.numOutputs);\n  const outputsTensorInfo: TensorInfo[] = [];\n  const outputShapes: number[][] = [];\n  let previousSum = 0;\n  const programUniforms: ProgramUniform[] = [{type: DataType.uint32, data: inputSize}];\n  for (let i = 0; i < attributes.numOutputs; i++) {\n    previousSum += attributes.splitSizes[i];\n    sizeInSplitAxis[i] = previousSum;\n    const outputShape = inputShape.slice();\n    outputShape[attributes.axis] = attributes.splitSizes[i];\n    outputShapes.push(outputShape);\n    outputs[i] = outputVariable(`output${i}`, dataType, outputShape.length);\n    outputsTensorInfo.push({dims: outputShapes[i], dataType: inputs[0].dataType});\n  }\n  programUniforms.push(\n      {type: DataType.uint32, data: sizeInSplitAxis}, ...createTensorShapeVariables(inputShape, ...outputShapes));\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  ${\n      shaderHelper.registerUniform('input_size', 'u32')\n          .registerUniform('size_in_split_axis', 'u32', sizeInSplitAxis.length)\n          .declareVariables(input, ...outputs)}\n  ${calculateOutputIndexImpl(sizeInSplitAxis.length)}\n  ${writeBufferDataImpl(outputs)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.input_size')}\n\n    var indices = ${input.offsetToIndices('global_idx')};\n    var index = ${input.indicesGet('indices', axis)};\n    let output_number = calculateOutputIndex(index);\n    if (output_number != 0) {\n      index -= ${getElementAt('uniforms.size_in_split_axis', 'output_number - 1u', sizeInSplitAxis.length)};\n      ${input.indicesSet('indices', axis, 'index')};\n    }\n    writeBufferData(output_number, indices, global_idx);\n  }`;\n  return {\n    name: 'Split',\n    shaderCache: {hint: attributes.cacheKey, inputDependencies: ['rank']},\n    getShaderSource,\n    getRunData: () => ({\n      outputs: outputsTensorInfo,\n      dispatchGroup: {x: Math.ceil(inputSize / 64 /* workgroup size */)},\n      programUniforms\n    })\n  };\n};\n\nexport const split = (context: ComputeContext, attributes: SplitAttributes): void => {\n  validateInputs(context.inputs);\n  const updatedAttributes =\n      context.inputs.length === 1 ? attributes : createSplitAttributesFromInputs(context.inputs, attributes);\n  context.compute(createSplitProgramInfo(context.inputs, updatedAttributes), {inputs: [0]});\n};\n\nexport const parseSplitAttributes = (attributes: Record<string, unknown>): SplitAttributes => {\n  const axis = attributes.axis as number;\n  const splitSizes: number[] = attributes.splitSizes as number[];\n  const numOutputs = attributes.numOutputs as number < 0 ? splitSizes.length : attributes.numOutputs as number;\n  if (numOutputs !== splitSizes.length) {\n    throw new Error('numOutputs and splitSizes lengh must be equal');\n  }\n  return createAttributeWithCacheKey({axis, numOutputs, splitSizes});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nconst getRepeats = (repeatsTensorView: TensorView): readonly number[] =>\n    Array.from(repeatsTensorView.getBigInt64Array(), Number);\n\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('Tile requires 2 inputs.');\n  }\n\n  if (inputs[0].dataType !== DataType.float && inputs[0].dataType !== DataType.int32 &&\n      inputs[0].dataType !== DataType.uint32) {\n    throw new Error('Tile only support float, int32, and uint32 data types');\n  }\n\n  if (inputs[1].dataType !== DataType.int64) {\n    throw new Error('Tile `repeats` input should be of int64 data type');\n  }\n\n  if (inputs[1].dims.length !== 1) {\n    throw new Error('Tile `repeats` input should be 1-D');\n  }\n\n  const repeats: readonly number[] = getRepeats(inputs[1]);\n\n  if (repeats.length !== inputs[0].dims.length) {\n    throw new Error('Tile `repeats` input should have same number of elements as rank of input data tensor');\n  }\n};\n\nconst getOutputShape = (inputShape: readonly number[], repeats: readonly number[]): readonly number[] => {\n  const outputShape: number[] = [];\n\n  for (let i = 0; i < inputShape.length; ++i) {\n    outputShape.push(inputShape[i] * repeats[i]);\n  }\n\n  return outputShape;\n};\n\nexport const createTileProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const repeats: readonly number[] = getRepeats(inputs[1]);\n  const outputShape = getOutputShape(inputShape, repeats);\n  const outputSize = ShapeUtil.size(outputShape);\n\n  const dataType = inputs[0].dataType;\n  const input = inputVariable('input', dataType, inputShape.length);\n  const output = outputVariable('output', dataType, outputShape.length);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n      const inputShape = ${input.indices(...inputShape)};\n      ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(input, output)}\n      ${shaderHelper.mainStart()}\n      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n      let output_indices = ${output.offsetToIndices('global_idx')};\n      var input_indices: ${input.type.indices};\n      for (var i = 0; i < ${inputShape.length}; i++) {\n        let input_dim_i = ${input.indicesGet('uniforms.input_shape', 'i')};\n        let input_dim_value = ${output.indicesGet('output_indices', 'i')}  % input_dim_i;\n\n        ${input.indicesSet('input_indices', 'i', 'input_dim_value')}\n      }\n      ${output.setByOffset('global_idx', input.getByIndices('input_indices'))}\n    }`;\n\n  return {\n    name: 'Tile',\n    shaderCache: {hint: `${repeats}`, inputDependencies: ['rank']},\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n      programUniforms:\n          [{type: DataType.uint32, data: outputSize}, ...createTensorShapeVariables(inputs[0].dims, outputShape)],\n    }),\n    getShaderSource,\n  };\n};\n\nexport const tile = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  context.compute(createTileProgramInfo(context.inputs), {inputs: [0]});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {BroadcastUtil, ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nconst createWhereOpProgramShader =\n    (shaderHelper: ShaderHelper, inputs: readonly TensorView[], dimsOutput: readonly number[], isBroadcast: boolean,\n     typeOutput: number) => {\n      const output = outputVariable('output_data', typeOutput, dimsOutput.length, 4);\n      const a = inputVariable('a_data', inputs[1].dataType, inputs[1].dims.length, 4);\n      const b = inputVariable('b_data', inputs[2].dataType, inputs[2].dims.length, 4);\n      const c = inputVariable('c_data', inputs[0].dataType, inputs[0].dims.length, 4);\n\n      let assignment: string;\n      const expression = (a: string, b: string, c: string) => `select(${b}, ${a}, ${c})`;\n      if (!isBroadcast) {\n        assignment = output.setByOffset(\n            'global_idx',\n            expression(a.getByOffset('global_idx'), b.getByOffset('global_idx'), c.getByOffset('global_idx')));\n      } else {\n        const singleAssignment = (resStr: string, x: number, typeCast = '') => {\n          const expressionA = `a_data[index_a${x}][component_a${x}]`;\n          const expressionB = `b_data[index_b${x}][component_b${x}]`;\n          // eslint-disable-next-line no-bitwise\n          const expressionC = `bool(c_data[index_c${x}] & (0xffu << (component_c${x} * 8)))`;\n          return `\n            let output_indices${x} = ${output.offsetToIndices(`global_idx * 4u + ${x}u`)};\n            let offset_a${x} = ${a.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n            let offset_b${x} = ${b.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n            let offset_c${x} = ${c.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n            let index_a${x} = offset_a${x} / 4u;\n            let index_b${x} = offset_b${x} / 4u;\n            let index_c${x} = offset_c${x} / 4u;\n            let component_a${x} = offset_a${x} % 4u;\n            let component_b${x} = offset_b${x} % 4u;\n            let component_c${x} = offset_c${x} % 4u;\n            ${resStr}[${x}] = ${typeCast}(${expression(expressionA, expressionB, expressionC)});\n          `;\n        };\n        if (typeOutput === DataType.bool) {\n          assignment = `\n            var data = vec4<u32>(0);\n            ${singleAssignment('data', 0, 'u32')}\n            ${singleAssignment('data', 1, 'u32')}\n            ${singleAssignment('data', 2, 'u32')}\n            ${singleAssignment('data', 3, 'u32')}\n            output_data[global_idx] = dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(data));`;\n        } else {\n          assignment = `\n            ${singleAssignment('output_data[global_idx]', 0)}\n            ${singleAssignment('output_data[global_idx]', 1)}\n            ${singleAssignment('output_data[global_idx]', 2)}\n            ${singleAssignment('output_data[global_idx]', 3)}\n          `;\n        }\n      }\n\n      return `\n        ${shaderHelper.registerUniform('vec_size', 'u32').declareVariables(c, a, b, output)}\n        ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.vec_size')}\n        ${assignment}\n      }`;\n    };\n\nconst createWhereOpProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const dimsA = inputs[1].dims;\n  const dimsB = inputs[2].dims;\n  const dimsC = inputs[0].dims;\n  const outputDataType = inputs[1].dataType;\n\n  const isBroadcast = !(ShapeUtil.areEqual(dimsA, dimsB) && ShapeUtil.areEqual(dimsB, dimsC));\n  let outputShape = dimsA;\n  let outputSize = ShapeUtil.size(dimsA);\n  // TODO: deal with zero-sized tensors (eg. dims=[1,0])\n\n  if (isBroadcast) {\n    const calculatedShape = BroadcastUtil.calcShape(BroadcastUtil.calcShape(dimsA, dimsB, false)!, dimsC, false);\n    if (!calculatedShape) {\n      throw new Error('Can\\'t perform where op on the given tensors');\n    }\n    outputShape = calculatedShape;\n    outputSize = ShapeUtil.size(outputShape);\n  }\n\n  const vecSize = Math.ceil(outputSize / 4);\n\n  return {\n    name: 'Where',\n    shaderCache: {inputDependencies: ['rank', 'rank', 'rank']},\n    getShaderSource: (shaderHelper) =>\n        createWhereOpProgramShader(shaderHelper, inputs, outputShape, isBroadcast, outputDataType),\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: outputDataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */ / 4 /* vec size */)},\n      programUniforms:\n          [{type: DataType.uint32, data: vecSize}, ...createTensorShapeVariables(dimsC, dimsA, dimsB, outputShape)],\n    }),\n  };\n};\n\nexport const where = (context: ComputeContext): void => {\n  context.compute(createWhereOpProgramInfo(context.inputs));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {argMax, argMin, parseArgMinMaxAttributes} from './ops/argminmax';\nimport {attention} from './ops/attention';\nimport {batchNorm} from './ops/batch-norm';\nimport {biasAdd} from './ops/bias-add';\nimport {biasSplitGelu} from './ops/bias-split-gelu';\nimport * as binaryOps from './ops/binary-op';\nimport {concat, parseConcatAttributes} from './ops/concat';\nimport {conv, parseConvAttributes} from './ops/conv';\nimport {convTranspose, parseConvTransposeAttributes} from './ops/conv-transpose';\nimport {cumsum, parseCumSumAttributes} from './ops/cumsum';\nimport {depthToSpace, parseDepthToSpaceAttributes} from './ops/depth-to-space';\nimport {einsum, parseEinsumAttributes} from './ops/einsum';\nimport {expand} from './ops/expand';\nimport {fastGelu} from './ops/fast-gelu';\nimport {gather, parseGatherAttributes} from './ops/gather';\nimport {gatherElements, parseGatherElementsAttributes} from './ops/gather-elements';\nimport {gemm, parseGemmAttributes} from './ops/gemm';\nimport {instanceNorm} from './ops/instance-norm';\nimport {layerNorm} from './ops/layer-norm';\nimport {matMul} from './ops/matmul';\nimport {matMulNBits, parseMatMulNBitsAttributes} from './ops/matmulnbits';\nimport {multiHeadAttention, parseMultiHeadAttentionAttributes} from './ops/multihead-attentiion';\nimport {pad} from './ops/pad';\nimport * as pool from './ops/pool';\nimport {range} from './ops/range';\nimport {reduceL1, reduceL2, reduceLogSum, reduceLogSumExp, reduceMax, reduceMean, reduceMin, reduceProd, reduceSum, reduceSumSquare} from './ops/reduce';\nimport {parseResizeAttributes, resize} from './ops/resize';\nimport {rotaryEmbedding} from './ops/rotary-embedding';\nimport {skipLayerNorm} from './ops/skip-layer-norm';\nimport {parseSliceAttributes, slice} from './ops/slice';\nimport {parseSoftmaxAttributes, softmax} from './ops/softmax';\nimport {parseSplitAttributes, split} from './ops/split';\nimport {tile} from './ops/tile';\nimport {parseTransposeAttributes, transpose} from './ops/transpose';\nimport * as unaryOps from './ops/unary-op';\nimport {where} from './ops/where';\nimport {ComputeContext} from './types';\n\nexport type RunFunction = (context: ComputeContext, attribute?: unknown) => void;\nexport type ParseAttributeFunction = (attributeRaw: unknown) => unknown;\nexport type OperatorImplementation = [RunFunction]|[RunFunction, ParseAttributeFunction];\n\nexport const WEBGPU_OP_RESOLVE_RULES: Map<string, OperatorImplementation> = new Map([\n  ['Abs', [unaryOps.abs]],\n  ['Acos', [unaryOps.acos]],\n  ['Acosh', [unaryOps.acosh]],\n  ['Add', [binaryOps.add]],\n  ['ArgMax', [argMax, parseArgMinMaxAttributes]],\n  ['ArgMin', [argMin, parseArgMinMaxAttributes]],\n  ['Asin', [unaryOps.asin]],\n  ['Asinh', [unaryOps.asinh]],\n  ['Atan', [unaryOps.atan]],\n  ['Atanh', [unaryOps.atanh]],\n  ['Attention', [attention]],\n  // TODO: support new attributes for AveragePool-10\n  ['AveragePool', [pool.averagePool, pool.parseAveragePoolAttributes]],\n  ['BatchNormalization', [batchNorm]],\n  ['BiasAdd', [biasAdd]],\n  ['BiasSplitGelu', [biasSplitGelu]],\n  ['Cast', [unaryOps.cast, unaryOps.parseCastAttributes]],\n  ['Ceil', [unaryOps.ceil]],\n  ['Clip', [unaryOps.clip]],\n  ['Concat', [concat, parseConcatAttributes]],\n  ['Conv', [conv, parseConvAttributes]],\n  ['ConvTranspose', [convTranspose, parseConvTransposeAttributes]],\n  ['Cos', [unaryOps.cos]],\n  ['Cosh', [unaryOps.cosh]],\n  ['CumSum', [cumsum, parseCumSumAttributes]],\n  ['DepthToSpace', [depthToSpace, parseDepthToSpaceAttributes]],\n  ['Div', [binaryOps.div]],\n  ['Einsum', [einsum, parseEinsumAttributes]],\n  ['Elu', [unaryOps.elu, unaryOps.parseAlphaAttributes]],\n  ['Equal', [binaryOps.equal]],\n  ['Erf', [unaryOps.erf]],\n  ['Exp', [unaryOps.exp]],\n  ['Expand', [expand]],\n  ['FastGelu', [fastGelu]],\n  ['Floor', [unaryOps.floor]],\n  ['FusedConv', [conv, parseConvAttributes]],\n  ['Gather', [gather, parseGatherAttributes]],\n  ['GatherElements', [gatherElements, parseGatherElementsAttributes]],\n  ['Gelu', [unaryOps.gelu]],\n  ['Gemm', [gemm, parseGemmAttributes]],\n  ['GlobalAveragePool', [pool.globalAveragePool, pool.parseGlobalAveragePoolAttributes]],\n  ['GlobalMaxPool', [pool.globalMaxPool, pool.parseGlobalMaxPoolAttributes]],\n  ['Greater', [binaryOps.greater]],\n  ['GreaterOrEqual', [binaryOps.greaterOrEqual]],\n  ['HardSigmoid', [unaryOps.hardSigmoid, unaryOps.parseHardSigmoidAttributes]],\n  ['InstanceNormalization', [instanceNorm]],\n  ['LayerNormalization', [layerNorm]],\n  ['LeakyRelu', [unaryOps.leakyRelu, unaryOps.parseAlphaAttributes]],\n  ['Less', [binaryOps.less]],\n  ['LessOrEqual', [binaryOps.lessOrEqual]],\n  ['Log', [unaryOps.log]],\n  ['MatMul', [matMul]],\n  ['MatMulNBits', [matMulNBits, parseMatMulNBitsAttributes]],\n  // TODO: support new attributes for MaxPool-8 and MaxPool-10\n  ['MaxPool', [pool.maxPool, pool.parseMaxPoolAttributes]],\n  ['Mul', [binaryOps.mul]],\n  ['MultiHeadAttention', [multiHeadAttention, parseMultiHeadAttentionAttributes]],\n  ['Neg', [unaryOps.neg]],\n  ['Not', [unaryOps.not]],\n  ['Pad', [pad]],\n  ['Pow', [binaryOps.pow]],\n  ['Range', [range]],\n  ['Reciprocal', [unaryOps.reciprocal]],\n  ['ReduceMin', [reduceMin]],\n  ['ReduceMean', [reduceMean]],\n  ['ReduceMax', [reduceMax]],\n  ['ReduceSum', [reduceSum]],\n  ['ReduceProd', [reduceProd]],\n  ['ReduceL1', [reduceL1]],\n  ['ReduceL2', [reduceL2]],\n  ['ReduceLogSum', [reduceLogSum]],\n  ['ReduceLogSumExp', [reduceLogSumExp]],\n  ['ReduceSumSquare', [reduceSumSquare]],\n  ['Relu', [unaryOps.relu]],\n  ['Resize', [resize, parseResizeAttributes]],\n  ['RotaryEmbedding', [rotaryEmbedding]],\n  ['Sigmoid', [unaryOps.sigmoid]],\n  ['Sin', [unaryOps.sin]],\n  ['Sinh', [unaryOps.sinh]],\n  ['Slice', [slice, parseSliceAttributes]],\n  ['SkipLayerNormalization', [skipLayerNorm]],\n  ['Split', [split, parseSplitAttributes]],\n  ['Sqrt', [unaryOps.sqrt]],\n  ['Softmax', [softmax, parseSoftmaxAttributes]],\n  ['Sub', [binaryOps.sub]],\n  ['Tan', [unaryOps.tan]],\n  ['Tanh', [unaryOps.tanh]],\n  ['ThresholdedRelu', [unaryOps.thresholdedRelu, unaryOps.parseAlphaAttributes]],\n  ['Tile', [tile]],\n  ['Transpose', [transpose, parseTransposeAttributes]],\n  ['Where', [where]],\n]);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TRACE_FUNC_BEGIN, TRACE_FUNC_END} from 'onnxruntime-common';\n\nimport {WebGpuBackend} from '../backend-webgpu';\nimport {LOG_DEBUG} from '../log';\n\nimport {createShaderHelper} from './ops/common';\nimport {Artifact, GpuData, ProgramInfo} from './types';\n\n/**\n * ProgramManager is the main class behind running computations\n * It builds ProgramInfo's into Artifacts\n * It compiles given ProgramInfo's into WebGL Prorams (cached as Artifacts)\n * Uses the artifact to run the computation by calling Draw on\n * the WebGL drawing buffer\n * ProgramManager automatically maps (binds) input variables to their\n * corresponding Location's in the binary program\n */\nexport class ProgramManager {\n  repo: Map<unknown, Artifact>;  // this should be per-session object\n  attributesBound: boolean;\n\n  constructor(private backend: WebGpuBackend) {\n    this.repo = new Map();\n    this.attributesBound = false;\n  }\n  getArtifact(key: unknown): Artifact|undefined {\n    return this.repo.get(key);\n  }\n  setArtifact(key: unknown, artifact: Artifact): void {\n    this.repo.set(key, artifact);\n  }\n  run(buildArtifact: Artifact, inputs: GpuData[], outputs: GpuData[], dispatchGroup: [number, number, number],\n      uniformBufferBinding: GPUBindingResource|undefined): void {\n    TRACE_FUNC_BEGIN(buildArtifact.programInfo.name);\n    const device = this.backend.device;\n    const computePassEncoder = this.backend.getComputePassEncoder();\n    this.backend.writeTimestamp(this.backend.pendingDispatchNumber * 2);\n    const entries = [];\n    for (const input of inputs) {\n      entries.push({binding: entries.length, resource: {buffer: input.buffer}});\n    }\n    for (const output of outputs) {\n      entries.push({binding: entries.length, resource: {buffer: output.buffer}});\n    }\n    if (uniformBufferBinding) {\n      entries.push({binding: entries.length, resource: uniformBufferBinding});\n    }\n    const bindGroup = device.createBindGroup(\n        {layout: buildArtifact.computePipeline.getBindGroupLayout(0), entries, label: buildArtifact.programInfo.name});\n\n    if (this.backend.sessionStatus === 'capturing') {\n      const commandInfo = {\n        kernelId: this.backend.currentKernelId!,\n        computePipeline: buildArtifact.computePipeline,\n        bindGroup,\n        dispatchGroup\n      };\n      const sessionCommandList = this.backend.capturedCommandList.get(this.backend.currentSessionId!);\n      sessionCommandList!.push(commandInfo);\n    }\n\n    computePassEncoder.setPipeline(buildArtifact.computePipeline);\n    computePassEncoder.setBindGroup(0, bindGroup);\n    computePassEncoder.dispatchWorkgroups(...dispatchGroup);\n    this.backend.writeTimestamp(this.backend.pendingDispatchNumber * 2 + 1);\n    this.backend.pendingDispatchNumber++;\n\n    if (this.backend.pendingDispatchNumber >= this.backend.maxDispatchNumber ||\n        this.backend.queryType === 'at-passes') {\n      this.backend.endComputePass();\n    }\n    if (this.backend.pendingDispatchNumber >= this.backend.maxDispatchNumber) {\n      this.backend.flush();\n    }\n    TRACE_FUNC_END(buildArtifact.programInfo.name);\n  }\n  dispose(): void {\n    // this.repo.forEach(a => this.glContext.deleteProgram(a.program));\n  }\n  build(programInfo: ProgramInfo, normalizedDispatchGroupSize: [number, number, number]): Artifact {\n    TRACE_FUNC_BEGIN(programInfo.name);\n    const device = this.backend.device;\n    const extensions: string[] = [];\n    if (device.features.has('shader-f16')) {\n      extensions.push('enable f16;');\n    }\n    const shaderHelper = createShaderHelper(normalizedDispatchGroupSize, this.backend.device.limits);\n    const userCode = programInfo.getShaderSource(shaderHelper);\n    const code = `${extensions.join('\\n')}\\n${shaderHelper.additionalImplementations}\\n${userCode}`;\n    const shaderModule = device.createShaderModule({code, label: programInfo.name});\n    LOG_DEBUG('verbose', () => `[WebGPU] ${programInfo.name} shader code: ${code}`);\n\n    const computePipeline = device.createComputePipeline(\n        {compute: {module: shaderModule, entryPoint: 'main'}, layout: 'auto', label: programInfo.name});\n\n    TRACE_FUNC_END(programInfo.name);\n    return {programInfo, computePipeline, uniformVariablesInfo: shaderHelper.variablesInfo};\n  }\n\n  normalizeDispatchGroupSize(dispatchGroup: ReturnType<ProgramInfo['getRunData']>['dispatchGroup']):\n      [number, number, number] {\n    const x = typeof dispatchGroup === 'number' ? dispatchGroup : dispatchGroup.x;\n    const y = typeof dispatchGroup === 'number' ? 1 : (dispatchGroup.y || 1);\n    const z = typeof dispatchGroup === 'number' ? 1 : (dispatchGroup.z || 1);\n    const limitPerDimension = this.backend.device.limits.maxComputeWorkgroupsPerDimension;\n    if (x <= limitPerDimension && y <= limitPerDimension && z <= limitPerDimension) {\n      return [x, y, z];\n    }\n    const size = x * y * z;\n    let dispatchAverage = Math.ceil(Math.sqrt(size));\n    if (dispatchAverage > limitPerDimension) {\n      dispatchAverage = Math.ceil(Math.cbrt(size));\n      if (dispatchAverage > limitPerDimension) {\n        throw new Error('Total dispatch size exceeds WebGPU maximum.');\n      }\n      return [dispatchAverage, dispatchAverage, dispatchAverage];\n    } else {\n      return [dispatchAverage, dispatchAverage, 1];\n    }\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Env, Tensor, TRACE, TRACE_FUNC_BEGIN, TRACE_FUNC_END} from 'onnxruntime-common';\n\nimport {DataType, tensorDataTypeEnumToString} from '../wasm-common';\n\nimport {configureLogger, LOG_DEBUG} from './log';\nimport {createView, TensorView} from './tensor-view';\nimport {createGpuDataManager, downloadGpuData, GpuDataManager} from './webgpu/gpu-data-manager';\nimport {RunFunction, WEBGPU_OP_RESOLVE_RULES} from './webgpu/op-resolve-rules';\nimport {ProgramManager} from './webgpu/program-manager';\nimport {AdapterInfo, ComputeContext, GpuArchitecture, GpuData, GpuVendor, ProgramInfo, ProgramInputTensorInfoDependency, SessionState, TimestampQuery} from './webgpu/types';\n\ninterface CommandInfo {\n  readonly kernelId: number;\n  readonly computePipeline: GPUComputePipeline;\n  readonly bindGroup: GPUBindGroup;\n  readonly dispatchGroup: [number, number, number];\n}\n\ninterface KernelInfo {\n  readonly kernelType: string;\n  readonly kernelName: string;\n  readonly kernelEntry: RunFunction;\n  readonly attributes: [((attribute: unknown) => unknown)|undefined, unknown];\n}\n\ninterface PendingKernelInfo {\n  readonly kernelId: number;\n  readonly programName: string;\n  readonly inputTensorViews: readonly TensorView[];\n  readonly outputTensorViews: readonly TensorView[];\n}\n\nconst getProgramInputTensorInfoDependencyKey =\n    (inputTensors: readonly TensorView[], inputDependencies: readonly ProgramInputTensorInfoDependency[]): string => {\n      if (inputDependencies.length !== inputTensors.length) {\n        throw new Error(`inputDependencies length ${inputDependencies.length} is not equal to inputTensors length ${\n            inputTensors.length}.`);\n      }\n\n      const inputInfos: string[] = [];\n      for (let i = 0; i < inputTensors.length; ++i) {\n        const type = inputTensors[i].dataType;\n        switch (inputDependencies[i]) {\n          case 'none': {\n            inputInfos.push('');\n            break;\n          }\n          case 'type': {\n            inputInfos.push(`${type}`);\n            break;\n          }\n          case 'rank': {\n            const rank = inputTensors[i].dims.length;\n            inputInfos.push(`${type};${rank}`);\n            break;\n          }\n          case 'dims': {\n            const dims = inputTensors[i].dims.join(',');\n            inputInfos.push(`${type};${dims}`);\n            break;\n          }\n          default:\n            throw new Error(`unsupported input dependency: ${inputDependencies[i]}`);\n        }\n      }\n\n      return inputInfos.join('|');\n    };\n\n/**\n * get a unique key representing the program from the program info, input shapes and types.\n *\n * @returns a unique key is a shorter string than the shader source, which contains all the information to identify a\n * program. if the key is the same, the program shader source should be the same, so we can reuse the program.\n *\n */\nconst getProgramInfoUniqueKey =\n    (programInfo: ProgramInfo, inputTensors: readonly TensorView[], is1DimensionDispatch: boolean): string => {\n      // final key format:\n      // <PROGRAM_NAME>[<PROGRAM_CUSTOM_CACHE_HINT>]:is1DimensionDispatch:<INPUTS_INFO_0>|<INPUTS_INFO_1>|...\n      let key = programInfo.name;\n      if (programInfo.shaderCache?.hint) {\n        key += '[' + programInfo.shaderCache.hint + ']';\n      }\n      key += ':' + is1DimensionDispatch +\n          `:${\n                 getProgramInputTensorInfoDependencyKey(\n                     inputTensors,\n                     programInfo.shaderCache?.inputDependencies ??\n                         new Array<ProgramInputTensorInfoDependency>(inputTensors.length).fill('dims'))}`;\n      return key;\n    };\n\nclass AdapterInfoImpl implements AdapterInfo {\n  readonly architecture?: string;\n  readonly vendor?: string;\n\n  constructor(adapterInfo: GPUAdapterInfo) {\n    if (adapterInfo) {\n      this.architecture = adapterInfo.architecture;\n      this.vendor = adapterInfo.vendor;\n    }\n  }\n\n  isArchitecture(architecture: GpuArchitecture): boolean {\n    return this.architecture === architecture;\n  }\n\n  isVendor(vendor: GpuVendor): boolean {\n    return this.vendor === vendor;\n  }\n}\n\n/**\n * this class is designed to store status and being used as a singleton for JSEP. It will be passed to jsepInit() as\n * the first parameter so that it is stored for future use.\n */\nexport class WebGpuBackend {\n  adapterInfo: AdapterInfoImpl;\n  device: GPUDevice;\n  /**\n   * an instance of GpuDataManager to manage a GpuDataId -> GpuBuffer mapping\n   */\n  gpuDataManager: GpuDataManager;\n  /**\n   * an instance of ProgramManager to build and run WebGPU compute shader program, and manage a ProgramKey -> Program\n   * artifacts mapping\n   */\n  programManager: ProgramManager;\n\n  /**\n   * representing the session ID of which is currently being run.\n   * `null` means no session is being run.\n   * only valid when session.run is executed.\n   */\n  currentSessionId: number|null = null;\n\n  /**\n   * representing the kernel ID of which is currently being computed (CPU code perspective).\n   * `null` means no kernel is being computed.\n   * only one kernel can be computed at a moment.\n   */\n  currentKernelId: number|null = null;\n  /**\n   * a list of temporary GPU data for the current kernel. should release when the kernel done computation.\n   */\n  private temporaryData: GpuData[];\n  /**\n   * a KernelID -> a GPU data list, which stores persistent GPU data owned by the specific kernel.\n   */\n  private kernelPersistentData: Map<number, GpuData[]>;\n  /**\n   * a KernelID -> a custom data, which stores custom data owned by the specific kernel.\n   */\n  private kernelCustomData: Map<number, {[key: string]: unknown}>;\n  /**\n   * get the custom data of the current kernel\n   */\n  get currentKernelCustomData(): {[key: string]: unknown} {\n    if (this.currentKernelId === null) {\n      throw new Error('currentKernelCustomData(): currentKernelId is null. (should not happen)');\n    }\n\n    let data = this.kernelCustomData.get(this.currentKernelId);\n    if (!data) {\n      data = {};\n      this.kernelCustomData.set(this.currentKernelId, data);\n    }\n\n    return data;\n  }\n\n  // KernelID -> kernelInfo mapping\n  kernels: Map<number, KernelInfo>;\n  private commandEncoder: GPUCommandEncoder|null = null;\n  private computePassEncoder: GPUComputePassEncoder|null = null;\n  maxDispatchNumber = 16;\n  pendingDispatchNumber = 0;\n\n  // info of kernels pending submission for a single batch\n  private pendingKernels: PendingKernelInfo[] = [];\n  // queryReadBuffer -> pendingKernels mapping for all the batches\n  private pendingQueries: Map<GPUBuffer, PendingKernelInfo[]> = new Map();\n  private queryResolveBuffer?: GPUBuffer;\n  private querySet?: GPUQuerySet;\n  private queryTimeBase?: bigint;\n  queryType: TimestampQuery;\n\n  env: Env;\n  sessionStatus: SessionState = 'default';\n  /**\n   * a SessionID -> CommandInfo[] mapping. It's used to record all GPU commands for corresponding session.\n   */\n  capturedCommandList: Map<number, CommandInfo[]> = new Map();\n\n  /**\n   * a SessionID -> PendingKernelInfo[] mapping for profiling.\n   */\n  private capturedPendingKernels: Map<number, PendingKernelInfo[]> = new Map();\n\n  /**\n   * a SessionID -> a Map of (InputOutputIndex -> [ID, GPUBuffer]) mapping.\n   */\n  sessionExternalDataMapping: Map<number, Map<number, [number, GPUBuffer]>> = new Map();\n\n  async initialize(env: Env, adapter: GPUAdapter): Promise<void> {\n    this.env = env;\n    const requiredFeatures: GPUFeatureName[] = [];\n    const deviceDescriptor: GPUDeviceDescriptor = {\n      requiredLimits: {\n        maxComputeWorkgroupStorageSize: adapter.limits.maxComputeWorkgroupStorageSize,\n        maxComputeWorkgroupsPerDimension: adapter.limits.maxComputeWorkgroupsPerDimension,\n        maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,\n        maxBufferSize: adapter.limits.maxBufferSize,\n        maxComputeInvocationsPerWorkgroup: adapter.limits.maxComputeInvocationsPerWorkgroup,\n        maxComputeWorkgroupSizeX: adapter.limits.maxComputeWorkgroupSizeX,\n        maxComputeWorkgroupSizeY: adapter.limits.maxComputeWorkgroupSizeY,\n        maxComputeWorkgroupSizeZ: adapter.limits.maxComputeWorkgroupSizeZ,\n      },\n      requiredFeatures,\n    };\n\n    if (adapter.features.has('chromium-experimental-timestamp-query-inside-passes')) {\n      requiredFeatures.push('chromium-experimental-timestamp-query-inside-passes' as GPUFeatureName);\n    } else if (adapter.features.has('timestamp-query')) {\n      requiredFeatures.push('timestamp-query');\n    }\n    if (adapter.features.has('shader-f16')) {\n      requiredFeatures.push('shader-f16');\n    }\n\n    this.device = await adapter.requestDevice(deviceDescriptor);\n    this.adapterInfo = new AdapterInfoImpl(await adapter.requestAdapterInfo());\n    this.gpuDataManager = createGpuDataManager(this);\n    this.programManager = new ProgramManager(this);\n    this.kernels = new Map();\n    this.kernelPersistentData = new Map();\n    this.kernelCustomData = new Map();\n\n    // set up flags for logger\n    configureLogger(env.logLevel!, !!env.debug);\n\n    // TODO: set up flags\n\n    this.device.onuncapturederror = ev => {\n      if (ev.error instanceof GPUValidationError) {\n        // eslint-disable-next-line no-console\n        console.error(`An uncaught WebGPU validation error was raised: ${ev.error.message}`);\n      }\n    };\n\n    Object.defineProperty(\n        this.env.webgpu, 'device', {value: this.device, writable: false, enumerable: true, configurable: false});\n    Object.defineProperty(\n        this.env.webgpu, 'adapter', {value: adapter, writable: false, enumerable: true, configurable: false});\n\n    // init queryType, which is necessary for InferenceSession.create\n    this.setQueryType();\n  }\n\n  dispose(): void {\n    if (typeof this.querySet !== 'undefined') {\n      this.querySet.destroy();\n    }\n    this.gpuDataManager.dispose();\n  }\n\n  getCommandEncoder(): GPUCommandEncoder {\n    if (!this.commandEncoder) {\n      this.commandEncoder = this.device.createCommandEncoder();\n    }\n    return this.commandEncoder;\n  }\n\n  getComputePassEncoder(): GPUComputePassEncoder {\n    if (!this.computePassEncoder) {\n      const commandEncoder = this.getCommandEncoder();\n      const computePassDescriptor: GPUComputePassDescriptor = {};\n\n      if (this.queryType === 'at-passes') {\n        computePassDescriptor.timestampWrites = {\n          querySet: this.querySet!,\n          beginningOfPassWriteIndex: this.pendingDispatchNumber * 2,\n          endOfPassWriteIndex: this.pendingDispatchNumber * 2 + 1,\n        };\n      }\n\n      this.computePassEncoder = commandEncoder.beginComputePass(computePassDescriptor);\n    }\n    return this.computePassEncoder;\n  }\n\n  endComputePass(): void {\n    if (this.computePassEncoder) {\n      this.computePassEncoder.end();\n      this.computePassEncoder = null;\n    }\n  }\n\n  flush(): void {\n    if (!this.commandEncoder) {\n      return;\n    }\n\n    TRACE_FUNC_BEGIN();\n\n    this.endComputePass();\n    let queryReadBuffer: GPUBuffer;\n    if (this.queryType !== 'none') {\n      this.commandEncoder.resolveQuerySet(\n          this.querySet!, 0, this.pendingDispatchNumber * 2, this.queryResolveBuffer!, 0);\n\n      queryReadBuffer = this.device.createBuffer(\n          // eslint-disable-next-line no-bitwise\n          {size: this.pendingDispatchNumber * 2 * 8, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST});\n\n      this.pendingQueries.set(queryReadBuffer, this.pendingKernels);\n      this.pendingKernels = [];\n      this.commandEncoder.copyBufferToBuffer(\n          this.queryResolveBuffer!, 0, queryReadBuffer, 0, this.pendingDispatchNumber * 2 * 8);\n    }\n\n    this.device.queue.submit([this.commandEncoder.finish()]);\n    this.gpuDataManager.refreshPendingBuffers();\n    this.commandEncoder = null;\n    this.pendingDispatchNumber = 0;\n\n    if (this.queryType !== 'none') {\n      void queryReadBuffer!.mapAsync(GPUMapMode.READ).then(() => {\n        const mappedData = new BigUint64Array(queryReadBuffer.getMappedRange());\n        const pendingKernels = this.pendingQueries.get(queryReadBuffer)!;\n        for (let i = 0; i < mappedData.length / 2; i++) {\n          const pendingKernelInfo = pendingKernels[i];\n          const kernelId = pendingKernelInfo.kernelId;\n          const kernelInfo = this.kernels.get(kernelId)!;\n          const kernelType = kernelInfo.kernelType;\n          const kernelName = kernelInfo.kernelName;\n          const programName = pendingKernelInfo.programName;\n          const inputTensorViews = pendingKernelInfo.inputTensorViews;\n          const outputTensorViews = pendingKernelInfo.outputTensorViews;\n          const startTimeU64 = mappedData[i * 2];\n          const endTimeU64 = mappedData[i * 2 + 1];\n\n          if (typeof this.queryTimeBase === 'undefined') {\n            this.queryTimeBase = startTimeU64;\n          }\n\n          const startTime = Number(startTimeU64 - this.queryTimeBase);\n          const endTime = Number(endTimeU64 - this.queryTimeBase);\n\n          if (!Number.isSafeInteger(startTime) || !Number.isSafeInteger(endTime)) {\n            throw new RangeError('incorrect timestamp range');\n          }\n\n          if (this.env.webgpu.profiling?.ondata) {\n            this.env.webgpu.profiling.ondata({\n              version: 1,\n              inputsMetadata: inputTensorViews.map(\n                  value => ({dims: value.dims, dataType: tensorDataTypeEnumToString(value.dataType)})),\n              outputsMetadata: outputTensorViews.map(\n                  value => ({dims: value.dims, dataType: tensorDataTypeEnumToString(value.dataType)})),\n              kernelId,\n              kernelType,\n              kernelName,\n              programName,\n              startTime,\n              endTime,\n            });\n          } else {\n            // if no callback is provided, print the profiling message to console\n            let inputShapes = '';\n            inputTensorViews.forEach((value, i) => {\n              inputShapes += `input[${i}]: [${value.dims}] | ${tensorDataTypeEnumToString(value.dataType)}, `;\n            });\n            let outputShapes = '';\n            outputTensorViews.forEach((value, i) => {\n              outputShapes += `output[${i}]: [${value.dims}] | ${tensorDataTypeEnumToString(value.dataType)}, `;\n            });\n            // eslint-disable-next-line no-console\n            console.log(`[profiling] kernel \"${kernelId}|${kernelType}|${kernelName}|${programName}\" ${inputShapes}${\n                outputShapes}execution time: ${endTime - startTime} ns`);\n          }\n          TRACE('GPU', `${programName}::${startTimeU64}::${endTimeU64}`);\n        }\n        queryReadBuffer.unmap();\n        this.pendingQueries.delete(queryReadBuffer);\n      });\n    }\n    TRACE_FUNC_END();\n  }\n\n  /**\n   * run a WebGPU program.\n   * @param program a ProgramInfo instance\n   * @param inputTensorViews a TensorView array. each element represents a value already exists in GPU.\n   * @param outputIndices an indices array. each element can be either -1 (temporary data), -2 (persistent data) or an\n   * index to the kernel's output.\n   * @param createKernelOutput a callback function that create a value to kernel's output with the given index\n   * @param createIntermediateOutput a callback function that create a value as a intermediate value, either temporary\n   * or persistent (owned by the current kernel)\n   * @returns a TensorView array representing the result.\n   */\n  run(program: ProgramInfo, inputTensorViews: readonly TensorView[], outputIndices: readonly number[],\n      createKernelOutput: (index: number, dataType: number, dims: readonly number[]) => TensorView,\n      createIntermediateOutput: (dataType: number, dims: readonly number[]) => TensorView,\n      outputCount: number): TensorView[] {\n    TRACE_FUNC_BEGIN(program.name);\n    // create info for inputs\n    const inputDatas: GpuData[] = [];\n    for (let i = 0; i < inputTensorViews.length; ++i) {\n      const data = inputTensorViews[i].data;\n      // if tensor view data is 0, it means the output is zero-sized tensor, and there is no GPU data for it.\n      if (data === 0) {\n        continue;\n      }\n      const gpuData = this.gpuDataManager.get(data);\n      if (!gpuData) {\n        throw new Error(`no GPU data for input: ${data}`);\n      }\n      inputDatas.push(gpuData);\n    }\n\n    const {outputs, dispatchGroup, programUniforms} = program.getRunData(inputTensorViews);\n\n    // check output indices\n    const validatedOutputIndices = outputIndices.length === 0 ? outputs.map((_, i) => i) : outputIndices;\n    if (validatedOutputIndices.length !== outputs.length) {\n      throw new Error(`Output size ${validatedOutputIndices.length} must be equal to ${outputs.length}.`);\n    }\n\n    // create info for outputs\n    const outputTensorViews: TensorView[] = [];\n    const outputDatas: GpuData[] = [];\n    for (let i = 0; i < outputs.length; ++i) {\n      // value -1 and -2 are used for creating temporary and persistent outputs.\n      // value -3 is used for placeholder output. So -3, -2, -1 and 0, 1, 2, ... are valid\n      // output indices. see type definition of ComputeContextInputsOutputsMapping for more details.\n      if (!Number.isInteger(validatedOutputIndices[i]) || validatedOutputIndices[i] < -3 ||\n          validatedOutputIndices[i] >= outputCount) {\n        throw new Error(`Invalid output index: ${validatedOutputIndices[i]}`);\n      }\n      if (validatedOutputIndices[i] === -3) {\n        continue;\n      }\n      const isTemporary = validatedOutputIndices[i] === -1;\n      const isPersistent = validatedOutputIndices[i] === -2;\n      const tensorView = (isTemporary || isPersistent) ?\n          createIntermediateOutput(outputs[i].dataType, outputs[i].dims) :\n          createKernelOutput(validatedOutputIndices[i], outputs[i].dataType, outputs[i].dims);\n      outputTensorViews.push(tensorView);\n      // if tensor view data is 0, it means the output is zero-sized tensor, and there is no GPU data for it.\n      if (tensorView.data === 0) {\n        continue;\n      }\n      const gpuData = this.gpuDataManager.get(tensorView.data);\n      if (!gpuData) {\n        throw new Error(`no GPU data for output: ${tensorView.data}`);\n      }\n      if (isTemporary) {\n        this.temporaryData.push(gpuData);\n      }\n      if (isPersistent) {\n        let persistentData = this.kernelPersistentData.get(this.currentKernelId!);\n        if (!persistentData) {\n          persistentData = [];\n          this.kernelPersistentData.set(this.currentKernelId!, persistentData);\n        }\n        persistentData.push(gpuData);\n      }\n      outputDatas.push(gpuData);\n    }\n\n    // when there are any zero-sized tensor in the inputs or outputs, we should report error unless all outputs are\n    // zero-sized tensors.\n    if (inputDatas.length !== inputTensorViews.length || outputDatas.length !== outputTensorViews.length) {\n      // if all outputs are zero-sized tensors, there is no need to run the program.\n      if (outputDatas.length === 0) {\n        TRACE_FUNC_END(program.name);\n        return outputTensorViews;\n      }\n      // if some outputs are zero-sized tensors, report an error.\n      //\n      // TODO: so far we don't see any use case that outputs include both zero-sized tensors and non-zero-sized tensors.\n      // If we see such use case, we need to make a change here to support it.\n      throw new Error(\n          `Program ${program.name} has zero-sized tensor(s) in inputs or outputs. This is not supported now.`);\n    }\n\n    // load uniforms\n    // TODO: add cache for uniform (is it necessary?)\n    //\n    let uniformBufferBinding: GPUBindingResource|undefined;\n    if (programUniforms) {\n      let currentOffset = 0;\n      const offsets: number[] = [];\n\n      programUniforms.forEach(v => {\n        const data = typeof v.data === 'number' ? [v.data] : v.data;\n        if (data.length === 0) {\n          return;\n        }\n        // https://www.w3.org/TR/WGSL/#alignof\n        const sizeOfElement = v.type === DataType.float16 ? 2 : 4;\n        let sizeOfVecOrMat;\n        let baseAlignment;\n        if (v.type === DataType.float16) {\n          baseAlignment = data.length > 4 ? 16 : (data.length > 2 ? 8 : data.length * sizeOfElement);\n          sizeOfVecOrMat = data.length > 4 ? 16 : sizeOfElement * data.length;\n        } else {\n          baseAlignment = data.length <= 2 ? data.length * sizeOfElement : 16;\n          sizeOfVecOrMat = 16;\n        }\n        currentOffset = Math.ceil(currentOffset / baseAlignment) * baseAlignment;\n        offsets.push(currentOffset);\n        // For non-float16 type, when data.length > 4, the uniform variable is of type array<vec4<i32|u32|f32>,N>, where\n        // N = Math.ceil(data.length / 4) and SizeOf(vec4<i32|u32|f32>) = 16. The total byte length is N *\n        // SizeOf(vec4<i32|u32|f32>). For float16 type, when data.length > 4, the uniform variable is of type\n        // array<mat2x4<f16>,N>, where N = Math.ceil(data.length / 8) and SizeOf(mat2x4<f16>) = 16. The total byte\n        // length is N * SizeOf(mat2x4<f16>).\n        const elementPerVecOrMat = v.type === DataType.float16 ? 8 : 4;\n        currentOffset += data.length > 4 ? Math.ceil(data.length / elementPerVecOrMat) * sizeOfVecOrMat :\n                                           data.length * sizeOfElement;\n      });\n\n      // Meet alignment of struct here: https://www.w3.org/TR/WGSL/#alignment-and-size. For simplicity, set\n      // maxAlignmentOfField to 16 since the underlying buffer has been rounded up to 16.\n      const maxAlignmentOfField = 16;\n      currentOffset = Math.ceil(currentOffset / maxAlignmentOfField) * maxAlignmentOfField;\n      const arrayBuffer = new ArrayBuffer(currentOffset);\n      programUniforms.forEach((v, i) => {\n        const offset = offsets[i];\n        const data = typeof v.data === 'number' ? [v.data] : v.data;\n        if (v.type === DataType.int32) {\n          new Int32Array(arrayBuffer, offset, data.length).set(data);\n        } else if (v.type === DataType.uint32) {\n          new Uint32Array(arrayBuffer, offset, data.length).set(data);\n        } else if (v.type === DataType.float16) {\n          // TODO: use Float16Array.\n          new Uint16Array(arrayBuffer, offset, data.length).set(data);\n        } else if (v.type === DataType.float) {\n          new Float32Array(arrayBuffer, offset, data.length).set(data);\n        } else {\n          throw new Error(`Unsupported uniform type: ${tensorDataTypeEnumToString(v.type)}`);\n        }\n      });\n\n      const uniformBufferData =\n          // eslint-disable-next-line no-bitwise\n          this.gpuDataManager.create(currentOffset, GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM);\n      this.device.queue.writeBuffer(uniformBufferData.buffer, 0, arrayBuffer, 0, currentOffset);\n      this.gpuDataManager.release(uniformBufferData.id);\n      uniformBufferBinding = {offset: 0, size: currentOffset, buffer: uniformBufferData.buffer};\n    }\n\n    const normalizedDispatchGroup = this.programManager.normalizeDispatchGroupSize(dispatchGroup);\n    const is1DimensionDispatch = normalizedDispatchGroup[1] === 1 && normalizedDispatchGroup[2] === 1;\n    // get program info\n    const key = getProgramInfoUniqueKey(program, inputTensorViews, is1DimensionDispatch);\n    let artifact = this.programManager.getArtifact(key);\n    if (!artifact) {\n      artifact = this.programManager.build(program, normalizedDispatchGroup);\n      this.programManager.setArtifact(key, artifact);\n      LOG_DEBUG('info', () => `[artifact] key: ${key}, programName: ${program.name}`);\n    }\n\n    // validate uniform variables\n    if (programUniforms && artifact.uniformVariablesInfo) {\n      if (programUniforms.length !== artifact.uniformVariablesInfo.length) {\n        throw new Error(`Uniform variables count mismatch: expect ${artifact.uniformVariablesInfo.length}, got ${\n            programUniforms.length} in program \"${artifact.programInfo.name}\".`);\n      }\n      for (let i = 0; i < programUniforms.length; i++) {\n        const uniform = programUniforms[i];\n        const actualType = uniform.type;\n        const actualLength = typeof uniform.data === 'number' ? 1 : uniform.data.length;\n        const [type, length] = artifact.uniformVariablesInfo[i];\n        if (actualType !== type || actualLength !== length) {\n          throw new Error(`Uniform variable ${i} mismatch: expect type ${type} with size ${length}, got type ${\n              actualType} with size ${actualLength} in program \"${artifact.programInfo.name}\".`);\n        }\n      }\n    }\n\n    LOG_DEBUG(\n        'info',\n        () => `[ProgramManager] run \"${program.name}\" (key=${key}) with ${normalizedDispatchGroup[0]}x${\n            normalizedDispatchGroup[1]}x${normalizedDispatchGroup[2]}`);\n\n    if (this.queryType !== 'none' || this.sessionStatus === 'capturing') {\n      const pendingKernelInfo: PendingKernelInfo = {\n        kernelId: this.currentKernelId!,\n        programName: artifact.programInfo.name,\n        inputTensorViews,\n        outputTensorViews,\n      };\n      this.pendingKernels.push(pendingKernelInfo);\n\n      if (this.sessionStatus === 'capturing') {\n        const sessionPendingKernels = this.capturedPendingKernels.get(this.currentSessionId!);\n        sessionPendingKernels!.push(pendingKernelInfo);\n      }\n    }\n\n    this.programManager.run(artifact, inputDatas, outputDatas, normalizedDispatchGroup, uniformBufferBinding);\n\n    TRACE_FUNC_END(program.name);\n    return outputTensorViews;\n  }\n\n  upload(gpuDataId: number, data: Uint8Array): void {\n    this.gpuDataManager.upload(gpuDataId, data);\n  }\n\n  memcpy(src: number, dst: number): void {\n    this.gpuDataManager.memcpy(src, dst);\n  }\n\n  async download(gpuDataId: number, getTargetBuffer: () => Uint8Array): Promise<void> {\n    // the underlying buffer may be changed after the async function is called. so we use a getter function to make sure\n    // the buffer is up-to-date.\n    await this.gpuDataManager.download(gpuDataId, getTargetBuffer);\n  }\n\n  alloc(size: number): number {\n    return this.gpuDataManager.create(size).id;\n  }\n\n  free(ptr: number): number {\n    return this.gpuDataManager.release(ptr);\n  }\n\n  createKernel(kernelType: string, kernelId: number, attribute: unknown, kernelName: string): void {\n    const op = WEBGPU_OP_RESOLVE_RULES.get(kernelType);\n    if (!op) {\n      throw new Error(`kernel not implemented: ${kernelType}`);\n    }\n\n    const kernelInfo: KernelInfo = {\n      kernelType,\n      kernelName,\n      kernelEntry: op[0],\n      attributes: [op[1], attribute],\n    };\n    this.kernels.set(kernelId, kernelInfo);\n  }\n\n  releaseKernel(kernelId: number): void {\n    const persistentData = this.kernelPersistentData.get(kernelId);\n    if (persistentData) {\n      for (const data of persistentData) {\n        this.gpuDataManager.release(data.id);\n      }\n      this.kernelPersistentData.delete(kernelId);\n    }\n\n    this.kernelCustomData.delete(kernelId);\n    this.kernels.delete(kernelId);\n  }\n\n  computeKernel(kernelId: number, context: ComputeContext, errors: Array<Promise<string|null>>): number {\n    const kernel = this.kernels.get(kernelId);\n    if (!kernel) {\n      throw new Error(`kernel not created: ${kernelId}`);\n    }\n    const kernelType = kernel.kernelType;\n    const kernelName = kernel.kernelName;\n    const kernelEntry = kernel.kernelEntry;\n    const attributes = kernel.attributes;\n    if (this.currentKernelId !== null) {\n      throw new Error(`kernel \"[${kernelType}] ${kernelName}\" is not allowed to be called recursively`);\n    }\n    this.currentKernelId = kernelId;\n\n    // parse attributes if necessary\n    if (attributes[0]) {\n      attributes[1] = attributes[0](attributes[1]);\n      attributes[0] = undefined;\n    }\n\n    LOG_DEBUG('info', () => `[WebGPU] Start to run kernel \"[${kernelType}] ${kernelName}\"...`);\n\n    const useErrorScope = this.env.debug;\n\n    this.temporaryData = [];\n    try {\n      if (useErrorScope) {\n        this.device.pushErrorScope('validation');\n      }\n\n      kernelEntry(context, attributes[1]);\n      return 0;  // ORT_OK\n    } catch (e) {\n      errors.push(Promise.resolve(`[WebGPU] Kernel \"[${kernelType}] ${kernelName}\" failed. ${e}`));\n      return 1;  // ORT_FAIL\n    } finally {\n      if (useErrorScope) {\n        errors.push(this.device.popErrorScope().then(\n            err => err ? `GPU validation error for kernel \"[${kernelType}] ${kernelName}\": ${err.message}` : null));\n      }\n\n      for (const data of this.temporaryData) {\n        this.gpuDataManager.release(data.id);\n      }\n      this.temporaryData = [];\n      this.currentKernelId = null;\n    }\n  }\n\n  // #region external buffer\n  registerBuffer(sessionId: number, index: number, buffer: GPUBuffer, size: number): number {\n    let sessionInputOutputMapping = this.sessionExternalDataMapping.get(sessionId);\n    if (!sessionInputOutputMapping) {\n      sessionInputOutputMapping = new Map();\n      this.sessionExternalDataMapping.set(sessionId, sessionInputOutputMapping);\n    }\n\n    const previousBuffer = sessionInputOutputMapping.get(index);\n    const id = this.gpuDataManager.registerExternalBuffer(buffer, size, previousBuffer?.[1]);\n    sessionInputOutputMapping.set(index, [id, buffer]);\n    return id;\n  }\n  unregisterBuffers(sessionId: number): void {\n    const sessionInputOutputMapping = this.sessionExternalDataMapping.get(sessionId);\n    if (sessionInputOutputMapping) {\n      sessionInputOutputMapping.forEach(bufferInfo => this.gpuDataManager.unregisterExternalBuffer(bufferInfo[1]));\n      this.sessionExternalDataMapping.delete(sessionId);\n    }\n  }\n  getBuffer(gpuDataId: number): GPUBuffer {\n    const gpuData = this.gpuDataManager.get(gpuDataId);\n    if (!gpuData) {\n      throw new Error(`no GPU data for buffer: ${gpuDataId}`);\n    }\n    return gpuData.buffer;\n  }\n  createDownloader(gpuBuffer: GPUBuffer, size: number, type: Tensor.GpuBufferDataTypes):\n      () => Promise<Tensor.DataType> {\n    return async () => {\n      const data = await downloadGpuData(this, gpuBuffer, size);\n      return createView(data.buffer, type);\n    };\n  }\n  // #endregion\n  writeTimestamp(index: number): void {\n    if (this.queryType !== 'inside-passes') {\n      return;\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (this.computePassEncoder as any).writeTimestamp(this.querySet, index);\n  }\n  setQueryType(): void {\n    this.queryType = 'none';\n    if (this.env.webgpu.profiling?.mode === 'default' ||\n        (typeof this.env.trace === 'undefined' ? this.env.wasm.trace : this.env.trace)) {\n      if (this.device.features.has('chromium-experimental-timestamp-query-inside-passes')) {\n        this.queryType = 'inside-passes';\n      } else if (this.device.features.has('timestamp-query')) {\n        this.queryType = 'at-passes';\n      }\n\n      if (this.queryType !== 'none' && typeof this.querySet === 'undefined') {\n        this.querySet = this.device.createQuerySet({\n          type: 'timestamp',\n          count: this.maxDispatchNumber * 2,\n        });\n        this.queryResolveBuffer = this.device.createBuffer(\n            // eslint-disable-next-line no-bitwise\n            {size: this.maxDispatchNumber * 2 * 8, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});\n      }\n    }\n  }\n\n  captureBegin(): void {\n    LOG_DEBUG('info', 'captureBegin');\n    if (!this.capturedCommandList.get(this.currentSessionId!)) {\n      this.capturedCommandList.set(this.currentSessionId!, []);\n    }\n    if (!this.capturedPendingKernels.get(this.currentSessionId!)) {\n      this.capturedPendingKernels.set(this.currentSessionId!, []);\n    }\n    // flush the left commands before we change the status.\n    this.flush();\n    this.sessionStatus = 'capturing';\n  }\n  captureEnd(): void {\n    LOG_DEBUG('info', 'captureEnd');\n    // flush the left commands before we change the status.\n    this.flush();\n    this.sessionStatus = 'default';\n  }\n  replay(): void {\n    LOG_DEBUG('info', 'replay');\n    this.sessionStatus = 'replaying';\n    const sessionCommandList = this.capturedCommandList.get(this.currentSessionId!);\n    const sessionPendingKernels = this.capturedPendingKernels.get(this.currentSessionId!);\n    const length = sessionCommandList!.length;\n    this.pendingKernels = [];\n    for (let i = 0; i < length; i++) {\n      const computePassEncoder = this.getComputePassEncoder();\n      const command = sessionCommandList![i];\n      this.writeTimestamp(this.pendingDispatchNumber * 2);\n      computePassEncoder.setPipeline(command.computePipeline);\n      computePassEncoder.setBindGroup(0, command.bindGroup);\n      computePassEncoder.dispatchWorkgroups(...command.dispatchGroup);\n      this.writeTimestamp(this.pendingDispatchNumber * 2 + 1);\n      this.pendingDispatchNumber++;\n      if (this.queryType !== 'none') {\n        this.pendingKernels.push(sessionPendingKernels![i]);\n      }\n      if (this.pendingDispatchNumber >= this.maxDispatchNumber || this.queryType === 'at-passes') {\n        this.endComputePass();\n      }\n      if (this.pendingDispatchNumber >= this.maxDispatchNumber) {\n        this.flush();\n      }\n    }\n    // flush the left commands before we change the status.\n    this.flush();\n    this.sessionStatus = 'default';\n  }\n\n  onReleaseSession(sessionId: number): void {\n    this.unregisterBuffers(sessionId);\n    if (this.capturedCommandList.has(sessionId)) {\n      this.capturedCommandList.delete(sessionId);\n    }\n    if (this.capturedPendingKernels.has(sessionId)) {\n      this.capturedPendingKernels.delete(sessionId);\n    }\n    this.gpuDataManager.onReleaseSession(sessionId);\n  }\n\n  onRunStart(sessionId: number): void {\n    this.currentSessionId = sessionId;\n    this.setQueryType();\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Env} from 'onnxruntime-common';\n\nimport {OrtWasmModule} from '../binding/ort-wasm';\nimport {DataType, getTensorElementSize} from '../wasm-common';\n\nimport {WebGpuBackend} from './backend-webgpu';\nimport {LOG_DEBUG} from './log';\nimport {TensorView} from './tensor-view';\nimport {ShapeUtil} from './util';\nimport {AdapterInfo, ComputeContext, ComputeContextInputsOutputsMapping, ProgramInfo} from './webgpu/types';\n\n/* eslint-disable no-bitwise */\n\nclass TensorViewImpl implements TensorView {\n  constructor(\n      private module: OrtWasmModule, public readonly dataType: number, public readonly data: number,\n      public readonly dims: readonly number[]) {}\n\n  getFloat32Array(): Float32Array {\n    if (this.dataType !== DataType.float) {\n      throw new Error('Invalid data type');\n    }\n    const elementCount = ShapeUtil.size(this.dims);\n    return elementCount === 0 ? new Float32Array() :\n                                new Float32Array(this.module.HEAP8.buffer, this.data, elementCount);\n  }\n\n  getBigInt64Array(): BigInt64Array {\n    if (this.dataType !== DataType.int64) {\n      throw new Error('Invalid data type');\n    }\n    const elementCount = ShapeUtil.size(this.dims);\n    return elementCount === 0 ? new BigInt64Array() :\n                                new BigInt64Array(this.module.HEAP8.buffer, this.data, elementCount);\n  }\n\n  getInt32Array(): Int32Array {\n    if (this.dataType !== DataType.int32) {\n      throw new Error('Invalid data type');\n    }\n    const elementCount = ShapeUtil.size(this.dims);\n    return elementCount === 0 ? new Int32Array() : new Int32Array(this.module.HEAP8.buffer, this.data, elementCount);\n  }\n\n  reshape(newDims: readonly number[]): TensorView {\n    if (ShapeUtil.size(newDims) !== ShapeUtil.size(this.dims)) {\n      throw new Error('Invalid new shape');\n    }\n    return new TensorViewImpl(this.module, this.dataType, this.data, newDims);\n  }\n}\n\nclass ComputeContextImpl implements ComputeContext {\n  readonly adapterInfo: AdapterInfo;\n  readonly opKernelContext: number;\n  readonly inputs: readonly TensorView[];\n  readonly outputCount: number;\n  get kernelCustomData(): {[key: string]: unknown} {\n    return this.backend.currentKernelCustomData;\n  }\n  get customDataBuffer(): Uint8Array {\n    return this.module.HEAPU8.subarray(this.customDataOffset, this.customDataOffset + this.customDataSize);\n  }\n  private customDataOffset = 0;\n  private customDataSize = 0;\n  constructor(private module: OrtWasmModule, private backend: WebGpuBackend, contextDataOffset: number) {\n    this.adapterInfo = backend.adapterInfo;\n    const heapU32 = module.HEAPU32;\n\n    // extract context data\n    let dataIndex = (contextDataOffset >>> 2);\n    this.opKernelContext = heapU32[dataIndex++];\n    const inputCount = heapU32[dataIndex++];\n    this.outputCount = heapU32[dataIndex++];\n    this.customDataOffset = heapU32[dataIndex++];\n    this.customDataSize = heapU32[dataIndex++];\n\n    const inputs: TensorView[] = [];\n    for (let i = 0; i < inputCount; i++) {\n      const dataType = heapU32[dataIndex++];\n      const data = heapU32[dataIndex++];\n      const dim = heapU32[dataIndex++];\n      const dims: number[] = [];\n      for (let d = 0; d < dim; d++) {\n        dims.push(heapU32[dataIndex++]);\n      }\n      inputs.push(new TensorViewImpl(module, dataType, data, dims));\n    }\n    this.inputs = inputs;\n  }\n\n  getMaxComputeWorkgroupSizes(): [number, number, number] {\n    return [\n      this.backend.device.limits.maxComputeWorkgroupSizeX, this.backend.device.limits.maxComputeWorkgroupSizeY,\n      this.backend.device.limits.maxComputeWorkgroupSizeZ\n    ];\n  }\n\n  getMaxComputeWorkgroupStoragesize(): number {\n    return this.backend.device.limits.maxComputeWorkgroupStorageSize;\n  }\n\n  compute(program: ProgramInfo, inputsOutputsMapping?: ComputeContextInputsOutputsMapping): TensorView[] {\n    // prepare inputs. inputs should always be valid data.\n    const mappedInputs =\n        inputsOutputsMapping?.inputs?.map(i => typeof i === 'number' ? this.inputs[i] : i) ?? this.inputs;\n    // prepare outputs.\n    const outputIndices = inputsOutputsMapping?.outputs ?? [];\n    const createKernelOutput = (index: number, dataType: number, dims: readonly number[]): TensorView =>\n        new TensorViewImpl(this.module, dataType, this.output(index, dims), dims);\n    const createTemporaryOutput = (dataType: number, dims: readonly number[]): TensorView => {\n      const elementSize = getTensorElementSize(dataType);\n      if (!elementSize) {\n        throw new Error(`Unsupported data type: ${dataType}`);\n      }\n      const bufferSize = elementSize * ShapeUtil.size(dims);\n      const gpuDataId = bufferSize > 0 ? this.backend.gpuDataManager.create(bufferSize).id : 0;\n      return new TensorViewImpl(this.module, dataType, gpuDataId, dims);\n    };\n    return this.backend.run(\n        program, mappedInputs, outputIndices, createKernelOutput, createTemporaryOutput, this.outputCount);\n  }\n\n  output(index: number, dims: readonly number[]): number {\n    const stack = this.module.stackSave();\n    try {\n      const data = this.module.stackAlloc((1 + dims.length) * 4 /* sizeof(size_t) */);\n      let offset = data >> 2;\n      this.module.HEAPU32[offset++] = dims.length;\n      for (let i = 0; i < dims.length; i++) {\n        this.module.HEAPU32[offset++] = dims[i];\n      }\n      return this.module._JsepOutput!(this.opKernelContext, index, data);\n    } catch (e) {\n      throw new Error(\n          `Failed to generate kernel's output[${index}] with dims [${dims}]. ` +\n          'If you are running with pre-allocated output, please make sure the output type/dims are correct. ' +\n          `Error: ${e}`);\n    } finally {\n      this.module.stackRestore(stack);\n    }\n  }\n}\n\n/**\n * Initialize JSEP with WebGPU backend.\n *\n * This function will be called after the WebAssembly module is loaded and initialized (\"_OrtInit\" is called), once for\n * each of the following EPs if they are specified:\n * - \"webgpu\"\n * - \"webnn\"\n *\n * For WebGPU, this function expects:\n *  - WebGPU is enabled in build (BUILD_DEFS.DISABLE_WEBGPU === false).\n *  - WebGPU is available in current environment. (a valid GPUAdapter is passed in)\n *\n * For WebNN, this function expects:\n * - WebNN is enabled in build (BUILD_DEFS.DISABLE_WEBGPU === false).\n * - WebNN is available in current environment. (navigator.ml is not undefined)\n *\n * If the WebAssembly module is not built with JSEP support, this function will throw an error. This will invalidate\n * 'webgpu'/'webnn' backend.\n *\n * @param name - the name of the EP, either \"webgpu\" or \"webnn\"\n * @param module - the ORT WebAssembly module\n * @param env - the ORT environment variable (ort.env)\n * @param gpuAdapter - the pre-created GPU adapter\n */\nexport const init =\n    async(name: 'webgpu'|'webnn', module: OrtWasmModule, env: Env, gpuAdapter?: GPUAdapter): Promise<void> => {\n  const jsepInit = module.jsepInit;\n  if (!jsepInit) {\n    throw new Error('Failed to initialize JSEP. The WebAssembly module is not built with JSEP support.');\n  }\n\n  if (name === 'webgpu') {\n    const backend = new WebGpuBackend();\n    await backend.initialize(env, gpuAdapter!);\n\n    jsepInit('webgpu', [\n      // backend\n      backend,\n\n      // jsepAlloc()\n      (size: number) => backend.alloc(size),\n\n      // jsepFree()\n      (ptr: number) => backend.free(ptr),\n\n      // jsepCopy(src, dst, size, isSourceGpu)\n      (src: number, dst: number, size: number, isSourceGpu = false) => {\n        if (isSourceGpu) {\n          LOG_DEBUG('verbose', () => `[WebGPU] jsepCopyGpuToGpu: src=${src}, dst=${dst}, size=${size}`);\n          backend.memcpy(src, dst);\n        } else {\n          LOG_DEBUG('verbose', () => `[WebGPU] jsepCopyCpuToGpu: dataOffset=${src}, gpuDataId=${dst}, size=${size}`);\n          const data = module.HEAPU8.subarray(src >>> 0, (src >>> 0) + size);\n          backend.upload(dst, data);\n        }\n      },\n\n      // jsepCopyAsync(src, dst, size)\n      async(gpuDataId: number, dataOffset: number, size: number):\n          Promise<void> => {\n            LOG_DEBUG(\n                'verbose',\n                () => `[WebGPU] jsepCopyGpuToCpu: gpuDataId=${gpuDataId}, dataOffset=${dataOffset}, size=${size}`);\n\n            await backend.download(\n                gpuDataId, () => module.HEAPU8.subarray(dataOffset >>> 0, (dataOffset >>> 0) + size));\n          },\n\n      // jsepCreateKernel\n      (kernelType: string, kernelId: number, attribute: unknown) => backend.createKernel(\n          kernelType, kernelId, attribute, module.UTF8ToString(module._JsepGetNodeName!(kernelId))),\n\n      // jsepReleaseKernel\n      (kernel: number) => backend.releaseKernel(kernel),\n\n      // jsepRun\n      (kernel: number, contextDataOffset: number, sessionHandle: number, errors: Array<Promise<string|null>>) => {\n        LOG_DEBUG(\n            'verbose',\n            () => `[WebGPU] jsepRun: sessionHandle=${sessionHandle}, kernel=${kernel}, contextDataOffset=${\n                contextDataOffset}`);\n        const context = new ComputeContextImpl(module, backend, contextDataOffset);\n        return backend.computeKernel(kernel, context, errors);\n      },\n      // jsepCaptureBegin\n      () => backend.captureBegin(),\n      // jsepCaptureEnd\n      () => backend.captureEnd(),\n      // jsepReplay\n      () => backend.replay()\n    ]);\n  } else {\n    jsepInit('webnn');\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Env, InferenceSession, Tensor} from 'onnxruntime-common';\n\nimport {SerializableInternalBuffer, SerializableSessionMetadata, SerializableTensorMetadata, TensorMetadata} from './proxy-messages';\nimport {setRunOptions} from './run-options';\nimport {setSessionOptions} from './session-options';\nimport {dataLocationStringToEnum, getTensorElementSize, isGpuBufferSupportedType, logLevelStringToEnum, tensorDataTypeEnumToString, tensorDataTypeStringToEnum, tensorTypeToTypedArrayConstructor} from './wasm-common';\nimport {getInstance} from './wasm-factory';\nimport {allocWasmString, checkLastError} from './wasm-utils';\nimport {loadFile} from './wasm-utils-load-file';\n\n// #region Initializations\n\n/**\n * There are 4 different \"initialization\" steps for ORT. They happen in different places and different time.\n *\n * 1. JavaScript initialization for onnxruntime-common and onnxruntime-web.\n *    This is the first initialization step. In this step, onnxruntime-web calls onnxruntime-common's registerBackend()\n * function multiple times to register all the available backends. The backend registration is very fast. It only\n * registers the backend name with the uninitialized backend object. No heavy initialization is done in this step.\n *    Refer to web/lib/index.ts for the backend registration.\n *\n * 2. WebAssembly artifact initialization.\n *    This happens when any registered wasm backend is used for the first time (ie. `ort.InferenceSession.create()` or\n * `ort.TrainingSession.create()` is called). In this step, onnxruntime-web does the followings:\n *     - create a proxy worker and make sure the proxy worker is ready to receive messages, if proxy is enabled.\n *     - perform feature detection, locate correct WebAssembly artifact path and call the Emscripten generated\n * JavaScript code to initialize the WebAssembly runtime.\n *         - if proxy is enabled, this step happens in the proxy worker using message 'init-wasm'.\n *         - downloading the 'ort-wasm{...}.wasm' file is done in this step.\n *         - if multi-thread is enabled, one or more webworker will be created to initialize the PThread threadpool.\n *\n * 3. ORT environment initialization.\n *    This happens after step 2. In this step, onnxruntime-web performs ONNX Runtime environment initialization.\n * Function `_OrtInit()` is called in this step.\n *     - if proxy is enabled, this step happens in the proxy worker using message 'init-ort'.\n *     - logging level (ort.env.logLevel) and thread number (ort.env.wasm.numThreads) are set in this step.\n *\n * 4. Session initialization.\n *    This happens when `ort.InferenceSession.create()` or `ort.TrainingSession.create()` is called. Unlike the first 3\n * steps (they only called once), this step will be done for each session. In this step, onnxruntime-web does the\n * followings:\n *    If the parameter is a URL:\n *    - download the model data from the URL.\n *    - copy the model data to the WASM heap. (proxy: 'copy-from')\n *    - dereference the model buffer. This step allows the original ArrayBuffer to be garbage collected.\n *    - call `_OrtCreateSession()` to create the session. (proxy: 'create')\n *\n *    If the parameter is a Uint8Array object:\n *    - copy the model data to the WASM heap. (proxy: 'copy-from')\n *    - call `_OrtCreateSession()` to create the session. (proxy: 'create')\n *\n *\n */\n\n/**\n * initialize ORT environment.\n *\n * @param numThreads SetGlobalIntraOpNumThreads(numThreads)\n * @param loggingLevel CreateEnv(static_cast<OrtLoggingLevel>(logging_level))\n */\nconst initOrt = (numThreads: number, loggingLevel: number): void => {\n  const errorCode = getInstance()._OrtInit(numThreads, loggingLevel);\n  if (errorCode !== 0) {\n    checkLastError('Can\\'t initialize onnxruntime.');\n  }\n};\n\n/**\n * intialize runtime environment.\n * @param env passed in the environment config object.\n */\nexport const initRuntime = async(env: Env): Promise<void> => {\n  // init ORT\n  initOrt(env.wasm.numThreads!, logLevelStringToEnum(env.logLevel));\n};\n\n/**\n * perform EP specific initialization.\n *\n * @param env\n * @param epName\n */\nexport const initEp = async(env: Env, epName: string): Promise<void> => {\n  if (!BUILD_DEFS.DISABLE_WEBGPU) {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires\n    const initJsep = require('./jsep/init').init;\n\n    if (epName === 'webgpu') {\n      // perform WebGPU availability check\n      if (typeof navigator === 'undefined' || !navigator.gpu) {\n        throw new Error('WebGPU is not supported in current environment');\n      }\n\n      let adapter = env.webgpu.adapter as GPUAdapter | null;\n      if (!adapter) {\n        // if adapter is not set, request a new adapter.\n        const powerPreference = env.webgpu.powerPreference;\n        if (powerPreference !== undefined && powerPreference !== 'low-power' &&\n            powerPreference !== 'high-performance') {\n          throw new Error(`Invalid powerPreference setting: \"${powerPreference}\"`);\n        }\n        const forceFallbackAdapter = env.webgpu.forceFallbackAdapter;\n        if (forceFallbackAdapter !== undefined && typeof forceFallbackAdapter !== 'boolean') {\n          throw new Error(`Invalid forceFallbackAdapter setting: \"${forceFallbackAdapter}\"`);\n        }\n        adapter = await navigator.gpu.requestAdapter({powerPreference, forceFallbackAdapter});\n        if (!adapter) {\n          throw new Error(\n              'Failed to get GPU adapter. ' +\n              'You may need to enable flag \"--enable-unsafe-webgpu\" if you are using Chrome.');\n        }\n      } else {\n        // if adapter is set, validate it.\n        if (typeof adapter.limits !== 'object' || typeof adapter.features !== 'object' ||\n            typeof adapter.requestDevice !== 'function') {\n          throw new Error('Invalid GPU adapter set in `env.webgpu.adapter`. It must be a GPUAdapter object.');\n        }\n      }\n\n      if (!env.wasm.simd) {\n        throw new Error(\n            'Not supported for WebGPU=ON and SIMD=OFF. Please set `env.wasm.simd` to true when using `webgpu` EP');\n      }\n\n      await initJsep('webgpu', getInstance(), env, adapter);\n    }\n    if (epName === 'webnn') {\n      // perform WebNN availability check\n      if (typeof navigator === 'undefined' || !(navigator as unknown as {ml: unknown}).ml) {\n        throw new Error('WebNN is not supported in current environment');\n      }\n\n      await initJsep('webnn', getInstance(), env);\n    }\n  }\n};\n\n// #endregion Initializations\n\n/**\n * valid data locations for input/output tensors.\n */\ntype SupportedTensorDataLocationForInputOutput = 'cpu'|'cpu-pinned'|'gpu-buffer';\n\ntype IOBindingState = {\n  /**\n   * the handle of IO binding.\n   */\n  readonly handle: number;\n\n  /**\n   * the preferred location for each output tensor.\n   *\n   * value is one of 'cpu', 'cpu-pinned', 'gpu-buffer'.\n   */\n  readonly outputPreferredLocations: readonly SupportedTensorDataLocationForInputOutput[];\n\n  /**\n   * enum value of the preferred location for each output tensor.\n   */\n  readonly outputPreferredLocationsEncoded: readonly number[];\n};\n\n/**\n *  tuple elements are: InferenceSession ID; inputNamesUTF8Encoded; outputNamesUTF8Encoded; bindingState\n */\ntype SessionMetadata = [\n  inferenceSessionId: number, inputNamesUTF8Encoded: number[], outputNamesUTF8Encoded: number[],\n  bindingState: IOBindingState|null, enableGraphCapture: boolean, inputOutputBound: boolean\n];\n\nconst activeSessions = new Map<number, SessionMetadata>();\n\n/**\n * get the input/output count of the session.\n * @param sessionHandle the handle representing the session. should be non-zero.\n * @returns a tuple including 2 numbers, representing the input count and output count.\n */\nconst getSessionInputOutputCount = (sessionHandle: number): [number, number] => {\n  const wasm = getInstance();\n  const stack = wasm.stackSave();\n  try {\n    const dataOffset = wasm.stackAlloc(8);\n    const errorCode = wasm._OrtGetInputOutputCount(sessionHandle, dataOffset, dataOffset + 4);\n    if (errorCode !== 0) {\n      checkLastError('Can\\'t get session input/output count.');\n    }\n    return [wasm.HEAP32[dataOffset / 4], wasm.HEAP32[dataOffset / 4 + 1]];\n  } finally {\n    wasm.stackRestore(stack);\n  }\n};\n\n/**\n * allocate the memory and memcpy the external buffer.\n *\n * @param model - the external buffer containing the model data. Must not be the same buffer as the WASM heap.\n * @returns a 2-elements tuple - the pointer and size of the allocated buffer\n */\nexport const copyFromExternalBuffer = (model: Uint8Array): [number, number] => {\n  const wasm = getInstance();\n  const modelDataOffset = wasm._malloc(model.byteLength);\n  if (modelDataOffset === 0) {\n    throw new Error(`Can't create a session. failed to allocate a buffer of size ${model.byteLength}.`);\n  }\n  wasm.HEAPU8.set(model, modelDataOffset);\n  return [modelDataOffset, model.byteLength];\n};\n\n/**\n * create an inference session from a model data buffer.\n *\n * @param modelData - either a Uint8Array object representing the model data, or a 2-elements tuple containing the\n *     pointer and size of the model data buffer.\n * @param options an optional session options object.\n * @returns a 3-elements tuple containing [session handle, input names, output names]\n */\nexport const createSession = async(\n    modelData: Uint8Array|SerializableInternalBuffer,\n    options?: InferenceSession.SessionOptions): Promise<SerializableSessionMetadata> => {\n  let modelDataOffset: number, modelDataLength: number;\n  const wasm = getInstance();\n\n  if (Array.isArray(modelData)) {\n    // if model data is an array, it must be a 2-elements tuple containing the pointer and size of the model data\n    [modelDataOffset, modelDataLength] = modelData;\n  } else if (modelData.buffer === wasm.HEAPU8.buffer) {\n    // if model data uses the same buffer as the WASM heap, we don't need to copy it.\n    [modelDataOffset, modelDataLength] = [modelData.byteOffset, modelData.byteLength];\n  } else {\n    // otherwise, copy the model data to the WASM heap.\n    [modelDataOffset, modelDataLength] = copyFromExternalBuffer(modelData);\n  }\n\n  let sessionHandle = 0;\n  let sessionOptionsHandle = 0;\n  let ioBindingHandle = 0;\n  let allocs: number[] = [];\n  const inputNamesUTF8Encoded = [];\n  const outputNamesUTF8Encoded = [];\n\n  try {\n    [sessionOptionsHandle, allocs] = setSessionOptions(options);\n\n    if (options?.externalData && wasm.mountExternalData) {\n      const loadingPromises = [];\n      for (const file of options.externalData) {\n        const path = typeof file === 'string' ? file : file.path;\n        loadingPromises.push(loadFile(typeof file === 'string' ? file : file.data).then(data => {\n          wasm.mountExternalData!(path, data);\n        }));\n      }\n\n      // wait for all external data files to be loaded\n      await Promise.all(loadingPromises);\n    }\n\n    sessionHandle = await wasm._OrtCreateSession(modelDataOffset, modelDataLength, sessionOptionsHandle);\n    if (sessionHandle === 0) {\n      checkLastError('Can\\'t create a session.');\n    }\n\n    const [inputCount, outputCount] = getSessionInputOutputCount(sessionHandle);\n\n    const enableGraphCapture = !!options?.enableGraphCapture;\n\n    const inputNames = [];\n    const outputNames = [];\n    const outputPreferredLocations: SupportedTensorDataLocationForInputOutput[] = [];\n    for (let i = 0; i < inputCount; i++) {\n      const name = wasm._OrtGetInputName(sessionHandle, i);\n      if (name === 0) {\n        checkLastError('Can\\'t get an input name.');\n      }\n      inputNamesUTF8Encoded.push(name);\n      inputNames.push(wasm.UTF8ToString(name));\n    }\n    for (let i = 0; i < outputCount; i++) {\n      const name = wasm._OrtGetOutputName(sessionHandle, i);\n      if (name === 0) {\n        checkLastError('Can\\'t get an output name.');\n      }\n      outputNamesUTF8Encoded.push(name);\n      const nameString = wasm.UTF8ToString(name);\n      outputNames.push(nameString);\n\n      if (!BUILD_DEFS.DISABLE_WEBGPU) {\n        if (enableGraphCapture && options?.preferredOutputLocation === undefined) {\n          outputPreferredLocations.push('gpu-buffer');\n          continue;\n        }\n        const location = typeof options?.preferredOutputLocation === 'string' ?\n            options.preferredOutputLocation :\n            options?.preferredOutputLocation?.[nameString] ?? 'cpu';\n        if (location !== 'cpu' && location !== 'cpu-pinned' && location !== 'gpu-buffer') {\n          throw new Error(`Not supported preferred output location: ${location}.`);\n        }\n        if (enableGraphCapture && location !== 'gpu-buffer') {\n          throw new Error(`Not supported preferred output location: ${\n              location}. Only 'gpu-buffer' location is supported when enableGraphCapture is true.`);\n        }\n        outputPreferredLocations.push(location);\n      }\n    }\n\n    // use IO binding only when at least one output is preffered to be on GPU.\n    let bindingState: IOBindingState|null = null;\n    if (!BUILD_DEFS.DISABLE_WEBGPU && outputPreferredLocations.some(l => l === 'gpu-buffer')) {\n      ioBindingHandle = wasm._OrtCreateBinding(sessionHandle);\n      if (ioBindingHandle === 0) {\n        checkLastError('Can\\'t create IO binding.');\n      }\n\n      bindingState = {\n        handle: ioBindingHandle,\n        outputPreferredLocations,\n        outputPreferredLocationsEncoded: outputPreferredLocations.map(l => dataLocationStringToEnum(l)),\n      };\n    }\n\n    activeSessions.set(\n        sessionHandle,\n        [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, bindingState, enableGraphCapture, false]);\n    return [sessionHandle, inputNames, outputNames];\n  } catch (e) {\n    inputNamesUTF8Encoded.forEach(buf => wasm._OrtFree(buf));\n    outputNamesUTF8Encoded.forEach(buf => wasm._OrtFree(buf));\n\n    if (ioBindingHandle !== 0) {\n      wasm._OrtReleaseBinding(ioBindingHandle);\n    }\n\n    if (sessionHandle !== 0) {\n      wasm._OrtReleaseSession(sessionHandle);\n    }\n    throw e;\n  } finally {\n    wasm._free(modelDataOffset);\n    if (sessionOptionsHandle !== 0) {\n      wasm._OrtReleaseSessionOptions(sessionOptionsHandle);\n    }\n    allocs.forEach(alloc => wasm._free(alloc));\n\n    // unmount external data if necessary\n    wasm.unmountExternalData?.();\n  }\n};\n\nexport const releaseSession = (sessionId: number): void => {\n  const wasm = getInstance();\n  const session = activeSessions.get(sessionId);\n  if (!session) {\n    throw new Error(`cannot release session. invalid session id: ${sessionId}`);\n  }\n  const [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture] = session;\n\n  if (ioBindingState) {\n    if (enableGraphCapture) {\n      wasm._OrtClearBoundOutputs(ioBindingState.handle);\n    }\n    wasm._OrtReleaseBinding(ioBindingState.handle);\n  }\n\n  wasm.jsepOnReleaseSession?.(sessionId);\n\n  inputNamesUTF8Encoded.forEach(buf => wasm._OrtFree(buf));\n  outputNamesUTF8Encoded.forEach(buf => wasm._OrtFree(buf));\n  wasm._OrtReleaseSession(sessionHandle);\n  activeSessions.delete(sessionId);\n};\n\nexport const prepareInputOutputTensor =\n    (tensor: TensorMetadata|null, tensorHandles: number[], allocs: number[], sessionId: number, index: number,\n     enableGraphCapture = false): void => {\n      if (!tensor) {\n        tensorHandles.push(0);\n        return;\n      }\n\n      const wasm = getInstance();\n\n      const dataType = tensor[0];\n      const dims = tensor[1];\n      const location = tensor[3];\n\n      let rawData: number;\n      let dataByteLength: number;\n\n      if (dataType === 'string' && location === 'gpu-buffer') {\n        throw new Error('String tensor is not supported on GPU.');\n      }\n\n      if (enableGraphCapture && location !== 'gpu-buffer') {\n        throw new Error(\n            `External buffer must be provided for input/output index ${index} when enableGraphCapture is true.`);\n      }\n\n      if (location === 'gpu-buffer') {\n        const gpuBuffer = tensor[2].gpuBuffer as GPUBuffer;\n        const elementSizeInBytes = getTensorElementSize(tensorDataTypeStringToEnum(dataType))!;\n        dataByteLength = dims.reduce((a, b) => a * b, 1) * elementSizeInBytes;\n\n        const registerBuffer = wasm.jsepRegisterBuffer;\n        if (!registerBuffer) {\n          throw new Error('Tensor location \"gpu-buffer\" is not supported without using WebGPU.');\n        }\n        rawData = registerBuffer(sessionId, index, gpuBuffer, dataByteLength);\n      } else {\n        const data = tensor[2];\n\n        if (Array.isArray(data)) {\n          // string tensor\n          dataByteLength = 4 * data.length;\n          rawData = wasm._malloc(dataByteLength);\n          allocs.push(rawData);\n          let dataIndex = rawData / 4;\n          for (let i = 0; i < data.length; i++) {\n            if (typeof data[i] !== 'string') {\n              throw new TypeError(`tensor data at index ${i} is not a string`);\n            }\n            wasm.HEAPU32[dataIndex++] = allocWasmString(data[i], allocs);\n          }\n        } else {\n          dataByteLength = data.byteLength;\n          rawData = wasm._malloc(dataByteLength);\n          allocs.push(rawData);\n          wasm.HEAPU8.set(new Uint8Array(data.buffer, data.byteOffset, dataByteLength), rawData);\n        }\n      }\n\n      const stack = wasm.stackSave();\n      const dimsOffset = wasm.stackAlloc(4 * dims.length);\n      try {\n        let dimIndex = dimsOffset / 4;\n        dims.forEach(d => wasm.HEAP32[dimIndex++] = d);\n        const tensor = wasm._OrtCreateTensor(\n            tensorDataTypeStringToEnum(dataType), rawData, dataByteLength, dimsOffset, dims.length,\n            dataLocationStringToEnum(location));\n        if (tensor === 0) {\n          checkLastError(`Can't create tensor for input/output. session=${sessionId}, index=${index}.`);\n        }\n        tensorHandles.push(tensor);\n      } finally {\n        wasm.stackRestore(stack);\n      }\n    };\n\n/**\n * perform inference run\n */\nexport const run = async(\n    sessionId: number, inputIndices: number[], inputTensors: TensorMetadata[], outputIndices: number[],\n    outputTensors: Array<TensorMetadata|null>, options: InferenceSession.RunOptions): Promise<TensorMetadata[]> => {\n  const wasm = getInstance();\n  const session = activeSessions.get(sessionId);\n  if (!session) {\n    throw new Error(`cannot run inference. invalid session id: ${sessionId}`);\n  }\n  const sessionHandle = session[0];\n  const inputNamesUTF8Encoded = session[1];\n  const outputNamesUTF8Encoded = session[2];\n  const ioBindingState = session[3];\n  const enableGraphCapture = session[4];\n  const inputOutputBound = session[5];\n\n  const inputCount = inputIndices.length;\n  const outputCount = outputIndices.length;\n\n  let runOptionsHandle = 0;\n  let runOptionsAllocs: number[] = [];\n\n  const inputTensorHandles: number[] = [];\n  const outputTensorHandles: number[] = [];\n  const inputOutputAllocs: number[] = [];\n\n  const beforeRunStack = wasm.stackSave();\n  const inputValuesOffset = wasm.stackAlloc(inputCount * 4);\n  const inputNamesOffset = wasm.stackAlloc(inputCount * 4);\n  const outputValuesOffset = wasm.stackAlloc(outputCount * 4);\n  const outputNamesOffset = wasm.stackAlloc(outputCount * 4);\n\n  try {\n    [runOptionsHandle, runOptionsAllocs] = setRunOptions(options);\n\n    // create input tensors\n    for (let i = 0; i < inputCount; i++) {\n      prepareInputOutputTensor(\n          inputTensors[i], inputTensorHandles, inputOutputAllocs, sessionId, inputIndices[i], enableGraphCapture);\n    }\n\n    // create output tensors\n    for (let i = 0; i < outputCount; i++) {\n      prepareInputOutputTensor(\n          outputTensors[i], outputTensorHandles, inputOutputAllocs, sessionId, inputCount + outputIndices[i],\n          enableGraphCapture);\n    }\n\n    let inputValuesIndex = inputValuesOffset / 4;\n    let inputNamesIndex = inputNamesOffset / 4;\n    let outputValuesIndex = outputValuesOffset / 4;\n    let outputNamesIndex = outputNamesOffset / 4;\n    for (let i = 0; i < inputCount; i++) {\n      wasm.HEAPU32[inputValuesIndex++] = inputTensorHandles[i];\n      wasm.HEAPU32[inputNamesIndex++] = inputNamesUTF8Encoded[inputIndices[i]];\n    }\n    for (let i = 0; i < outputCount; i++) {\n      wasm.HEAPU32[outputValuesIndex++] = outputTensorHandles[i];\n      wasm.HEAPU32[outputNamesIndex++] = outputNamesUTF8Encoded[outputIndices[i]];\n    }\n\n    if (!BUILD_DEFS.DISABLE_WEBGPU && ioBindingState && !inputOutputBound) {\n      const {handle, outputPreferredLocations, outputPreferredLocationsEncoded} = ioBindingState;\n\n      if (inputNamesUTF8Encoded.length !== inputCount) {\n        throw new Error(`input count from feeds (${\n            inputCount}) is expected to be always equal to model's input count (${inputNamesUTF8Encoded.length}).`);\n      }\n\n      // process inputs\n      for (let i = 0; i < inputCount; i++) {\n        const index = inputIndices[i];\n        const errorCode = await wasm._OrtBindInput(handle, inputNamesUTF8Encoded[index], inputTensorHandles[i]);\n        if (errorCode !== 0) {\n          checkLastError(`Can't bind input[${i}] for session=${sessionId}.`);\n        }\n      }\n\n      // process pre-allocated outputs\n      for (let i = 0; i < outputCount; i++) {\n        const index = outputIndices[i];\n        const location = outputTensors[i]?.[3];  // undefined means output is not pre-allocated.\n\n        if (location) {\n          // output is pre-allocated. bind the tensor.\n          const errorCode = wasm._OrtBindOutput(handle, outputNamesUTF8Encoded[index], outputTensorHandles[i], 0);\n          if (errorCode !== 0) {\n            checkLastError(`Can't bind pre-allocated output[${i}] for session=${sessionId}.`);\n          }\n        } else {\n          // output is not pre-allocated. reset preferred location.\n          const errorCode =\n              wasm._OrtBindOutput(handle, outputNamesUTF8Encoded[index], 0, outputPreferredLocationsEncoded[index]);\n          if (errorCode !== 0) {\n            checkLastError(`Can't bind output[${i}] to ${outputPreferredLocations[i]} for session=${sessionId}.`);\n          }\n        }\n      }\n      activeSessions.set(\n          sessionId,\n          [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture, true]);\n    }\n\n    wasm.jsepOnRunStart?.(sessionHandle);\n    let errorCode: number;\n    if (!BUILD_DEFS.DISABLE_WEBGPU && ioBindingState) {\n      errorCode = await wasm._OrtRunWithBinding(\n          sessionHandle, ioBindingState.handle, outputCount, outputValuesOffset, runOptionsHandle);\n    } else {\n      errorCode = await wasm._OrtRun(\n          sessionHandle, inputNamesOffset, inputValuesOffset, inputCount, outputNamesOffset, outputCount,\n          outputValuesOffset, runOptionsHandle);\n    }\n\n    if (errorCode !== 0) {\n      checkLastError('failed to call OrtRun().');\n    }\n\n    const output: TensorMetadata[] = [];\n\n    for (let i = 0; i < outputCount; i++) {\n      const tensor = wasm.HEAPU32[outputValuesOffset / 4 + i];\n      if (tensor === outputTensorHandles[i]) {\n        // output tensor is pre-allocated. no need to copy data.\n        output.push(outputTensors[i]!);\n        continue;\n      }\n\n      const beforeGetTensorDataStack = wasm.stackSave();\n      // stack allocate 4 pointer value\n      const tensorDataOffset = wasm.stackAlloc(4 * 4);\n\n      let keepOutputTensor = false;\n      let type: Tensor.Type|undefined, dataOffset = 0;\n      try {\n        const errorCode = wasm._OrtGetTensorData(\n            tensor, tensorDataOffset, tensorDataOffset + 4, tensorDataOffset + 8, tensorDataOffset + 12);\n        if (errorCode !== 0) {\n          checkLastError(`Can't access output tensor data on index ${i}.`);\n        }\n        let tensorDataIndex = tensorDataOffset / 4;\n        const dataType = wasm.HEAPU32[tensorDataIndex++];\n        dataOffset = wasm.HEAPU32[tensorDataIndex++];\n        const dimsOffset = wasm.HEAPU32[tensorDataIndex++];\n        const dimsLength = wasm.HEAPU32[tensorDataIndex++];\n        const dims = [];\n        for (let i = 0; i < dimsLength; i++) {\n          dims.push(wasm.HEAPU32[dimsOffset / 4 + i]);\n        }\n        wasm._OrtFree(dimsOffset);\n\n        const size = dims.reduce((a, b) => a * b, 1);\n        type = tensorDataTypeEnumToString(dataType);\n\n        const preferredLocation = ioBindingState?.outputPreferredLocations[outputIndices[i]];\n\n        if (type === 'string') {\n          if (preferredLocation === 'gpu-buffer') {\n            throw new Error('String tensor is not supported on GPU.');\n          }\n          const stringData: string[] = [];\n          let dataIndex = dataOffset / 4;\n          for (let i = 0; i < size; i++) {\n            const offset = wasm.HEAPU32[dataIndex++];\n            const maxBytesToRead = i === size - 1 ? undefined : wasm.HEAPU32[dataIndex] - offset;\n            stringData.push(wasm.UTF8ToString(offset, maxBytesToRead));\n          }\n          output.push([type, dims, stringData, 'cpu']);\n        } else {\n          // If a certain output's preferred location is GPU but the tensor is empty, we still need to create a CPU\n          // tensor for it. There is no mapping GPU buffer for an empty tensor.\n          if (preferredLocation === 'gpu-buffer' && size > 0) {\n            const getBuffer = wasm.jsepGetBuffer;\n            if (!getBuffer) {\n              throw new Error('preferredLocation \"gpu-buffer\" is not supported without using WebGPU.');\n            }\n            const gpuBuffer = getBuffer(dataOffset);\n            const elementSize = getTensorElementSize(dataType);\n            if (elementSize === undefined || !isGpuBufferSupportedType(type)) {\n              throw new Error(`Unsupported data type: ${type}`);\n            }\n\n            // do not release the tensor right now. it will be released when user calls tensor.dispose().\n            keepOutputTensor = true;\n\n            output.push([\n              type, dims, {\n                gpuBuffer,\n                download: wasm.jsepCreateDownloader!(gpuBuffer, size * elementSize, type),\n                dispose: () => {\n                  wasm._OrtReleaseTensor(tensor);\n                }\n              },\n              'gpu-buffer'\n            ]);\n          } else {\n            const typedArrayConstructor = tensorTypeToTypedArrayConstructor(type);\n            const data = new typedArrayConstructor(size);\n            new Uint8Array(data.buffer, data.byteOffset, data.byteLength)\n                .set(wasm.HEAPU8.subarray(dataOffset, dataOffset + data.byteLength));\n            output.push([type, dims, data, 'cpu']);\n          }\n        }\n      } finally {\n        wasm.stackRestore(beforeGetTensorDataStack);\n        if (type === 'string' && dataOffset) {\n          wasm._free(dataOffset);\n        }\n        if (!keepOutputTensor) {\n          wasm._OrtReleaseTensor(tensor);\n        }\n      }\n    }\n\n    if (ioBindingState && !enableGraphCapture) {\n      wasm._OrtClearBoundOutputs(ioBindingState.handle);\n      activeSessions.set(\n          sessionId,\n          [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture, false]);\n    }\n    return output;\n  } finally {\n    wasm.stackRestore(beforeRunStack);\n\n    inputTensorHandles.forEach(v => wasm._OrtReleaseTensor(v));\n    outputTensorHandles.forEach(v => wasm._OrtReleaseTensor(v));\n    inputOutputAllocs.forEach(p => wasm._free(p));\n\n    if (runOptionsHandle !== 0) {\n      wasm._OrtReleaseRunOptions(runOptionsHandle);\n    }\n    runOptionsAllocs.forEach(p => wasm._free(p));\n  }\n};\n\n/**\n * end profiling\n */\nexport const endProfiling = (sessionId: number): void => {\n  const wasm = getInstance();\n  const session = activeSessions.get(sessionId);\n  if (!session) {\n    throw new Error('invalid session id');\n  }\n  const sessionHandle = session[0];\n\n  // profile file name is not used yet, but it must be freed.\n  const profileFileName = wasm._OrtEndProfiling(sessionHandle);\n  if (profileFileName === 0) {\n    checkLastError('Can\\'t get an profile file name.');\n  }\n  wasm._OrtFree(profileFileName);\n};\n\nexport const extractTransferableBuffers = (tensors: readonly SerializableTensorMetadata[]): ArrayBufferLike[] => {\n  const buffers: ArrayBufferLike[] = [];\n  for (const tensor of tensors) {\n    const data = tensor[2];\n    if (!Array.isArray(data) && 'buffer' in data) {\n      buffers.push(data.buffer);\n    }\n  }\n  return buffers;\n};\n", "/*!\n * ONNX Runtime Web v1.18.0\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License.\n */\n\"use strict\";\n(() => {\n  var __defProp = Object.defineProperty;\n  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;\n  var __getOwnPropNames = Object.getOwnPropertyNames;\n  var __hasOwnProp = Object.prototype.hasOwnProperty;\n  var __esm = (fn, res) => function __init() {\n    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;\n  };\n  var __commonJS = (cb, mod) => function __require() {\n    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n  };\n  var __export = (target, all) => {\n    for (var name in all)\n      __defProp(target, name, { get: all[name], enumerable: true });\n  };\n  var __copyProps = (to, from, except, desc) => {\n    if (from && typeof from === \"object\" || typeof from === \"function\") {\n      for (let key of __getOwnPropNames(from))\n        if (!__hasOwnProp.call(to, key) && key !== except)\n          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n    }\n    return to;\n  };\n  var __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n  // nodejs-ignore:fs\n  var fs_exports = {};\n  __export(fs_exports, {\n    createReadStream: () => createReadStream,\n    readFile: () => readFile,\n    readFileSync: () => readFileSync\n  });\n  var readFile, readFileSync, createReadStream;\n  var init_fs = __esm({\n    \"nodejs-ignore:fs\"() {\n      readFile = void 0;\n      readFileSync = void 0;\n      createReadStream = void 0;\n    }\n  });\n\n  // nodejs-ignore:path\n  var path_exports = {};\n  __export(path_exports, {\n    join: () => join2\n  });\n  var join2;\n  var init_path = __esm({\n    \"nodejs-ignore:path\"() {\n      join2 = void 0;\n    }\n  });\n\n  // web/lib/wasm/binding/ort-wasm-simd.jsep.js\n  var require_ort_wasm_simd_jsep = __commonJS({\n    \"web/lib/wasm/binding/ort-wasm-simd.jsep.js\"(exports, module) {\n      \"use strict\";\n      var ortWasm = (() => {\n        var _scriptDir = typeof document != \"undefined\" ? document.currentScript?.src : void 0;\n        if (typeof __filename != \"undefined\")\n          _scriptDir ||= __filename;\n        return function(moduleArg = {}) {\n          var g = moduleArg, aa, ba, readyPromise = new Promise((a, b) => {\n            aa = a;\n            ba = b;\n          });\n          \"use strict\";\n          g.mountExternalData = (a, b) => {\n            (g.Ph || (g.Ph = /* @__PURE__ */ new Map())).set(a, b);\n          };\n          g.unmountExternalData = () => {\n            delete g.Ph;\n          };\n          let da = () => {\n            const a = (c, d, e) => (...f) => {\n              const h = t, k = d?.();\n              f = c(...f);\n              const l = d?.();\n              k !== l && (c = l, e(k), d = e = null);\n              return t != h ? ca() : f;\n            }, b = (c) => async (...d) => {\n              try {\n                if (g.Oh)\n                  throw Error(\"Session already started\");\n                const e = g.Oh = { gi: d[0], errors: [] }, f = await c(...d);\n                if (g.Oh !== e)\n                  throw Error(\"Session mismatch\");\n                g.Uh?.flush();\n                const h = e.errors;\n                if (0 < h.length) {\n                  let k = await Promise.all(h);\n                  k = k.filter((l) => l);\n                  if (0 < k.length)\n                    throw Error(k.join(\"\\n\"));\n                }\n                return f;\n              } finally {\n                g.Oh = null;\n              }\n            };\n            g._OrtCreateSession = a(\n              g._OrtCreateSession,\n              () => g._OrtCreateSession,\n              (c) => g._OrtCreateSession = c\n            );\n            g._OrtRun = b(a(g._OrtRun, () => g._OrtRun, (c) => g._OrtRun = c));\n            g._OrtRunWithBinding = b(a(g._OrtRunWithBinding, () => g._OrtRunWithBinding, (c) => g._OrtRunWithBinding = c));\n            g._OrtBindInput = a(g._OrtBindInput, () => g._OrtBindInput, (c) => g._OrtBindInput = c);\n            da = void 0;\n          };\n          g.jsepInit = (a, b) => {\n            da?.();\n            if (\"webgpu\" === a) {\n              [g.Uh, g.Zh, g.ci, g.Vh, g.bi, g.je, g.di, g.fi, g.$h, g.ai, g.ei] = b;\n              const c = g.Uh;\n              g.jsepRegisterBuffer = (d, e, f, h) => c.registerBuffer(d, e, f, h);\n              g.jsepGetBuffer = (d) => c.getBuffer(d);\n              g.jsepCreateDownloader = (d, e, f) => c.createDownloader(d, e, f);\n              g.jsepOnReleaseSession = (d) => {\n                c.onReleaseSession(d);\n              };\n              g.jsepOnRunStart = (d) => c.onRunStart(d);\n            }\n          };\n          var ea = Object.assign({}, g), fa = \"./this.program\", ha = (a, b) => {\n            throw b;\n          }, ia = \"object\" == typeof window, ja = \"function\" == typeof importScripts, ka = \"object\" == typeof process && \"object\" == typeof process.versions && \"string\" == typeof process.versions.node, v = \"\", la, ma, na;\n          if (ka) {\n            var fs = (init_fs(), __toCommonJS(fs_exports)), oa = (init_path(), __toCommonJS(path_exports));\n            v = ja ? oa.dirname(v) + \"/\" : __dirname + \"/\";\n            la = (a, b) => {\n              a = pa(a) ? new URL(a) : oa.normalize(a);\n              return fs.readFileSync(a, b ? void 0 : \"utf8\");\n            };\n            na = (a) => {\n              a = la(a, true);\n              a.buffer || (a = new Uint8Array(a));\n              return a;\n            };\n            ma = (a, b, c, d = true) => {\n              a = pa(a) ? new URL(a) : oa.normalize(a);\n              fs.readFile(a, d ? void 0 : \"utf8\", (e, f) => {\n                e ? c(e) : b(d ? f.buffer : f);\n              });\n            };\n            !g.thisProgram && 1 < process.argv.length && (fa = process.argv[1].replace(/\\\\/g, \"/\"));\n            process.argv.slice(2);\n            ha = (a, b) => {\n              process.exitCode = a;\n              throw b;\n            };\n          } else if (ia || ja)\n            ja ? v = self.location.href : \"undefined\" != typeof document && document.currentScript && (v = document.currentScript.src), _scriptDir && (v = _scriptDir), v.startsWith(\"blob:\") ? v = \"\" : v = v.substr(0, v.replace(/[?#].*/, \"\").lastIndexOf(\"/\") + 1), la = (a) => {\n              var b = new XMLHttpRequest();\n              b.open(\"GET\", a, false);\n              b.send(null);\n              return b.responseText;\n            }, ja && (na = (a) => {\n              var b = new XMLHttpRequest();\n              b.open(\"GET\", a, false);\n              b.responseType = \"arraybuffer\";\n              b.send(null);\n              return new Uint8Array(b.response);\n            }), ma = (a, b, c) => {\n              var d = new XMLHttpRequest();\n              d.open(\"GET\", a, true);\n              d.responseType = \"arraybuffer\";\n              d.onload = () => {\n                200 == d.status || 0 == d.status && d.response ? b(d.response) : c();\n              };\n              d.onerror = c;\n              d.send(null);\n            };\n          var qa = console.log.bind(console), w = console.error.bind(console);\n          Object.assign(g, ea);\n          ea = null;\n          var ra, x = false, sa, z, E, ta, ua, G, I, va, wa, xa, ya;\n          function za() {\n            var a = ra.buffer;\n            g.HEAP8 = z = new Int8Array(a);\n            g.HEAP16 = ta = new Int16Array(a);\n            g.HEAPU8 = E = new Uint8Array(a);\n            g.HEAPU16 = ua = new Uint16Array(a);\n            g.HEAP32 = G = new Int32Array(a);\n            g.HEAPU32 = I = new Uint32Array(a);\n            g.HEAPF32 = va = new Float32Array(a);\n            g.HEAPF64 = ya = new Float64Array(a);\n            g.HEAP64 = wa = new BigInt64Array(a);\n            g.HEAPU64 = xa = new BigUint64Array(a);\n          }\n          var Aa = [], Ba = [], Ca = [], Da = 0, Ea = null, Fa = null;\n          function Ga(a) {\n            a = \"Aborted(\" + a + \")\";\n            w(a);\n            x = true;\n            sa = 1;\n            a = new WebAssembly.RuntimeError(a + \". Build with -sASSERTIONS for more info.\");\n            ba(a);\n            throw a;\n          }\n          var Ha = (a) => a.startsWith(\"data:application/octet-stream;base64,\"), pa = (a) => a.startsWith(\"file://\"), Ia;\n          Ia = \"ort-wasm-simd.wasm\";\n          if (!Ha(Ia)) {\n            var Ja = Ia;\n            Ia = g.locateFile ? g.locateFile(Ja, v) : v + Ja;\n          }\n          function Ka(a) {\n            if (na)\n              return na(a);\n            throw \"both async and sync fetching of the wasm failed\";\n          }\n          function La(a) {\n            if (ia || ja) {\n              if (\"function\" == typeof fetch && !pa(a))\n                return fetch(a, { credentials: \"same-origin\" }).then((b) => {\n                  if (!b.ok)\n                    throw `failed to load wasm binary file at '${a}'`;\n                  return b.arrayBuffer();\n                }).catch(() => Ka(a));\n              if (ma)\n                return new Promise((b, c) => {\n                  ma(a, (d) => b(new Uint8Array(d)), c);\n                });\n            }\n            return Promise.resolve().then(() => Ka(a));\n          }\n          function Ma(a, b, c) {\n            return La(a).then((d) => WebAssembly.instantiate(d, b)).then(c, (d) => {\n              w(`failed to asynchronously prepare wasm: ${d}`);\n              Ga(d);\n            });\n          }\n          function Na(a, b) {\n            var c = Ia;\n            return \"function\" != typeof WebAssembly.instantiateStreaming || Ha(c) || pa(c) || ka || \"function\" != typeof fetch ? Ma(c, a, b) : fetch(c, { credentials: \"same-origin\" }).then((d) => WebAssembly.instantiateStreaming(d, a).then(b, function(e) {\n              w(`wasm streaming compile failed: ${e}`);\n              w(\"falling back to ArrayBuffer instantiation\");\n              return Ma(c, a, b);\n            }));\n          }\n          var Oa = {\n            1261504: (a, b, c, d) => {\n              if (\"undefined\" == typeof g || !g.Ph)\n                return 1;\n              a = J(a >>> 0);\n              a.startsWith(\"./\") && (a = a.substring(2));\n              a = g.Ph.get(a);\n              if (!a)\n                return 2;\n              b >>>= 0;\n              c >>>= 0;\n              if (b + c > a.byteLength)\n                return 3;\n              try {\n                return E.set(a.subarray(b, b + c), d >>> 0 >>> 0), 0;\n              } catch {\n                return 4;\n              }\n            },\n            1262005: (a, b, c) => {\n              c = J(c);\n              const d = new Uint8Array(b);\n              d.set(E.subarray(a >>> 0, a + b >>> 0));\n              \"object\" == typeof process && \"object\" == typeof process.versions && \"string\" == typeof process.versions.node ? (init_fs(), __toCommonJS(fs_exports)).writeFileSync(c, d) : (a = new File([d], c, { type: \"application/octet-stream\" }), a = URL.createObjectURL(a), window.open(a, \"_blank\"));\n            },\n            1262513: () => {\n              g.$h();\n            },\n            1262544: () => {\n              g.ai();\n            },\n            1262573: () => {\n              g.ei();\n            },\n            1262598: (a) => g.Zh(a),\n            1262631: (a) => g.ci(a),\n            1262663: (a, b, c) => {\n              g.Vh(a, b, c, true);\n            },\n            1262702: (a, b, c) => {\n              g.Vh(a, b, c);\n            },\n            1262735: (a) => {\n              g.je(\"Abs\", a, void 0);\n            },\n            1262786: (a) => {\n              g.je(\"Neg\", a, void 0);\n            },\n            1262837: (a) => {\n              g.je(\"Floor\", a, void 0);\n            },\n            1262890: (a) => {\n              g.je(\"Ceil\", a, void 0);\n            },\n            1262942: (a) => {\n              g.je(\"Reciprocal\", a, void 0);\n            },\n            1263e3: (a) => {\n              g.je(\"Sqrt\", a, void 0);\n            },\n            1263052: (a) => {\n              g.je(\"Exp\", a, void 0);\n            },\n            1263103: (a) => {\n              g.je(\"Erf\", a, void 0);\n            },\n            1263154: (a) => {\n              g.je(\"Sigmoid\", a, void 0);\n            },\n            1263209: (a, b, c) => {\n              g.je(\"HardSigmoid\", a, { alpha: b, beta: c });\n            },\n            1263288: (a) => {\n              g.je(\"Log\", a, void 0);\n            },\n            1263339: (a) => {\n              g.je(\"Sin\", a, void 0);\n            },\n            1263390: (a) => {\n              g.je(\"Cos\", a, void 0);\n            },\n            1263441: (a) => {\n              g.je(\"Tan\", a, void 0);\n            },\n            1263492: (a) => {\n              g.je(\"Asin\", a, void 0);\n            },\n            1263544: (a) => {\n              g.je(\"Acos\", a, void 0);\n            },\n            1263596: (a) => {\n              g.je(\"Atan\", a, void 0);\n            },\n            1263648: (a) => {\n              g.je(\"Sinh\", a, void 0);\n            },\n            1263700: (a) => {\n              g.je(\"Cosh\", a, void 0);\n            },\n            1263752: (a) => {\n              g.je(\"Asinh\", a, void 0);\n            },\n            1263805: (a) => {\n              g.je(\"Acosh\", a, void 0);\n            },\n            1263858: (a) => {\n              g.je(\"Atanh\", a, void 0);\n            },\n            1263911: (a) => {\n              g.je(\"Tanh\", a, void 0);\n            },\n            1263963: (a) => {\n              g.je(\"Not\", a, void 0);\n            },\n            1264014: (a, b, c) => {\n              g.je(\"Clip\", a, { min: b, max: c });\n            },\n            1264083: (a) => {\n              g.je(\"Clip\", a, void 0);\n            },\n            1264135: (a, b) => {\n              g.je(\"Elu\", a, { alpha: b });\n            },\n            1264193: (a) => {\n              g.je(\"Relu\", a, void 0);\n            },\n            1264245: (a, b) => {\n              g.je(\"LeakyRelu\", a, { alpha: b });\n            },\n            1264309: (a, b) => {\n              g.je(\"ThresholdedRelu\", a, { alpha: b });\n            },\n            1264379: (a, b) => {\n              g.je(\"Cast\", a, { to: b });\n            },\n            1264437: (a) => {\n              g.je(\"Add\", a, void 0);\n            },\n            1264488: (a) => {\n              g.je(\"Sub\", a, void 0);\n            },\n            1264539: (a) => {\n              g.je(\"Mul\", a, void 0);\n            },\n            1264590: (a) => {\n              g.je(\"Div\", a, void 0);\n            },\n            1264641: (a) => {\n              g.je(\"Pow\", a, void 0);\n            },\n            1264692: (a) => {\n              g.je(\"Equal\", a, void 0);\n            },\n            1264745: (a) => {\n              g.je(\"Greater\", a, void 0);\n            },\n            1264800: (a) => {\n              g.je(\"GreaterOrEqual\", a, void 0);\n            },\n            1264862: (a) => {\n              g.je(\"Less\", a, void 0);\n            },\n            1264914: (a) => {\n              g.je(\"LessOrEqual\", a, void 0);\n            },\n            1264973: (a, b, c, d, e) => {\n              g.je(\"ReduceMean\", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n            },\n            1265132: (a, b, c, d, e) => {\n              g.je(\"ReduceMax\", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n            },\n            1265290: (a, b, c, d, e) => {\n              g.je(\"ReduceMin\", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n            },\n            1265448: (a, b, c, d, e) => {\n              g.je(\"ReduceProd\", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n            },\n            1265607: (a, b, c, d, e) => {\n              g.je(\"ReduceSum\", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n            },\n            1265765: (a, b, c, d, e) => {\n              g.je(\"ReduceL1\", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n            },\n            1265922: (a, b, c, d, e) => {\n              g.je(\"ReduceL2\", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n            },\n            1266079: (a, b, c, d, e) => {\n              g.je(\"ReduceLogSum\", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n            },\n            1266240: (a, b, c, d, e) => {\n              g.je(\"ReduceSumSquare\", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n            },\n            1266404: (a, b, c, d, e) => {\n              g.je(\"ReduceLogSumExp\", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n            },\n            1266568: (a) => {\n              g.je(\"Where\", a, void 0);\n            },\n            1266621: (a, b, c) => {\n              g.je(\"Transpose\", a, { perm: b ? Array.from(G.subarray(b >>> 0, c >>> 0)) : [] });\n            },\n            1266729: (a, b, c, d) => {\n              g.je(\"DepthToSpace\", a, { blocksize: b, mode: J(c), format: d ? \"NHWC\" : \"NCHW\" });\n            },\n            1266862: (a, b, c, d) => {\n              g.je(\"DepthToSpace\", a, { blocksize: b, mode: J(c), format: d ? \"NHWC\" : \"NCHW\" });\n            },\n            1266995: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => {\n              g.je(\"ConvTranspose\", a, { format: l ? \"NHWC\" : \"NCHW\", autoPad: b, dilations: [c], group: d, kernelShape: [e], pads: [f, h], strides: [k], wIsConst: () => !!z[m >>> 0], outputPadding: n ? Array.from(G.subarray(n >>> 0, q >>> 0)) : [], outputShape: r ? Array.from(G.subarray(r >>> 0, p >>> 0)) : [], activation: J(u) });\n            },\n            1267396: (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => {\n              g.je(\"ConvTranspose\", a, { format: k ? \"NHWC\" : \"NCHW\", autoPad: b, dilations: Array.from(G.subarray(c >>> 0, (c >>> 0) + 2 >>> 0)), group: d, kernelShape: Array.from(G.subarray(e >>> 0, (e >>> 0) + 2 >>> 0)), pads: Array.from(G.subarray(f >>> 0, (f >>> 0) + 4 >>> 0)), strides: Array.from(G.subarray(h >>> 0, (h >>> 0) + 2 >>> 0)), wIsConst: () => !!z[l >>> 0], outputPadding: m ? Array.from(G.subarray(m >>> 0, n >>> 0)) : [], outputShape: q ? Array.from(G.subarray(q >>> 0, r >>> 0)) : [], activation: J(p) });\n            },\n            1267961: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => {\n              g.je(\"ConvTranspose\", a, { format: l ? \"NHWC\" : \"NCHW\", autoPad: b, dilations: [c], group: d, kernelShape: [e], pads: [f, h], strides: [k], wIsConst: () => !!z[m >>> 0], outputPadding: n ? Array.from(G.subarray(n >>> 0, q >>> 0)) : [], outputShape: r ? Array.from(G.subarray(r >>> 0, p >>> 0)) : [], activation: J(u) });\n            },\n            1268362: (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => {\n              g.je(\"ConvTranspose\", a, {\n                format: k ? \"NHWC\" : \"NCHW\",\n                autoPad: b,\n                dilations: Array.from(G.subarray(c >>> 0, (c >>> 0) + 2 >>> 0)),\n                group: d,\n                kernelShape: Array.from(G.subarray(e >>> 0, (e >>> 0) + 2 >>> 0)),\n                pads: Array.from(G.subarray(f >>> 0, (f >>> 0) + 4 >>> 0)),\n                strides: Array.from(G.subarray(h >>> 0, (h >>> 0) + 2 >>> 0)),\n                wIsConst: () => !!z[l >>> 0],\n                outputPadding: m ? Array.from(G.subarray(m >>> 0, n >>> 0)) : [],\n                outputShape: q ? Array.from(G.subarray(q >>> 0, r >>> 0)) : [],\n                activation: J(p)\n              });\n            },\n            1268927: (a, b) => {\n              g.je(\"GlobalAveragePool\", a, { format: b ? \"NHWC\" : \"NCHW\" });\n            },\n            1269018: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => {\n              g.je(\"AveragePool\", a, {\n                format: y ? \"NHWC\" : \"NCHW\",\n                auto_pad: b,\n                ceil_mode: c,\n                count_include_pad: d,\n                storage_order: e,\n                dilations: [f, h],\n                kernel_shape: [k, l],\n                pads: [m, n, q, r],\n                strides: [p, u]\n              });\n            },\n            1269302: (a, b) => {\n              g.je(\"GlobalAveragePool\", a, { format: b ? \"NHWC\" : \"NCHW\" });\n            },\n            1269393: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => {\n              g.je(\"AveragePool\", a, { format: y ? \"NHWC\" : \"NCHW\", auto_pad: b, ceil_mode: c, count_include_pad: d, storage_order: e, dilations: [f, h], kernel_shape: [k, l], pads: [m, n, q, r], strides: [p, u] });\n            },\n            1269677: (a, b) => {\n              g.je(\"GlobalMaxPool\", a, { format: b ? \"NHWC\" : \"NCHW\" });\n            },\n            1269764: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => {\n              g.je(\"MaxPool\", a, { format: y ? \"NHWC\" : \"NCHW\", auto_pad: b, ceil_mode: c, count_include_pad: d, storage_order: e, dilations: [f, h], kernel_shape: [k, l], pads: [m, n, q, r], strides: [p, u] });\n            },\n            1270044: (a, b) => {\n              g.je(\"GlobalMaxPool\", a, { format: b ? \"NHWC\" : \"NCHW\" });\n            },\n            1270131: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => {\n              g.je(\"MaxPool\", a, { format: y ? \"NHWC\" : \"NCHW\", auto_pad: b, ceil_mode: c, count_include_pad: d, storage_order: e, dilations: [f, h], kernel_shape: [k, l], pads: [m, n, q, r], strides: [p, u] });\n            },\n            1270411: (a, b, c, d, e) => {\n              g.je(\"Gemm\", a, { alpha: b, beta: c, transA: d, transB: e });\n            },\n            1270515: (a) => {\n              g.je(\"MatMul\", a, void 0);\n            },\n            1270569: (a, b, c, d) => {\n              g.je(\"ArgMax\", a, { keepDims: !!b, selectLastIndex: !!c, axis: d });\n            },\n            1270677: (a, b, c, d) => {\n              g.je(\"ArgMin\", a, { keepDims: !!b, selectLastIndex: !!c, axis: d });\n            },\n            1270785: (a, b) => {\n              g.je(\"Softmax\", a, { axis: b });\n            },\n            1270848: (a, b) => {\n              g.je(\"Concat\", a, { axis: b });\n            },\n            1270908: (a, b, c, d, e) => {\n              g.je(\"Split\", a, { axis: b, numOutputs: c, splitSizes: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n            },\n            1271048: (a) => {\n              g.je(\"Expand\", a, void 0);\n            },\n            1271102: (a, b) => {\n              g.je(\"Gather\", a, { axis: Number(b) });\n            },\n            1271173: (a, b) => {\n              g.je(\n                \"GatherElements\",\n                a,\n                { axis: Number(b) }\n              );\n            },\n            1271252: (a, b, c, d, e, f, h, k, l, m, n) => {\n              g.je(\"Resize\", a, { antialias: b, axes: c ? Array.from(G.subarray(c >>> 0, d >>> 0)) : [], coordinateTransformMode: J(e), cubicCoeffA: f, excludeOutside: h, extrapolationValue: k, keepAspectRatioPolicy: J(l), mode: J(m), nearestMode: J(n) });\n            },\n            1271598: (a, b, c, d, e, f, h) => {\n              g.je(\"Slice\", a, { starts: b ? Array.from(G.subarray(b >>> 0, c >>> 0)) : [], ends: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [], axes: f ? Array.from(G.subarray(f >>> 0, h >>> 0)) : [] });\n            },\n            1271814: (a) => {\n              g.je(\"Tile\", a, void 0);\n            },\n            1271866: (a, b, c, d) => {\n              g.je(\"LayerNormalization\", a, { axis: b, epsilon: c, simplified: !!d });\n            },\n            1271977: (a, b, c) => {\n              g.je(\"InstanceNormalization\", a, { epsilon: b, format: c ? \"NHWC\" : \"NCHW\" });\n            },\n            1272091: (a, b, c) => {\n              g.je(\"InstanceNormalization\", a, { epsilon: b, format: c ? \"NHWC\" : \"NCHW\" });\n            },\n            1272205: (a) => {\n              g.je(\"Range\", a, void 0);\n            },\n            1272258: (a, b) => {\n              g.je(\"Einsum\", a, { equation: J(b) });\n            },\n            1272339: (a, b, c, d, e) => {\n              g.je(\"Pad\", a, { mode: b, value: c, pads: d ? Array.from(G.subarray(d >>> 0, e >>> 0)) : [] });\n            },\n            1272466: (a, b, c, d, e, f) => {\n              g.je(\"BatchNormalization\", a, {\n                epsilon: b,\n                momentum: c,\n                spatial: !!e,\n                trainingMode: !!d,\n                format: f ? \"NHWC\" : \"NCHW\"\n              });\n            },\n            1272635: (a, b, c, d, e, f) => {\n              g.je(\"BatchNormalization\", a, { epsilon: b, momentum: c, spatial: !!e, trainingMode: !!d, format: f ? \"NHWC\" : \"NCHW\" });\n            },\n            1272804: (a, b, c) => {\n              g.je(\"CumSum\", a, { exclusive: Number(b), reverse: Number(c) });\n            },\n            1272901: (a, b, c, d, e, f, h, k, l) => {\n              g.je(\"Attention\", a, { numHeads: b, isUnidirectional: c, maskFilterValue: d, scale: e, doRotary: f, qkvHiddenSizes: h ? Array.from(G.subarray(Number(k) >>> 0, Number(k) + h >>> 0)) : [], pastPresentShareBuffer: !!l });\n            },\n            1273173: (a) => {\n              g.je(\n                \"BiasAdd\",\n                a,\n                void 0\n              );\n            },\n            1273228: (a) => {\n              g.je(\"BiasSplitGelu\", a, void 0);\n            },\n            1273289: (a) => {\n              g.je(\"FastGelu\", a, void 0);\n            },\n            1273345: (a, b, c, d, e, f, h, k, l, m, n, q, r) => {\n              g.je(\"Conv\", a, { format: l ? \"NHWC\" : \"NCHW\", auto_pad: b, dilations: [c], group: d, kernel_shape: [e], pads: f ? Array.from(G.subarray(f >>> 0, h >>> 0)) : [], strides: [k], w_is_const: () => !!z[m >>> 0], activation: J(n), activation_params: q ? Array.from(va.subarray(q >>> 0, r >>> 0)) : [] });\n            },\n            1273715: (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => {\n              g.je(\"Conv\", a, { format: q ? \"NHWC\" : \"NCHW\", auto_pad: b, dilations: [c, d], group: e, kernel_shape: [\n                f,\n                h\n              ], pads: k ? Array.from(G.subarray(k >>> 0, l >>> 0)) : [], strides: [m, n], w_is_const: () => !!z[r >>> 0], activation: J(p), activation_params: u ? Array.from(va.subarray(u >>> 0, y >>> 0)) : [] });\n            },\n            1274106: (a) => {\n              g.je(\"Gelu\", a, void 0);\n            },\n            1274158: (a, b, c, d, e, f) => {\n              g.je(\"MatMulNBits\", a, { k: b, n: c, accuracyLevel: d, bits: e, blockSize: f });\n            },\n            1274285: (a, b, c, d, e, f) => {\n              g.je(\"MultiHeadAttention\", a, { numHeads: b, isUnidirectional: c, maskFilterValue: d, scale: e, doRotary: f });\n            },\n            1274444: (a, b, c, d, e) => {\n              g.je(\"RotaryEmbedding\", a, {\n                interleaved: !!b,\n                numHeads: c,\n                rotaryEmbeddingDim: d,\n                scale: e\n              });\n            },\n            1274583: (a, b, c) => {\n              g.je(\"SkipLayerNormalization\", a, { epsilon: b, simplified: !!c });\n            },\n            1274685: (a, b, c) => {\n              g.je(\"SkipLayerNormalization\", a, { epsilon: b, simplified: !!c });\n            },\n            1274787: (a, b, c, d) => {\n              g.je(\"LayerNormalization\", a, { axis: b, epsilon: c, simplified: !!d });\n            },\n            1274898: (a) => {\n              g.di(a);\n            },\n            1274932: (a, b) => g.fi(a, b, g.Oh.gi, g.Oh.errors)\n          };\n          function Pa(a) {\n            this.name = \"ExitStatus\";\n            this.message = `Program terminated with exit(${a})`;\n            this.status = a;\n          }\n          var Qa = [], Ra = 0, L = 0;\n          class Sa {\n            constructor(a) {\n              this.Nh = a;\n              this.Ih = a - 24;\n            }\n          }\n          var Za = (a) => {\n            var b = L;\n            if (!b)\n              return Ta(0), 0;\n            var c = new Sa(b);\n            I[c.Ih + 16 >>> 2 >>> 0] = b;\n            var d = I[c.Ih + 4 >>> 2 >>> 0];\n            if (!d)\n              return Ta(0), b;\n            for (var e in a) {\n              var f = a[e];\n              if (0 === f || f === d)\n                break;\n              if (Ua(f, d, c.Ih + 16))\n                return Ta(f), b;\n            }\n            Ta(d);\n            return b;\n          }, $a = \"undefined\" != typeof TextDecoder ? new TextDecoder(\"utf8\") : void 0, ab = (a, b, c) => {\n            b >>>= 0;\n            var d = b + c;\n            for (c = b; a[c] && !(c >= d); )\n              ++c;\n            if (16 < c - b && a.buffer && $a)\n              return $a.decode(a.subarray(b, c));\n            for (d = \"\"; b < c; ) {\n              var e = a[b++];\n              if (e & 128) {\n                var f = a[b++] & 63;\n                if (192 == (e & 224))\n                  d += String.fromCharCode((e & 31) << 6 | f);\n                else {\n                  var h = a[b++] & 63;\n                  e = 224 == (e & 240) ? (e & 15) << 12 | f << 6 | h : (e & 7) << 18 | f << 12 | h << 6 | a[b++] & 63;\n                  65536 > e ? d += String.fromCharCode(e) : (e -= 65536, d += String.fromCharCode(55296 | e >> 10, 56320 | e & 1023));\n                }\n              } else\n                d += String.fromCharCode(e);\n            }\n            return d;\n          }, J = (a, b) => (a >>>= 0) ? ab(E, a, b) : \"\", bb = (a) => {\n            for (var b = 0, c = 0; c < a.length; ++c) {\n              var d = a.charCodeAt(c);\n              127 >= d ? b++ : 2047 >= d ? b += 2 : 55296 <= d && 57343 >= d ? (b += 4, ++c) : b += 3;\n            }\n            return b;\n          }, M = (a, b, c, d) => {\n            c >>>= 0;\n            if (!(0 < d))\n              return 0;\n            var e = c;\n            d = c + d - 1;\n            for (var f = 0; f < a.length; ++f) {\n              var h = a.charCodeAt(f);\n              if (55296 <= h && 57343 >= h) {\n                var k = a.charCodeAt(++f);\n                h = 65536 + ((h & 1023) << 10) | k & 1023;\n              }\n              if (127 >= h) {\n                if (c >= d)\n                  break;\n                b[c++ >>> 0] = h;\n              } else {\n                if (2047 >= h) {\n                  if (c + 1 >= d)\n                    break;\n                  b[c++ >>> 0] = 192 | h >> 6;\n                } else {\n                  if (65535 >= h) {\n                    if (c + 2 >= d)\n                      break;\n                    b[c++ >>> 0] = 224 | h >> 12;\n                  } else {\n                    if (c + 3 >= d)\n                      break;\n                    b[c++ >>> 0] = 240 | h >> 18;\n                    b[c++ >>> 0] = 128 | h >> 12 & 63;\n                  }\n                  b[c++ >>> 0] = 128 | h >> 6 & 63;\n                }\n                b[c++ >>> 0] = 128 | h & 63;\n              }\n            }\n            b[c >>> 0] = 0;\n            return c - e;\n          }, cb, N = (a) => {\n            for (var b = \"\"; E[a >>> 0]; )\n              b += cb[E[a++ >>> 0]];\n            return b;\n          }, db = {}, eb = {}, fb = {}, O;\n          function gb(a, b, c = {}) {\n            var d = b.name;\n            if (!a)\n              throw new O(`type \"${d}\" must have a positive integer typeid pointer`);\n            if (eb.hasOwnProperty(a)) {\n              if (c.Xh)\n                return;\n              throw new O(`Cannot register type '${d}' twice`);\n            }\n            eb[a] = b;\n            delete fb[a];\n            db.hasOwnProperty(a) && (b = db[a], delete db[a], b.forEach((e) => e()));\n          }\n          function P(a, b, c = {}) {\n            if (!(\"argPackAdvance\" in b))\n              throw new TypeError(\"registerType registeredInstance requires argPackAdvance\");\n            return gb(a, b, c);\n          }\n          var hb = (a, b, c) => {\n            switch (b) {\n              case 1:\n                return c ? (d) => z[d >>> 0] : (d) => E[d >>> 0];\n              case 2:\n                return c ? (d) => ta[d >>> 1 >>> 0] : (d) => ua[d >>> 1 >>> 0];\n              case 4:\n                return c ? (d) => G[d >>> 2 >>> 0] : (d) => I[d >>> 2 >>> 0];\n              case 8:\n                return c ? (d) => wa[d >>> 3] : (d) => xa[d >>> 3];\n              default:\n                throw new TypeError(`invalid integer width (${b}): ${a}`);\n            }\n          }, ib = [], Q = [];\n          function jb(a) {\n            a >>>= 0;\n            9 < a && 0 === --Q[a + 1] && (Q[a] = void 0, ib.push(a));\n          }\n          var R = (a) => {\n            if (!a)\n              throw new O(\"Cannot use deleted val. handle = \" + a);\n            return Q[a];\n          }, S = (a) => {\n            switch (a) {\n              case void 0:\n                return 2;\n              case null:\n                return 4;\n              case true:\n                return 6;\n              case false:\n                return 8;\n              default:\n                const b = ib.pop() || Q.length;\n                Q[b] = a;\n                Q[b + 1] = 1;\n                return b;\n            }\n          };\n          function kb(a) {\n            return this.fromWireType(I[a >>> 2 >>> 0]);\n          }\n          var lb = { name: \"emscripten::val\", fromWireType: (a) => {\n            var b = R(a);\n            jb(a);\n            return b;\n          }, toWireType: (a, b) => S(b), argPackAdvance: 8, readValueFromPointer: kb, Mh: null }, mb = (a, b) => {\n            switch (b) {\n              case 4:\n                return function(c) {\n                  return this.fromWireType(va[c >>> 2 >>> 0]);\n                };\n              case 8:\n                return function(c) {\n                  return this.fromWireType(ya[c >>> 3 >>> 0]);\n                };\n              default:\n                throw new TypeError(`invalid float width (${b}): ${a}`);\n            }\n          }, nb = \"undefined\" != typeof TextDecoder ? new TextDecoder(\"utf-16le\") : void 0, ob = (a, b) => {\n            var c = a >> 1;\n            for (var d = c + b / 2; !(c >= d) && ua[c >>> 0]; )\n              ++c;\n            c <<= 1;\n            if (32 < c - a && nb)\n              return nb.decode(E.subarray(a >>> 0, c >>> 0));\n            c = \"\";\n            for (d = 0; !(d >= b / 2); ++d) {\n              var e = ta[a + 2 * d >>> 1 >>> 0];\n              if (0 == e)\n                break;\n              c += String.fromCharCode(e);\n            }\n            return c;\n          }, pb = (a, b, c) => {\n            c ??= 2147483647;\n            if (2 > c)\n              return 0;\n            c -= 2;\n            var d = b;\n            c = c < 2 * a.length ? c / 2 : a.length;\n            for (var e = 0; e < c; ++e)\n              ta[b >>> 1 >>> 0] = a.charCodeAt(e), b += 2;\n            ta[b >>> 1 >>> 0] = 0;\n            return b - d;\n          }, qb = (a) => 2 * a.length, rb = (a, b) => {\n            for (var c = 0, d = \"\"; !(c >= b / 4); ) {\n              var e = G[a + 4 * c >>> 2 >>> 0];\n              if (0 == e)\n                break;\n              ++c;\n              65536 <= e ? (e -= 65536, d += String.fromCharCode(55296 | e >> 10, 56320 | e & 1023)) : d += String.fromCharCode(e);\n            }\n            return d;\n          }, sb = (a, b, c) => {\n            b >>>= 0;\n            c ??= 2147483647;\n            if (4 > c)\n              return 0;\n            var d = b;\n            c = d + c - 4;\n            for (var e = 0; e < a.length; ++e) {\n              var f = a.charCodeAt(e);\n              if (55296 <= f && 57343 >= f) {\n                var h = a.charCodeAt(++e);\n                f = 65536 + ((f & 1023) << 10) | h & 1023;\n              }\n              G[b >>> 2 >>> 0] = f;\n              b += 4;\n              if (b + 4 > c)\n                break;\n            }\n            G[b >>> 2 >>> 0] = 0;\n            return b - d;\n          }, tb = (a) => {\n            for (var b = 0, c = 0; c < a.length; ++c) {\n              var d = a.charCodeAt(c);\n              55296 <= d && 57343 >= d && ++c;\n              b += 4;\n            }\n            return b;\n          }, vb = (a, b) => {\n            var c = eb[a];\n            if (void 0 === c)\n              throw a = ub(a), c = N(a), T(a), new O(`${b} has unknown type ${c}`);\n            return c;\n          }, wb = (a, b, c) => {\n            var d = [];\n            a = a.toWireType(d, c);\n            d.length && (I[b >>> 2 >>> 0] = S(d));\n            return a;\n          }, xb = (a) => {\n            try {\n              a();\n            } catch (b) {\n              Ga(b);\n            }\n          }, yb = (a) => {\n            if (!x)\n              try {\n                a();\n                try {\n                  sa = sa = a = sa, g.onExit?.(a), x = true, ha(a, new Pa(a));\n                } catch (b) {\n                  b instanceof Pa || \"unwind\" == b || ha(1, b);\n                }\n              } catch (b) {\n                b instanceof Pa || \"unwind\" == b || ha(1, b);\n              }\n          };\n          function zb() {\n            var a = U, b = {};\n            for (let [c, d] of Object.entries(a))\n              b[c] = \"function\" == typeof d ? (...e) => {\n                Ab.push(c);\n                try {\n                  return d(...e);\n                } finally {\n                  x || (Ab.pop(), t && 1 === V && 0 === Ab.length && (V = 0, xb(Bb), \"undefined\" != typeof Fibers && Fibers.mi()));\n                }\n              } : d;\n            return b;\n          }\n          var V = 0, t = null, Cb = 0, Ab = [], Db = {}, Eb = {}, Fb = 0, Gb = null, Hb = [];\n          function ca() {\n            return new Promise((a, b) => {\n              Gb = { resolve: a, reject: b };\n            });\n          }\n          function Ib() {\n            var a = Jb(65548), b = a + 12;\n            I[a >>> 2 >>> 0] = b;\n            I[a + 4 >>> 2 >>> 0] = b + 65536;\n            b = Ab[0];\n            var c = Db[b];\n            void 0 === c && (c = Fb++, Db[b] = c, Eb[c] = b);\n            G[a + 8 >>> 2 >>> 0] = c;\n            return a;\n          }\n          function Kb(a) {\n            if (!x) {\n              if (0 === V) {\n                var b = false, c = false;\n                a((d = 0) => {\n                  if (!x && (Cb = d, b = true, c)) {\n                    V = 2;\n                    xb(() => Lb(t));\n                    \"undefined\" != typeof Browser && Browser.Sh.Wh && Browser.Sh.resume();\n                    d = false;\n                    try {\n                      var e = (0, U[Eb[G[t + 8 >>> 2 >>> 0]]])();\n                    } catch (k) {\n                      e = k, d = true;\n                    }\n                    var f = false;\n                    if (!t) {\n                      var h = Gb;\n                      h && (Gb = null, (d ? h.reject : h.resolve)(e), f = true);\n                    }\n                    if (d && !f)\n                      throw e;\n                  }\n                });\n                c = true;\n                b || (V = 1, t = Ib(), \"undefined\" != typeof Browser && Browser.Sh.Wh && Browser.Sh.pause(), xb(() => Mb(t)));\n              } else\n                2 === V ? (V = 0, xb(Nb), T(t), t = null, Hb.forEach(yb)) : Ga(`invalid state: ${V}`);\n              return Cb;\n            }\n          }\n          function Ob(a) {\n            return Kb((b) => {\n              a().then(b);\n            });\n          }\n          var Pb = [], Qb = {}, Rb = (a) => {\n            var b = Qb[a];\n            return void 0 === b ? N(a) : b;\n          }, Sb = () => \"object\" == typeof globalThis ? globalThis : Function(\"return this\")(), Tb = (a) => {\n            var b = Pb.length;\n            Pb.push(a);\n            return b;\n          }, Ub = (a, b) => {\n            for (var c = Array(a), d = 0; d < a; ++d)\n              c[d] = vb(I[b + 4 * d >>> 2 >>> 0], \"parameter \" + d);\n            return c;\n          }, Vb = (a, b) => Object.defineProperty(b, \"name\", { value: a });\n          function Wb(a) {\n            var b = Function;\n            if (!(b instanceof Function))\n              throw new TypeError(`new_ called with constructor type ${typeof b} which is not a function`);\n            var c = Vb(b.name || \"unknownFunctionName\", function() {\n            });\n            c.prototype = b.prototype;\n            c = new c();\n            a = b.apply(c, a);\n            return a instanceof Object ? a : c;\n          }\n          var W = (a) => 0 === a % 4 && (0 !== a % 100 || 0 === a % 400), Xb = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335], Yb = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334], Zb = [], $b = (a, b) => {\n            Zb.length = 0;\n            for (var c; c = E[a++ >>> 0]; ) {\n              var d = 105 != c;\n              d &= 112 != c;\n              b += d && b % 8 ? 4 : 0;\n              Zb.push(112 == c ? I[b >>> 2 >>> 0] : 106 == c ? wa[b >>> 3] : 105 == c ? G[b >>> 2 >>> 0] : ya[b >>> 3 >>> 0]);\n              b += d ? 8 : 4;\n            }\n            return Zb;\n          }, ac = {}, cc = () => {\n            if (!bc) {\n              var a = { USER: \"web_user\", LOGNAME: \"web_user\", PATH: \"/\", PWD: \"/\", HOME: \"/home/web_user\", LANG: (\"object\" == typeof navigator && navigator.languages && navigator.languages[0] || \"C\").replace(\"-\", \"_\") + \".UTF-8\", _: fa || \"./this.program\" }, b;\n              for (b in ac)\n                void 0 === ac[b] ? delete a[b] : a[b] = ac[b];\n              var c = [];\n              for (b in a)\n                c.push(`${b}=${a[b]}`);\n              bc = c;\n            }\n            return bc;\n          }, bc, dc = [null, [], []], ec = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], fc = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];\n          function gc(a) {\n            var b = Array(bb(a) + 1);\n            M(a, b, 0, b.length);\n            return b;\n          }\n          function hc(a, b, c, d) {\n            function e(p, u, y) {\n              for (p = \"number\" == typeof p ? p.toString() : p || \"\"; p.length < u; )\n                p = y[0] + p;\n              return p;\n            }\n            function f(p, u) {\n              return e(p, u, \"0\");\n            }\n            function h(p, u) {\n              function y(B) {\n                return 0 > B ? -1 : 0 < B ? 1 : 0;\n              }\n              var A;\n              0 === (A = y(p.getFullYear() - u.getFullYear())) && 0 === (A = y(p.getMonth() - u.getMonth())) && (A = y(p.getDate() - u.getDate()));\n              return A;\n            }\n            function k(p) {\n              switch (p.getDay()) {\n                case 0:\n                  return new Date(p.getFullYear() - 1, 11, 29);\n                case 1:\n                  return p;\n                case 2:\n                  return new Date(p.getFullYear(), 0, 3);\n                case 3:\n                  return new Date(\n                    p.getFullYear(),\n                    0,\n                    2\n                  );\n                case 4:\n                  return new Date(p.getFullYear(), 0, 1);\n                case 5:\n                  return new Date(p.getFullYear() - 1, 11, 31);\n                case 6:\n                  return new Date(p.getFullYear() - 1, 11, 30);\n              }\n            }\n            function l(p) {\n              var u = p.Kh;\n              for (p = new Date(new Date(p.Lh + 1900, 0, 1).getTime()); 0 < u; ) {\n                var y = p.getMonth(), A = (W(p.getFullYear()) ? ec : fc)[y];\n                if (u > A - p.getDate())\n                  u -= A - p.getDate() + 1, p.setDate(1), 11 > y ? p.setMonth(y + 1) : (p.setMonth(0), p.setFullYear(p.getFullYear() + 1));\n                else {\n                  p.setDate(p.getDate() + u);\n                  break;\n                }\n              }\n              y = new Date(p.getFullYear() + 1, 0, 4);\n              u = k(new Date(\n                p.getFullYear(),\n                0,\n                4\n              ));\n              y = k(y);\n              return 0 >= h(u, p) ? 0 >= h(y, p) ? p.getFullYear() + 1 : p.getFullYear() : p.getFullYear() - 1;\n            }\n            a >>>= 0;\n            b >>>= 0;\n            c >>>= 0;\n            d >>>= 0;\n            var m = I[d + 40 >>> 2 >>> 0];\n            d = { ji: G[d >>> 2 >>> 0], ii: G[d + 4 >>> 2 >>> 0], Qh: G[d + 8 >>> 2 >>> 0], Th: G[d + 12 >>> 2 >>> 0], Rh: G[d + 16 >>> 2 >>> 0], Lh: G[d + 20 >>> 2 >>> 0], Jh: G[d + 24 >>> 2 >>> 0], Kh: G[d + 28 >>> 2 >>> 0], li: G[d + 32 >>> 2 >>> 0], hi: G[d + 36 >>> 2 >>> 0], ki: m ? J(m) : \"\" };\n            c = J(c);\n            m = {\n              \"%c\": \"%a %b %d %H:%M:%S %Y\",\n              \"%D\": \"%m/%d/%y\",\n              \"%F\": \"%Y-%m-%d\",\n              \"%h\": \"%b\",\n              \"%r\": \"%I:%M:%S %p\",\n              \"%R\": \"%H:%M\",\n              \"%T\": \"%H:%M:%S\",\n              \"%x\": \"%m/%d/%y\",\n              \"%X\": \"%H:%M:%S\",\n              \"%Ec\": \"%c\",\n              \"%EC\": \"%C\",\n              \"%Ex\": \"%m/%d/%y\",\n              \"%EX\": \"%H:%M:%S\",\n              \"%Ey\": \"%y\",\n              \"%EY\": \"%Y\",\n              \"%Od\": \"%d\",\n              \"%Oe\": \"%e\",\n              \"%OH\": \"%H\",\n              \"%OI\": \"%I\",\n              \"%Om\": \"%m\",\n              \"%OM\": \"%M\",\n              \"%OS\": \"%S\",\n              \"%Ou\": \"%u\",\n              \"%OU\": \"%U\",\n              \"%OV\": \"%V\",\n              \"%Ow\": \"%w\",\n              \"%OW\": \"%W\",\n              \"%Oy\": \"%y\"\n            };\n            for (var n in m)\n              c = c.replace(new RegExp(n, \"g\"), m[n]);\n            var q = \"Sunday Monday Tuesday Wednesday Thursday Friday Saturday\".split(\" \"), r = \"January February March April May June July August September October November December\".split(\" \");\n            m = { \"%a\": (p) => q[p.Jh].substring(0, 3), \"%A\": (p) => q[p.Jh], \"%b\": (p) => r[p.Rh].substring(0, 3), \"%B\": (p) => r[p.Rh], \"%C\": (p) => f((p.Lh + 1900) / 100 | 0, 2), \"%d\": (p) => f(p.Th, 2), \"%e\": (p) => e(p.Th, 2, \" \"), \"%g\": (p) => l(p).toString().substring(2), \"%G\": l, \"%H\": (p) => f(p.Qh, 2), \"%I\": (p) => {\n              p = p.Qh;\n              0 == p ? p = 12 : 12 < p && (p -= 12);\n              return f(p, 2);\n            }, \"%j\": (p) => {\n              for (var u = 0, y = 0; y <= p.Rh - 1; u += (W(p.Lh + 1900) ? ec : fc)[y++])\n                ;\n              return f(p.Th + u, 3);\n            }, \"%m\": (p) => f(p.Rh + 1, 2), \"%M\": (p) => f(p.ii, 2), \"%n\": () => \"\\n\", \"%p\": (p) => 0 <= p.Qh && 12 > p.Qh ? \"AM\" : \"PM\", \"%S\": (p) => f(p.ji, 2), \"%t\": () => \"\t\", \"%u\": (p) => p.Jh || 7, \"%U\": (p) => f(Math.floor((p.Kh + 7 - p.Jh) / 7), 2), \"%V\": (p) => {\n              var u = Math.floor((p.Kh + 7 - (p.Jh + 6) % 7) / 7);\n              2 >= (p.Jh + 371 - p.Kh - 2) % 7 && u++;\n              if (u)\n                53 == u && (y = (p.Jh + 371 - p.Kh) % 7, 4 == y || 3 == y && W(p.Lh) || (u = 1));\n              else {\n                u = 52;\n                var y = (p.Jh + 7 - p.Kh - 1) % 7;\n                (4 == y || 5 == y && W(p.Lh % 400 - 1)) && u++;\n              }\n              return f(u, 2);\n            }, \"%w\": (p) => p.Jh, \"%W\": (p) => f(Math.floor((p.Kh + 7 - (p.Jh + 6) % 7) / 7), 2), \"%y\": (p) => (p.Lh + 1900).toString().substring(2), \"%Y\": (p) => p.Lh + 1900, \"%z\": (p) => {\n              p = p.hi;\n              var u = 0 <= p;\n              p = Math.abs(p) / 60;\n              return (u ? \"+\" : \"-\") + String(\"0000\" + (p / 60 * 100 + p % 60)).slice(-4);\n            }, \"%Z\": (p) => p.ki, \"%%\": () => \"%\" };\n            c = c.replace(/%%/g, \"\\0\\0\");\n            for (n in m)\n              c.includes(n) && (c = c.replace(new RegExp(n, \"g\"), m[n](d)));\n            c = c.replace(/\\0\\0/g, \"%\");\n            n = gc(c);\n            if (n.length > b)\n              return 0;\n            z.set(n, a >>> 0);\n            return n.length - 1;\n          }\n          for (var ic = Array(256), jc = 0; 256 > jc; ++jc)\n            ic[jc] = String.fromCharCode(jc);\n          cb = ic;\n          O = g.BindingError = class extends Error {\n            constructor(a) {\n              super(a);\n              this.name = \"BindingError\";\n            }\n          };\n          g.InternalError = class extends Error {\n            constructor(a) {\n              super(a);\n              this.name = \"InternalError\";\n            }\n          };\n          Q.push(0, 1, void 0, 1, null, 1, true, 1, false, 1);\n          g.count_emval_handles = () => Q.length / 2 - 5 - ib.length;\n          var Cf = {\n            bd: function(a, b, c) {\n              return Ob(async () => {\n                await g.bi(a, b, c);\n              });\n            },\n            v: function(a) {\n              a = new Sa(a >>> 0);\n              0 == z[a.Ih + 12 >>> 0] && (z[a.Ih + 12 >>> 0] = 1, Ra--);\n              z[a.Ih + 13 >>> 0] = 0;\n              Qa.push(a);\n              kc(a.Nh);\n              if (lc(I[a.Ih + 4 >>> 2 >>> 0]))\n                a = I[a.Nh >>> 2 >>> 0];\n              else {\n                var b = I[a.Ih + 16 >>> 2 >>> 0];\n                a = 0 !== b ? b : a.Nh;\n              }\n              return a;\n            },\n            N: () => {\n              X(0, 0);\n              var a = Qa.pop();\n              mc(a.Nh);\n              L = 0;\n            },\n            a: function() {\n              return Za([]);\n            },\n            m: function(a) {\n              return Za([a >>> 0]);\n            },\n            x: function(a, b) {\n              return Za([a >>> 0, b >>> 0]);\n            },\n            q: function(a, b, c) {\n              return Za([a >>> 0, b >>> 0, c >>> 0]);\n            },\n            Bb: () => {\n              var a = Qa.pop();\n              a || Ga(\"no exception to throw\");\n              var b = a.Nh;\n              0 == z[a.Ih + 13 >>> 0] && (Qa.push(a), z[a.Ih + 13 >>> 0] = 1, z[a.Ih + 12 >>> 0] = 0, Ra++);\n              L = b;\n              throw L;\n            },\n            s: function(a, b, c) {\n              a >>>= 0;\n              var d = new Sa(a);\n              I[d.Ih + 16 >>> 2 >>> 0] = 0;\n              I[d.Ih + 4 >>> 2 >>> 0] = b >>> 0;\n              I[d.Ih + 8 >>> 2 >>> 0] = c >>> 0;\n              L = a;\n              Ra++;\n              throw L;\n            },\n            fb: () => Ra,\n            g: function(a) {\n              L ||= a >>> 0;\n              throw L;\n            },\n            Cb: function() {\n              return 0;\n            },\n            $c: function() {\n            },\n            Mc: function() {\n            },\n            Oc: function() {\n            },\n            Gc: function() {\n              return 0;\n            },\n            Zc: function() {\n            },\n            Uc: function() {\n            },\n            Yc: function() {\n            },\n            _b: function() {\n            },\n            Nc: function() {\n            },\n            Kc: function() {\n            },\n            _c: function() {\n            },\n            Lc: function() {\n            },\n            Wb: function(a, b, c) {\n              b = N(b >>> 0);\n              P(a >>> 0, { name: b, fromWireType: (d) => d, toWireType: function(d, e) {\n                if (\"bigint\" != typeof e && \"number\" != typeof e)\n                  throw null === e ? e = \"null\" : (d = typeof e, e = \"object\" === d || \"array\" === d || \"function\" === d ? e.toString() : \"\" + e), new TypeError(`Cannot convert \"${e}\" to ${this.name}`);\n                \"number\" == typeof e && (e = BigInt(e));\n                return e;\n              }, argPackAdvance: 8, readValueFromPointer: hb(b, c >>> 0, -1 == b.indexOf(\"u\")), Mh: null });\n            },\n            Ec: function(a, b, c, d) {\n              b = N(b >>> 0);\n              P(a >>> 0, { name: b, fromWireType: function(e) {\n                return !!e;\n              }, toWireType: function(e, f) {\n                return f ? c : d;\n              }, argPackAdvance: 8, readValueFromPointer: function(e) {\n                return this.fromWireType(E[e >>> 0]);\n              }, Mh: null });\n            },\n            Cc: function(a) {\n              return P(a >>> 0, lb);\n            },\n            Vb: function(a, b, c) {\n              b = N(b >>> 0);\n              P(a >>> 0, { name: b, fromWireType: (d) => d, toWireType: (d, e) => e, argPackAdvance: 8, readValueFromPointer: mb(b, c >>> 0), Mh: null });\n            },\n            Aa: function(a, b, c, d, e) {\n              a >>>= 0;\n              c >>>= 0;\n              b = N(b >>> 0);\n              -1 === e && (e = 4294967295);\n              e = (k) => k;\n              if (0 === d) {\n                var f = 32 - 8 * c;\n                e = (k) => k << f >>> f;\n              }\n              var h = b.includes(\"unsigned\") ? function(k, l) {\n                return l >>> 0;\n              } : function(k, l) {\n                return l;\n              };\n              P(a, {\n                name: b,\n                fromWireType: e,\n                toWireType: h,\n                argPackAdvance: 8,\n                readValueFromPointer: hb(b, c, 0 !== d),\n                Mh: null\n              });\n            },\n            _: function(a, b, c) {\n              function d(f) {\n                return new e(z.buffer, I[f + 4 >>> 2 >>> 0], I[f >>> 2 >>> 0]);\n              }\n              var e = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array][b];\n              c = N(c >>> 0);\n              P(a >>> 0, { name: c, fromWireType: d, argPackAdvance: 8, readValueFromPointer: d }, { Xh: true });\n            },\n            Xb: function(a, b) {\n              b = N(b >>> 0);\n              var c = \"std::string\" === b;\n              P(a >>> 0, { name: b, fromWireType: function(d) {\n                var e = I[d >>> 2 >>> 0], f = d + 4;\n                if (c)\n                  for (var h = f, k = 0; k <= e; ++k) {\n                    var l = f + k;\n                    if (k == e || 0 == E[l >>> 0]) {\n                      h = J(h, l - h);\n                      if (void 0 === m)\n                        var m = h;\n                      else\n                        m += String.fromCharCode(0), m += h;\n                      h = l + 1;\n                    }\n                  }\n                else {\n                  m = Array(e);\n                  for (k = 0; k < e; ++k)\n                    m[k] = String.fromCharCode(E[f + k >>> 0]);\n                  m = m.join(\"\");\n                }\n                T(d);\n                return m;\n              }, toWireType: function(d, e) {\n                e instanceof ArrayBuffer && (e = new Uint8Array(e));\n                var f = \"string\" == typeof e;\n                if (!(f || e instanceof Uint8Array || e instanceof Uint8ClampedArray || e instanceof Int8Array))\n                  throw new O(\"Cannot pass non-string to std::string\");\n                var h = c && f ? bb(e) : e.length;\n                var k = Jb(4 + h + 1), l = k + 4;\n                I[k >>> 2 >>> 0] = h;\n                if (c && f)\n                  M(e, E, l, h + 1);\n                else if (f)\n                  for (f = 0; f < h; ++f) {\n                    var m = e.charCodeAt(f);\n                    if (255 < m)\n                      throw T(l), new O(\"String has UTF-16 code units that do not fit in 8 bits\");\n                    E[l + f >>> 0] = m;\n                  }\n                else\n                  for (f = 0; f < h; ++f)\n                    E[l + f >>> 0] = e[f];\n                null !== d && d.push(T, k);\n                return k;\n              }, argPackAdvance: 8, readValueFromPointer: kb, Mh(d) {\n                T(d);\n              } });\n            },\n            Ab: function(a, b, c) {\n              b >>>= 0;\n              c >>>= 0;\n              c = N(c);\n              if (2 === b) {\n                var d = ob;\n                var e = pb;\n                var f = qb;\n                var h = (k) => ua[k >>> 1 >>> 0];\n              } else\n                4 === b && (d = rb, e = sb, f = tb, h = (k) => I[k >>> 2 >>> 0]);\n              P(a >>> 0, {\n                name: c,\n                fromWireType: (k) => {\n                  for (var l = I[k >>> 2 >>> 0], m, n = k + 4, q = 0; q <= l; ++q) {\n                    var r = k + 4 + q * b;\n                    if (q == l || 0 == h(r))\n                      n = d(n, r - n), void 0 === m ? m = n : (m += String.fromCharCode(0), m += n), n = r + b;\n                  }\n                  T(k);\n                  return m;\n                },\n                toWireType: (k, l) => {\n                  if (\"string\" != typeof l)\n                    throw new O(`Cannot pass non-string to C++ string type ${c}`);\n                  var m = f(l), n = Jb(4 + m + b);\n                  I[n >>> 2 >>> 0] = m / b;\n                  e(l, n + 4, m + b);\n                  null !== k && k.push(T, n);\n                  return n;\n                },\n                argPackAdvance: 8,\n                readValueFromPointer: kb,\n                Mh(k) {\n                  T(k);\n                }\n              });\n            },\n            Fc: function(a, b) {\n              b = N(b >>> 0);\n              P(a >>> 0, { Yh: true, name: b, argPackAdvance: 0, fromWireType: () => {\n              }, toWireType: () => {\n              } });\n            },\n            ad: () => 1,\n            kd: function(a, b, c) {\n              b >>>= 0;\n              c >>>= 0;\n              a = R(a >>> 0);\n              b = vb(b, \"emval::as\");\n              return wb(b, c, a);\n            },\n            Cd: function(a) {\n              a >>>= 0;\n              return Ob(() => {\n                a = R(a);\n                return a.then(S);\n              });\n            },\n            ud: function(a, b, c, d) {\n              c >>>= 0;\n              d >>>= 0;\n              a = Pb[a >>> 0];\n              b = R(b >>> 0);\n              return a(null, b, c, d);\n            },\n            ia: function(a, b, c, d, e) {\n              c >>>= 0;\n              d >>>= 0;\n              e >>>= 0;\n              a = Pb[a >>> 0];\n              b = R(b >>> 0);\n              c = Rb(c);\n              return a(b, b[c], d, e);\n            },\n            Bc: jb,\n            qd: function(a, b) {\n              b >>>= 0;\n              a = R(a >>> 0);\n              b = R(b);\n              return a == b;\n            },\n            zd: function(a) {\n              a >>>= 0;\n              if (0 === a)\n                return S(Sb());\n              a = Rb(a);\n              return S(Sb()[a]);\n            },\n            ha: function(a, b, c) {\n              b = Ub(a, b >>> 0);\n              var d = b.shift();\n              a--;\n              var e = \"return function (obj, func, destructorsRef, args) {\\n\", f = 0, h = [];\n              0 === c && h.push(\"obj\");\n              for (var k = [\"retType\"], l = [d], m = 0; m < a; ++m)\n                h.push(\"arg\" + m), k.push(\"argType\" + m), l.push(b[m]), e += `  var arg${m} = argType${m}.readValueFromPointer(args${f ? \"+\" + f : \"\"});\n`, f += b[m].argPackAdvance;\n              e += `  var rv = ${1 === c ? \"new func\" : \"func.call\"}(${h.join(\", \")});\n`;\n              d.Yh || (k.push(\"emval_returnValue\"), l.push(wb), e += \"  return emval_returnValue(retType, destructorsRef, rv);\\n\");\n              k.push(e + \"};\\n\");\n              a = Wb(k)(...l);\n              c = `methodCaller<(${b.map((n) => n.name).join(\", \")}) => ${d.name}>`;\n              return Tb(Vb(c, a));\n            },\n            yd: function(a, b) {\n              b >>>= 0;\n              a = R(a >>> 0);\n              b = R(b);\n              return S(a[b]);\n            },\n            ba: function(a) {\n              a >>>= 0;\n              9 < a && (Q[a + 1] += 1);\n            },\n            md: function() {\n              return S([]);\n            },\n            hd: function(a) {\n              a = R(a >>> 0);\n              for (var b = Array(a.length), c = 0; c < a.length; c++)\n                b[c] = a[c];\n              return S(b);\n            },\n            U: function(a) {\n              return S(Rb(a >>> 0));\n            },\n            Xa: function() {\n              return S({});\n            },\n            vd: function(a) {\n              a >>>= 0;\n              for (var b = R(a); b.length; ) {\n                var c = b.pop();\n                b.pop()(c);\n              }\n              jb(a);\n            },\n            sd: function(a, b, c) {\n              b >>>= 0;\n              c >>>= 0;\n              a = R(a >>> 0);\n              b = R(b);\n              c = R(c);\n              a[b] = c;\n            },\n            zb: function(a, b) {\n              b >>>= 0;\n              a = vb(a >>> 0, \"_emval_take_value\");\n              a = a.readValueFromPointer(b);\n              return S(a);\n            },\n            Rc: function(a, b) {\n              a = -9007199254740992 > a || 9007199254740992 < a ? NaN : Number(a);\n              b >>>= 0;\n              a = new Date(1e3 * a);\n              G[b >>> 2 >>> 0] = a.getUTCSeconds();\n              G[b + 4 >>> 2 >>> 0] = a.getUTCMinutes();\n              G[b + 8 >>> 2 >>> 0] = a.getUTCHours();\n              G[b + 12 >>> 2 >>> 0] = a.getUTCDate();\n              G[b + 16 >>> 2 >>> 0] = a.getUTCMonth();\n              G[b + 20 >>> 2 >>> 0] = a.getUTCFullYear() - 1900;\n              G[b + 24 >>> 2 >>> 0] = a.getUTCDay();\n              G[b + 28 >>> 2 >>> 0] = (a.getTime() - Date.UTC(\n                a.getUTCFullYear(),\n                0,\n                1,\n                0,\n                0,\n                0,\n                0\n              )) / 864e5 | 0;\n            },\n            Sc: function(a, b) {\n              a = -9007199254740992 > a || 9007199254740992 < a ? NaN : Number(a);\n              b >>>= 0;\n              a = new Date(1e3 * a);\n              G[b >>> 2 >>> 0] = a.getSeconds();\n              G[b + 4 >>> 2 >>> 0] = a.getMinutes();\n              G[b + 8 >>> 2 >>> 0] = a.getHours();\n              G[b + 12 >>> 2 >>> 0] = a.getDate();\n              G[b + 16 >>> 2 >>> 0] = a.getMonth();\n              G[b + 20 >>> 2 >>> 0] = a.getFullYear() - 1900;\n              G[b + 24 >>> 2 >>> 0] = a.getDay();\n              G[b + 28 >>> 2 >>> 0] = (W(a.getFullYear()) ? Xb : Yb)[a.getMonth()] + a.getDate() - 1 | 0;\n              G[b + 36 >>> 2 >>> 0] = -(60 * a.getTimezoneOffset());\n              var c = new Date(a.getFullYear(), 6, 1).getTimezoneOffset(), d = new Date(a.getFullYear(), 0, 1).getTimezoneOffset();\n              G[b + 32 >>> 2 >>> 0] = (c != d && a.getTimezoneOffset() == Math.min(d, c)) | 0;\n            },\n            Tc: function(a) {\n              a >>>= 0;\n              var b = new Date(G[a + 20 >>> 2 >>> 0] + 1900, G[a + 16 >>> 2 >>> 0], G[a + 12 >>> 2 >>> 0], G[a + 8 >>> 2 >>> 0], G[a + 4 >>> 2 >>> 0], G[a >>> 2 >>> 0], 0), c = G[a + 32 >>> 2 >>> 0], d = b.getTimezoneOffset(), e = new Date(b.getFullYear(), 6, 1).getTimezoneOffset(), f = new Date(b.getFullYear(), 0, 1).getTimezoneOffset(), h = Math.min(f, e);\n              0 > c ? G[a + 32 >>> 2 >>> 0] = Number(e != f && h == d) : 0 < c != (h == d) && (e = Math.max(f, e), b.setTime(b.getTime() + 6e4 * ((0 < c ? h : e) - d)));\n              G[a + 24 >>> 2 >>> 0] = b.getDay();\n              G[a + 28 >>> 2 >>> 0] = (W(b.getFullYear()) ? Xb : Yb)[b.getMonth()] + b.getDate() - 1 | 0;\n              G[a >>> 2 >>> 0] = b.getSeconds();\n              G[a + 4 >>> 2 >>> 0] = b.getMinutes();\n              G[a + 8 >>> 2 >>> 0] = b.getHours();\n              G[a + 12 >>> 2 >>> 0] = b.getDate();\n              G[a + 16 >>> 2 >>> 0] = b.getMonth();\n              G[a + 20 >>> 2 >>> 0] = b.getYear();\n              a = b.getTime();\n              return BigInt(isNaN(a) ? -1 : a / 1e3);\n            },\n            Pc: function() {\n              return -52;\n            },\n            Qc: function() {\n            },\n            Ic: function(a, b, c, d) {\n              c >>>= 0;\n              d >>>= 0;\n              var e = (/* @__PURE__ */ new Date()).getFullYear(), f = new Date(e, 0, 1), h = new Date(e, 6, 1);\n              e = f.getTimezoneOffset();\n              var k = h.getTimezoneOffset();\n              I[a >>> 0 >>> 2 >>> 0] = 60 * Math.max(e, k);\n              G[b >>> 0 >>> 2 >>> 0] = Number(e != k);\n              a = (l) => l.toLocaleTimeString(void 0, { hour12: false, timeZoneName: \"short\" }).split(\" \")[1];\n              f = a(f);\n              h = a(h);\n              k < e ? (M(f, E, c, 17), M(h, E, d, 17)) : (M(f, E, d, 17), M(h, E, c, 17));\n            },\n            bb: () => {\n              Ga(\"\");\n            },\n            A: function(a, b, c) {\n              a >>>= 0;\n              b = $b(b >>> 0, c >>> 0);\n              return Oa[a](...b);\n            },\n            bc: function(a, b, c) {\n              a >>>= 0;\n              b = $b(b >>> 0, c >>> 0);\n              return Oa[a](...b);\n            },\n            $b: () => Date.now(),\n            Jc: function() {\n              return 4294901760;\n            },\n            ga: () => performance.now(),\n            Hc: function(a) {\n              a >>>= 0;\n              var b = E.length;\n              if (4294901760 < a)\n                return false;\n              for (var c = 1; 4 >= c; c *= 2) {\n                var d = b * (1 + 0.2 / c);\n                d = Math.min(d, a + 100663296);\n                var e = Math;\n                d = Math.max(a, d);\n                a: {\n                  e = (e.min.call(e, 4294901760, d + (65536 - d % 65536) % 65536) - ra.buffer.byteLength + 65535) / 65536;\n                  try {\n                    ra.grow(e);\n                    za();\n                    var f = 1;\n                    break a;\n                  } catch (h) {\n                  }\n                  f = void 0;\n                }\n                if (f)\n                  return true;\n              }\n              return false;\n            },\n            Wc: function(a, b) {\n              a >>>= 0;\n              b >>>= 0;\n              var c = 0;\n              cc().forEach((d, e) => {\n                var f = b + c;\n                e = I[a + 4 * e >>> 2 >>> 0] = f;\n                for (f = 0; f < d.length; ++f)\n                  z[e++ >>> 0] = d.charCodeAt(f);\n                z[e >>> 0] = 0;\n                c += d.length + 1;\n              });\n              return 0;\n            },\n            Xc: function(a, b) {\n              a >>>= 0;\n              b >>>= 0;\n              var c = cc();\n              I[a >>> 2 >>> 0] = c.length;\n              var d = 0;\n              c.forEach((e) => d += e.length + 1);\n              I[b >>> 2 >>> 0] = d;\n              return 0;\n            },\n            Db: () => 52,\n            Zb: function() {\n              return 52;\n            },\n            Vc: function() {\n              return 70;\n            },\n            Yb: function(a, b, c, d) {\n              b >>>= 0;\n              c >>>= 0;\n              d >>>= 0;\n              for (var e = 0, f = 0; f < c; f++) {\n                var h = I[b >>> 2 >>> 0], k = I[b + 4 >>> 2 >>> 0];\n                b += 8;\n                for (var l = 0; l < k; l++) {\n                  var m = E[h + l >>> 0], n = dc[a];\n                  0 === m || 10 === m ? ((1 === a ? qa : w)(ab(n, 0)), n.length = 0) : n.push(m);\n                }\n                e += k;\n              }\n              I[d >>> 2 >>> 0] = e;\n              return 0;\n            },\n            xb: nc,\n            cd: oc,\n            ua: pc,\n            W: qc,\n            $: rc,\n            ra: sc,\n            ta: tc,\n            dd: uc,\n            ob: vc,\n            P: wc,\n            z: xc,\n            b: yc,\n            Ub: zc,\n            ya: Ac,\n            e: Bc,\n            kb: Cc,\n            h: Dc,\n            X: Ec,\n            i: Fc,\n            ed: Gc,\n            j: Hc,\n            t: Ic,\n            r: Jc,\n            o: Kc,\n            Wa: Lc,\n            Ca: Mc,\n            ma: Nc,\n            Qb: Oc,\n            db: Pc,\n            Ib: Qc,\n            mb: Rc,\n            kc: Sc,\n            xc: Tc,\n            hc: Uc,\n            ic: Vc,\n            ac: Wc,\n            oa: Xc,\n            yb: Yc,\n            Ba: Zc,\n            Eb: $c,\n            ea: ad,\n            jc: bd,\n            Ta: cd,\n            F: dd,\n            G: ed,\n            Gb: fd,\n            jd: gd,\n            qa: hd,\n            O: jd,\n            V: kd,\n            T: ld,\n            y: md,\n            Fb: nd,\n            gc: od,\n            D: pd,\n            Hb: qd,\n            id: rd,\n            Ua: sd,\n            wa: td,\n            lc: ud,\n            cc: vd,\n            Nb: wd,\n            aa: xd,\n            I: yd,\n            C: zd,\n            _a: Ad,\n            fc: Bd,\n            Q: Cd,\n            d: Dd,\n            ab: Ed,\n            n: Fd,\n            Ya: Gd,\n            va: Hd,\n            wb: Id,\n            f: Jd,\n            yc: Kd,\n            da: Ld,\n            gb: Md,\n            Da: Nd,\n            lb: Od,\n            hb: Pd,\n            c: Qd,\n            vc: Rd,\n            od: Sd,\n            k: Td,\n            tc: Ud,\n            l: Vd,\n            wc: Wd,\n            sc: Xd,\n            rd: Yd,\n            p: Zd,\n            Ra: $d,\n            tb: ae,\n            Qa: be,\n            Kb: ce,\n            B: de,\n            K: ee,\n            S: fe,\n            $a: ge,\n            pc: he,\n            ub: ie,\n            za: je,\n            ka: ke,\n            xa: le,\n            Sb: me,\n            La: ne,\n            jb: oe,\n            Ga: pe,\n            nc: qe,\n            Ha: re,\n            Ia: se,\n            fd: te,\n            xd: ue,\n            Z: ve,\n            pa: we,\n            pd: xe,\n            wd: ye,\n            Mb: ze,\n            Ma: Ae,\n            Ka: Be,\n            Tb: Ce,\n            rc: De,\n            Ja: Ee,\n            Na: Fe,\n            pb: Ge,\n            la: He,\n            Ea: Ie,\n            mc: Je,\n            qc: Ke,\n            Jb: Le,\n            Fa: Me,\n            ja: Ne,\n            Ad: Oe,\n            nd: Pe,\n            R: Qe,\n            eb: Re,\n            Za: Se,\n            ec: Te,\n            ib: Ue,\n            E: Ve,\n            M: We,\n            Va: Xe,\n            ld: Ye,\n            ca: Ze,\n            nb: $e,\n            na: af,\n            dc: bf,\n            Ac: cf,\n            u: df,\n            L: ef,\n            td: ff,\n            Pb: gf,\n            oc: hf,\n            Bd: jf,\n            Ob: kf,\n            Lb: lf,\n            cb: mf,\n            zc: nf,\n            Rb: of,\n            Oa: pf,\n            Y: qf,\n            uc: rf,\n            J: sf,\n            gd: tf,\n            vb: uf,\n            sa: vf,\n            H: wf,\n            rb: xf,\n            Pa: yf,\n            Sa: zf,\n            sb: Af,\n            qb: Bf,\n            w: function(a) {\n              return a >>> 0;\n            },\n            Dc: hc,\n            fa: function(a, b, c, d) {\n              return hc(a >>> 0, b >>> 0, c >>> 0, d >>> 0);\n            }\n          }, U = function() {\n            function a(c) {\n              U = c.exports;\n              U = zb();\n              U = Df();\n              ra = U.Dd;\n              za();\n              Ba.unshift(U.Ed);\n              Da--;\n              0 == Da && (null !== Ea && (clearInterval(Ea), Ea = null), Fa && (c = Fa, Fa = null, c()));\n              return U;\n            }\n            var b = { a: Cf };\n            Da++;\n            if (g.instantiateWasm)\n              try {\n                return g.instantiateWasm(b, a);\n              } catch (c) {\n                w(`Module.instantiateWasm callback failed with error: ${c}`), ba(c);\n              }\n            Na(b, function(c) {\n              a(c.instance);\n            }).catch(ba);\n            return {};\n          }(), ub = (a) => (ub = U.Fd)(a);\n          g._OrtInit = (a, b) => (g._OrtInit = U.Gd)(a, b);\n          g._OrtGetLastError = (a, b) => (g._OrtGetLastError = U.Hd)(a, b);\n          g._OrtCreateSessionOptions = (a, b, c, d, e, f, h, k, l, m) => (g._OrtCreateSessionOptions = U.Id)(a, b, c, d, e, f, h, k, l, m);\n          g._OrtAppendExecutionProvider = (a, b) => (g._OrtAppendExecutionProvider = U.Jd)(a, b);\n          g._OrtAddFreeDimensionOverride = (a, b, c) => (g._OrtAddFreeDimensionOverride = U.Kd)(a, b, c);\n          g._OrtAddSessionConfigEntry = (a, b, c) => (g._OrtAddSessionConfigEntry = U.Ld)(a, b, c);\n          g._OrtReleaseSessionOptions = (a) => (g._OrtReleaseSessionOptions = U.Md)(a);\n          g._OrtCreateSession = (a, b, c) => (g._OrtCreateSession = U.Nd)(a, b, c);\n          g._OrtReleaseSession = (a) => (g._OrtReleaseSession = U.Od)(a);\n          g._OrtGetInputOutputCount = (a, b, c) => (g._OrtGetInputOutputCount = U.Pd)(a, b, c);\n          g._OrtGetInputName = (a, b) => (g._OrtGetInputName = U.Qd)(a, b);\n          g._OrtGetOutputName = (a, b) => (g._OrtGetOutputName = U.Rd)(a, b);\n          g._OrtFree = (a) => (g._OrtFree = U.Sd)(a);\n          g._OrtCreateTensor = (a, b, c, d, e, f) => (g._OrtCreateTensor = U.Td)(a, b, c, d, e, f);\n          g._OrtGetTensorData = (a, b, c, d, e) => (g._OrtGetTensorData = U.Ud)(a, b, c, d, e);\n          g._OrtReleaseTensor = (a) => (g._OrtReleaseTensor = U.Vd)(a);\n          g._OrtCreateRunOptions = (a, b, c, d) => (g._OrtCreateRunOptions = U.Wd)(a, b, c, d);\n          g._OrtAddRunConfigEntry = (a, b, c) => (g._OrtAddRunConfigEntry = U.Xd)(a, b, c);\n          g._OrtReleaseRunOptions = (a) => (g._OrtReleaseRunOptions = U.Yd)(a);\n          g._OrtCreateBinding = (a) => (g._OrtCreateBinding = U.Zd)(a);\n          g._OrtBindInput = (a, b, c) => (g._OrtBindInput = U._d)(a, b, c);\n          g._OrtBindOutput = (a, b, c, d) => (g._OrtBindOutput = U.$d)(a, b, c, d);\n          g._OrtClearBoundOutputs = (a) => (g._OrtClearBoundOutputs = U.ae)(a);\n          g._OrtReleaseBinding = (a) => (g._OrtReleaseBinding = U.be)(a);\n          g._OrtRunWithBinding = (a, b, c, d, e) => (g._OrtRunWithBinding = U.ce)(a, b, c, d, e);\n          g._OrtRun = (a, b, c, d, e, f, h, k) => (g._OrtRun = U.de)(a, b, c, d, e, f, h, k);\n          g._OrtEndProfiling = (a) => (g._OrtEndProfiling = U.ee)(a);\n          g._JsepOutput = (a, b, c) => (g._JsepOutput = U.fe)(a, b, c);\n          g._JsepGetNodeName = (a) => (g._JsepGetNodeName = U.ge)(a);\n          var Jb = g._malloc = (a) => (Jb = g._malloc = U.he)(a), T = g._free = (a) => (T = g._free = U.ie)(a), X = (a, b) => (X = U.ke)(a, b), Ta = (a) => (Ta = U.le)(a), Y = (a) => (Y = U.me)(a), Ef = (a) => (Ef = U.ne)(a), Z = () => (Z = U.oe)(), mc = (a) => (mc = U.pe)(a), kc = (a) => (kc = U.qe)(a), Ua = (a, b, c) => (Ua = U.re)(a, b, c), lc = (a) => (lc = U.se)(a), dynCall_vii = g.dynCall_vii = (a, b, c) => (dynCall_vii = g.dynCall_vii = U.te)(a, b, c), Ff = g.dynCall_iiii = (a, b, c, d) => (Ff = g.dynCall_iiii = U.ue)(a, b, c, d), dynCall_iii = g.dynCall_iii = (a, b, c) => (dynCall_iii = g.dynCall_iii = U.ve)(a, b, c), Gf = g.dynCall_ii = (a, b) => (Gf = g.dynCall_ii = U.we)(a, b), Hf = g.dynCall_iiiiiii = (a, b, c, d, e, f, h) => (Hf = g.dynCall_iiiiiii = U.xe)(a, b, c, d, e, f, h), dynCall_vi = g.dynCall_vi = (a, b) => (dynCall_vi = g.dynCall_vi = U.ye)(a, b), dynCall_v = g.dynCall_v = (a) => (dynCall_v = g.dynCall_v = U.ze)(a), If = g.dynCall_iiiiii = (a, b, c, d, e, f) => (If = g.dynCall_iiiiii = U.Ae)(a, b, c, d, e, f), Jf = g.dynCall_iiij = (a, b, c, d) => (Jf = g.dynCall_iiij = U.Be)(a, b, c, d), Kf = g.dynCall_iiiii = (a, b, c, d, e) => (Kf = g.dynCall_iiiii = U.Ce)(a, b, c, d, e), Lf = g.dynCall_viii = (a, b, c, d) => (Lf = g.dynCall_viii = U.De)(a, b, c, d), Mf = g.dynCall_viiiii = (a, b, c, d, e, f) => (Mf = g.dynCall_viiiii = U.Ee)(a, b, c, d, e, f), Nf = g.dynCall_viiii = (a, b, c, d, e) => (Nf = g.dynCall_viiii = U.Fe)(a, b, c, d, e), Of = g.dynCall_viiiiii = (a, b, c, d, e, f, h) => (Of = g.dynCall_viiiiii = U.Ge)(a, b, c, d, e, f, h), Pf = g.dynCall_viiji = (a, b, c, d, e) => (Pf = g.dynCall_viiji = U.He)(a, b, c, d, e), Qf = g.dynCall_viiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q) => (Qf = g.dynCall_viiiiiiiiiii = U.Ie)(a, b, c, d, e, f, h, k, l, m, n, q), Rf = g.dynCall_viiijjjii = (a, b, c, d, e, f, h, k, l) => (Rf = g.dynCall_viiijjjii = U.Je)(a, b, c, d, e, f, h, k, l), Sf = g.dynCall_iid = (a, b, c) => (Sf = g.dynCall_iid = U.Ke)(a, b, c), Tf = g.dynCall_iif = (a, b, c) => (Tf = g.dynCall_iif = U.Le)(a, b, c), Uf = g.dynCall_iij = (a, b, c) => (Uf = g.dynCall_iij = U.Me)(a, b, c), Vf = g.dynCall_jii = (a, b, c) => (Vf = g.dynCall_jii = U.Ne)(a, b, c), Wf = g.dynCall_i = (a) => (Wf = g.dynCall_i = U.Oe)(a), Xf = g.dynCall_viiiiiiii = (a, b, c, d, e, f, h, k, l) => (Xf = g.dynCall_viiiiiiii = U.Pe)(a, b, c, d, e, f, h, k, l), Yf = g.dynCall_viiiiij = (a, b, c, d, e, f, h) => (Yf = g.dynCall_viiiiij = U.Qe)(a, b, c, d, e, f, h), Zf = g.dynCall_ji = (a, b) => (Zf = g.dynCall_ji = U.Re)(a, b), $f = g.dynCall_viij = (a, b, c, d) => ($f = g.dynCall_viij = U.Se)(a, b, c, d), ag = g.dynCall_iiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q) => (ag = g.dynCall_iiiiiiiiiiii = U.Te)(a, b, c, d, e, f, h, k, l, m, n, q), bg = g.dynCall_viiiiiiiii = (a, b, c, d, e, f, h, k, l, m) => (bg = g.dynCall_viiiiiiiii = U.Ue)(a, b, c, d, e, f, h, k, l, m), cg = g.dynCall_ij = (a, b) => (cg = g.dynCall_ij = U.Ve)(a, b), dg = g.dynCall_iiiiij = (a, b, c, d, e, f) => (dg = g.dynCall_iiiiij = U.We)(a, b, c, d, e, f), eg = g.dynCall_j = (a) => (eg = g.dynCall_j = U.Xe)(a), fg = g.dynCall_vij = (a, b, c) => (fg = g.dynCall_vij = U.Ye)(a, b, c), gg = g.dynCall_viijjjiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q) => (gg = g.dynCall_viijjjiiiiii = U.Ze)(a, b, c, d, e, f, h, k, l, m, n, q), hg = g.dynCall_viiijiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q) => (hg = g.dynCall_viiijiiiiiii = U._e)(a, b, c, d, e, f, h, k, l, m, n, q), ig = g.dynCall_iiiiiiii = (a, b, c, d, e, f, h, k) => (ig = g.dynCall_iiiiiiii = U.$e)(a, b, c, d, e, f, h, k), jg = g.dynCall_viiiiiii = (a, b, c, d, e, f, h, k) => (jg = g.dynCall_viiiiiii = U.af)(a, b, c, d, e, f, h, k), kg = g.dynCall_iiiiiiiij = (a, b, c, d, e, f, h, k, l) => (kg = g.dynCall_iiiiiiiij = U.bf)(a, b, c, d, e, f, h, k, l), lg = g.dynCall_viiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (lg = g.dynCall_viiiiiiiiiiiii = U.cf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), mg = g.dynCall_iiiiiiiii = (a, b, c, d, e, f, h, k, l) => (mg = g.dynCall_iiiiiiiii = U.df)(a, b, c, d, e, f, h, k, l), ng = g.dynCall_iiiiijiiiii = (a, b, c, d, e, f, h, k, l, m, n) => (ng = g.dynCall_iiiiijiiiii = U.ef)(a, b, c, d, e, f, h, k, l, m, n), og = g.dynCall_vijjjiiij = (a, b, c, d, e, f, h, k, l) => (og = g.dynCall_vijjjiiij = U.ff)(a, b, c, d, e, f, h, k, l), pg = g.dynCall_fi = (a, b) => (pg = g.dynCall_fi = U.gf)(a, b), qg = g.dynCall_fii = (a, b, c) => (qg = g.dynCall_fii = U.hf)(a, b, c), rg = g.dynCall_di = (a, b) => (rg = g.dynCall_di = U.jf)(a, b), sg = g.dynCall_dii = (a, b, c) => (sg = g.dynCall_dii = U.kf)(a, b, c), tg = g.dynCall_vijj = (a, b, c, d) => (tg = g.dynCall_vijj = U.lf)(a, b, c, d), ug = g.dynCall_iiiiiiiiii = (a, b, c, d, e, f, h, k, l, m) => (ug = g.dynCall_iiiiiiiiii = U.mf)(a, b, c, d, e, f, h, k, l, m), vg = g.dynCall_viijiii = (a, b, c, d, e, f, h) => (vg = g.dynCall_viijiii = U.nf)(a, b, c, d, e, f, h), wg = g.dynCall_viid = (a, b, c, d) => (wg = g.dynCall_viid = U.of)(a, b, c, d), xg = g.dynCall_viffiii = (a, b, c, d, e, f, h) => (xg = g.dynCall_viffiii = U.pf)(a, b, c, d, e, f, h), yg = g.dynCall_viifiii = (a, b, c, d, e, f, h) => (yg = g.dynCall_viifiii = U.qf)(a, b, c, d, e, f, h), zg = g.dynCall_viiiiidiidi = (a, b, c, d, e, f, h, k, l, m, n) => (zg = g.dynCall_viiiiidiidi = U.rf)(a, b, c, d, e, f, h, k, l, m, n), Ag = g.dynCall_viiiiiiiiidi = (a, b, c, d, e, f, h, k, l, m, n, q) => (Ag = g.dynCall_viiiiiiiiidi = U.sf)(a, b, c, d, e, f, h, k, l, m, n, q), Bg = g.dynCall_jiii = (a, b, c, d) => (Bg = g.dynCall_jiii = U.tf)(a, b, c, d), Cg = g.dynCall_vjiiiiii = (a, b, c, d, e, f, h, k) => (Cg = g.dynCall_vjiiiiii = U.uf)(a, b, c, d, e, f, h, k), Dg = g.dynCall_viiid = (a, b, c, d, e) => (Dg = g.dynCall_viiid = U.vf)(a, b, c, d, e), Eg = g.dynCall_viiiiiiiiiji = (a, b, c, d, e, f, h, k, l, m, n, q) => (Eg = g.dynCall_viiiiiiiiiji = U.wf)(a, b, c, d, e, f, h, k, l, m, n, q), Fg = g.dynCall_viji = (a, b, c, d) => (Fg = g.dynCall_viji = U.xf)(a, b, c, d), Gg = g.dynCall_vijjjjjjjjjjjjji = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => (Gg = g.dynCall_vijjjjjjjjjjjjji = U.yf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y), Hg = g.dynCall_viiiji = (a, b, c, d, e, f) => (Hg = g.dynCall_viiiji = U.zf)(a, b, c, d, e, f), Ig = g.dynCall_vijjjiiji = (a, b, c, d, e, f, h, k, l) => (Ig = g.dynCall_vijjjiiji = U.Af)(a, b, c, d, e, f, h, k, l), Jg = g.dynCall_iiiji = (a, b, c, d, e) => (Jg = g.dynCall_iiiji = U.Bf)(a, b, c, d, e), Kg = g.dynCall_iiijiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (Kg = g.dynCall_iiijiiiiiiiiii = U.Cf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), Lg = g.dynCall_vj = (a, b) => (Lg = g.dynCall_vj = U.Df)(a, b), Mg = g.dynCall_jjj = (a, b, c) => (Mg = g.dynCall_jjj = U.Ef)(a, b, c), Ng = g.dynCall_iiijiiiiii = (a, b, c, d, e, f, h, k, l, m) => (Ng = g.dynCall_iiijiiiiii = U.Ff)(a, b, c, d, e, f, h, k, l, m), Og = g.dynCall_vfiii = (a, b, c, d, e) => (Og = g.dynCall_vfiii = U.Gf)(a, b, c, d, e), Pg = g.dynCall_viiiiff = (a, b, c, d, e, f, h) => (Pg = g.dynCall_viiiiff = U.Hf)(a, b, c, d, e, f, h), Qg = g.dynCall_viiiiiff = (a, b, c, d, e, f, h, k) => (Qg = g.dynCall_viiiiiff = U.If)(a, b, c, d, e, f, h, k), Rg = g.dynCall_viiff = (a, b, c, d, e) => (Rg = g.dynCall_viiff = U.Jf)(a, b, c, d, e), Sg = g.dynCall_viiiiiiiiifiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (Sg = g.dynCall_viiiiiiiiifiii = U.Kf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), Tg = g.dynCall_viiiiiiiijj = (a, b, c, d, e, f, h, k, l, m, n) => (Tg = g.dynCall_viiiiiiiijj = U.Lf)(a, b, c, d, e, f, h, k, l, m, n), Ug = g.dynCall_iiiiiiiiiiiiiifii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) => (Ug = g.dynCall_iiiiiiiiiiiiiifii = U.Mf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A), Vg = g.dynCall_viiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Vg = g.dynCall_viiiiiiiiiiii = U.Nf)(a, b, c, d, e, f, h, k, l, m, n, q, r), Wg = g.dynCall_iiiiiiiiiiiiiiiiifii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) => (Wg = g.dynCall_iiiiiiiiiiiiiiiiifii = U.Of)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D), Xg = g.dynCall_vijjiiiiii = (a, b, c, d, e, f, h, k, l, m) => (Xg = g.dynCall_vijjiiiiii = U.Pf)(a, b, c, d, e, f, h, k, l, m), Yg = g.dynCall_iiiijjj = (a, b, c, d, e, f, h) => (Yg = g.dynCall_iiiijjj = U.Qf)(a, b, c, d, e, f, h), Zg = g.dynCall_viiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n) => (Zg = g.dynCall_viiiiiiiiii = U.Rf)(a, b, c, d, e, f, h, k, l, m, n), $g = g.dynCall_iiijjj = (a, b, c, d, e, f) => ($g = g.dynCall_iiijjj = U.Sf)(a, b, c, d, e, f), ah = g.dynCall_fffffff = (a, b, c, d, e, f, h) => (ah = g.dynCall_fffffff = U.Tf)(a, b, c, d, e, f, h), bh = g.dynCall_viiiij = (a, b, c, d, e, f) => (bh = g.dynCall_viiiij = U.Uf)(a, b, c, d, e, f), ch = g.dynCall_viiiiiijiifiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (ch = g.dynCall_viiiiiijiifiii = U.Vf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), dh = g.dynCall_vjjjjjjffjifiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B) => (dh = g.dynCall_vjjjjjjffjifiiiiii = U.Wf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B), eh = g.dynCall_viiiiiiffjifiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) => (eh = g.dynCall_viiiiiiffjifiiiii = U.Xf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A), fh = g.dynCall_viiiiiiffjfiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => (fh = g.dynCall_viiiiiiffjfiiiii = U.Yf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y), gh = g.dynCall_viiiiiiffjiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => (gh = g.dynCall_viiiiiiffjiiiii = U.Zf)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u), hh = g.dynCall_vjjjjjjjjfffiiifiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) => (hh = g.dynCall_vjjjjjjjjfffiiifiiiii = U._f)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F), ih = g.dynCall_vjjjjjjfffifijiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C) => (ih = g.dynCall_vjjjjjjfffifijiiiii = U.$f)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C), jh = g.dynCall_vjjjjjjfffifiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B) => (jh = g.dynCall_vjjjjjjfffifiiiiii = U.ag)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B), kh = g.dynCall_vjjjjjjjjfffjifiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) => (kh = g.dynCall_vjjjjjjjjfffjifiiiiii = U.bg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F), lh = g.dynCall_vijiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (lh = g.dynCall_vijiiiiiiiiii = U.cg)(a, b, c, d, e, f, h, k, l, m, n, q, r), mh = g.dynCall_vijjfffiii = (a, b, c, d, e, f, h, k, l, m) => (mh = g.dynCall_vijjfffiii = U.dg)(a, b, c, d, e, f, h, k, l, m), nh = g.dynCall_viiiiiiijiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (nh = g.dynCall_viiiiiiijiiii = U.eg)(a, b, c, d, e, f, h, k, l, m, n, q, r), oh = g.dynCall_vijjjjjjifiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => (oh = g.dynCall_vijjjjjjifiiiii = U.fg)(\n            a,\n            b,\n            c,\n            d,\n            e,\n            f,\n            h,\n            k,\n            l,\n            m,\n            n,\n            q,\n            r,\n            p,\n            u\n          ), ph = g.dynCall_viifi = (a, b, c, d, e) => (ph = g.dynCall_viifi = U.gg)(a, b, c, d, e), qh = g.dynCall_vjjjjjiiii = (a, b, c, d, e, f, h, k, l, m) => (qh = g.dynCall_vjjjjjiiii = U.hg)(a, b, c, d, e, f, h, k, l, m), rh = g.dynCall_vjjjjfiii = (a, b, c, d, e, f, h, k, l) => (rh = g.dynCall_vjjjjfiii = U.ig)(a, b, c, d, e, f, h, k, l), sh = g.dynCall_viiiiiijiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (sh = g.dynCall_viiiiiijiiiiii = U.jg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), th = g.dynCall_vijjii = (a, b, c, d, e, f) => (th = g.dynCall_vijjii = U.kg)(a, b, c, d, e, f), uh = g.dynCall_viiiiijjiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (uh = g.dynCall_viiiiijjiiiii = U.lg)(a, b, c, d, e, f, h, k, l, m, n, q, r), vh = g.dynCall_iiiiiji = (a, b, c, d, e, f, h) => (vh = g.dynCall_iiiiiji = U.mg)(a, b, c, d, e, f, h), wh = g.dynCall_iiiiji = (a, b, c, d, e, f) => (wh = g.dynCall_iiiiji = U.ng)(a, b, c, d, e, f), xh = g.dynCall_viiiiijiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (xh = g.dynCall_viiiiijiiiiii = U.og)(a, b, c, d, e, f, h, k, l, m, n, q, r), yh = g.dynCall_viiijiiiiii = (a, b, c, d, e, f, h, k, l, m, n) => (yh = g.dynCall_viiijiiiiii = U.pg)(a, b, c, d, e, f, h, k, l, m, n), zh = g.dynCall_viijj = (a, b, c, d, e) => (zh = g.dynCall_viijj = U.qg)(a, b, c, d, e), Ah = g.dynCall_viiiijii = (a, b, c, d, e, f, h, k) => (Ah = g.dynCall_viiiijii = U.rg)(a, b, c, d, e, f, h, k), Bh = g.dynCall_viijjiii = (a, b, c, d, e, f, h, k) => (Bh = g.dynCall_viijjiii = U.sg)(a, b, c, d, e, f, h, k), Ch = g.dynCall_ijii = (a, b, c, d) => (Ch = g.dynCall_ijii = U.tg)(a, b, c, d), Dh = g.dynCall_viiiiijjji = (a, b, c, d, e, f, h, k, l, m) => (Dh = g.dynCall_viiiiijjji = U.ug)(a, b, c, d, e, f, h, k, l, m), Eh = g.dynCall_vijjjjiij = (a, b, c, d, e, f, h, k, l) => (Eh = g.dynCall_vijjjjiij = U.vg)(a, b, c, d, e, f, h, k, l), Fh = g.dynCall_viiiiijij = (a, b, c, d, e, f, h, k, l) => (Fh = g.dynCall_viiiiijij = U.wg)(a, b, c, d, e, f, h, k, l), Gh = g.dynCall_viiiiiijij = (a, b, c, d, e, f, h, k, l, m) => (Gh = g.dynCall_viiiiiijij = U.xg)(a, b, c, d, e, f, h, k, l, m), Hh = g.dynCall_vijiii = (a, b, c, d, e, f) => (Hh = g.dynCall_vijiii = U.yg)(a, b, c, d, e, f), Ih = g.dynCall_viiiiiiiiifi = (a, b, c, d, e, f, h, k, l, m, n, q) => (Ih = g.dynCall_viiiiiiiiifi = U.zg)(a, b, c, d, e, f, h, k, l, m, n, q), Jh = g.dynCall_iiijiiii = (a, b, c, d, e, f, h, k) => (Jh = g.dynCall_iiijiiii = U.Ag)(a, b, c, d, e, f, h, k), Kh = g.dynCall_viiiiiijjiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (Kh = g.dynCall_viiiiiijjiiiii = U.Bg)(\n            a,\n            b,\n            c,\n            d,\n            e,\n            f,\n            h,\n            k,\n            l,\n            m,\n            n,\n            q,\n            r,\n            p\n          ), Lh = g.dynCall_viiiiiiijiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => (Lh = g.dynCall_viiiiiiijiiiiii = U.Cg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u), Mh = g.dynCall_vif = (a, b, c) => (Mh = g.dynCall_vif = U.Dg)(a, b, c), Nh = g.dynCall_viif = (a, b, c, d) => (Nh = g.dynCall_viif = U.Eg)(a, b, c, d), Oh = g.dynCall_fiii = (a, b, c, d) => (Oh = g.dynCall_fiii = U.Fg)(a, b, c, d), Ph = g.dynCall_diii = (a, b, c, d) => (Ph = g.dynCall_diii = U.Gg)(a, b, c, d), Qh = g.dynCall_viiiiiifii = (a, b, c, d, e, f, h, k, l, m) => (Qh = g.dynCall_viiiiiifii = U.Hg)(a, b, c, d, e, f, h, k, l, m), Rh = g.dynCall_viiiiijiiiiiiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F, H, K, Va, Wa, Xa) => (Rh = g.dynCall_viiiiijiiiiiiiiiiiiiiiiiii = U.Ig)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F, H, K, Va, Wa, Xa), Sh = g.dynCall_viijji = (a, b, c, d, e, f) => (Sh = g.dynCall_viijji = U.Jg)(a, b, c, d, e, f), Th = g.dynCall_iiiiiiiiiiiji = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Th = g.dynCall_iiiiiiiiiiiji = U.Kg)(a, b, c, d, e, f, h, k, l, m, n, q, r), Uh = g.dynCall_viifiifijjjii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Uh = g.dynCall_viifiifijjjii = U.Lg)(a, b, c, d, e, f, h, k, l, m, n, q, r), Vh = g.dynCall_viiiiiiiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) => (Vh = g.dynCall_viiiiiiiiiiiiiiiiiiii = U.Mg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F), Wh = g.dynCall_viiiiifiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Wh = g.dynCall_viiiiifiiiiii = U.Ng)(a, b, c, d, e, f, h, k, l, m, n, q, r), Xh = g.dynCall_vijiiiiiiijjii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p) => (Xh = g.dynCall_vijiiiiiiijjii = U.Og)(a, b, c, d, e, f, h, k, l, m, n, q, r, p), Yh = g.dynCall_viiiiiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C) => (Yh = g.dynCall_viiiiiiiiiiiiiiiiii = U.Pg)(\n            a,\n            b,\n            c,\n            d,\n            e,\n            f,\n            h,\n            k,\n            l,\n            m,\n            n,\n            q,\n            r,\n            p,\n            u,\n            y,\n            A,\n            B,\n            C\n          ), Zh = g.dynCall_viiiiiiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) => (Zh = g.dynCall_viiiiiiiiiiiiiiiiiii = U.Qg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D), $h = g.dynCall_viiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) => ($h = g.dynCall_viiiiiiiiiiiiiii = U.Rg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y), ai = g.dynCall_viiiiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) => (ai = g.dynCall_viiiiiiiiiiiiiiii = U.Sg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A), bi = g.dynCall_viiiijjj = (a, b, c, d, e, f, h, k) => (bi = g.dynCall_viiiijjj = U.Tg)(a, b, c, d, e, f, h, k), ci = g.dynCall_iiiiid = (a, b, c, d, e, f) => (ci = g.dynCall_iiiiid = U.Ug)(a, b, c, d, e, f), di = g.dynCall_viiiiiiijjj = (a, b, c, d, e, f, h, k, l, m, n) => (di = g.dynCall_viiiiiiijjj = U.Vg)(a, b, c, d, e, f, h, k, l, m, n), ei = g.dynCall_iiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n) => (ei = g.dynCall_iiiiiiiiiii = U.Wg)(a, b, c, d, e, f, h, k, l, m, n), fi = g.dynCall_iiiiiiiiiiiiiiiiiifi = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) => (fi = g.dynCall_iiiiiiiiiiiiiiiiiifi = U.Xg)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D), gi = g.dynCall_viiif = (a, b, c, d, e) => (gi = g.dynCall_viiif = U.Yg)(a, b, c, d, e), hi = g.dynCall_viiijiiiii = (a, b, c, d, e, f, h, k, l, m) => (hi = g.dynCall_viiijiiiii = U.Zg)(a, b, c, d, e, f, h, k, l, m), ii = g.dynCall_viiij = (a, b, c, d, e) => (ii = g.dynCall_viiij = U._g)(a, b, c, d, e), ji = g.dynCall_iijjj = (a, b, c, d, e) => (ji = g.dynCall_iijjj = U.$g)(a, b, c, d, e), ki = g.dynCall_viiiiji = (a, b, c, d, e, f, h) => (ki = g.dynCall_viiiiji = U.ah)(a, b, c, d, e, f, h), li = g.dynCall_iijjji = (a, b, c, d, e, f) => (li = g.dynCall_iijjji = U.bh)(a, b, c, d, e, f), mi = g.dynCall_ijijji = (a, b, c, d, e, f) => (mi = g.dynCall_ijijji = U.ch)(\n            a,\n            b,\n            c,\n            d,\n            e,\n            f\n          ), ni = g.dynCall_viiijjiii = (a, b, c, d, e, f, h, k, l) => (ni = g.dynCall_viiijjiii = U.dh)(a, b, c, d, e, f, h, k, l), oi = g.dynCall_iiiiijji = (a, b, c, d, e, f, h, k) => (oi = g.dynCall_iiiiijji = U.eh)(a, b, c, d, e, f, h, k), pi = g.dynCall_iiiifi = (a, b, c, d, e, f) => (pi = g.dynCall_iiiifi = U.fh)(a, b, c, d, e, f), qi = g.dynCall_iiijii = (a, b, c, d, e, f) => (qi = g.dynCall_iiijii = U.gh)(a, b, c, d, e, f), ri = g.dynCall_iiiiiiiiijii = (a, b, c, d, e, f, h, k, l, m, n, q) => (ri = g.dynCall_iiiiiiiiijii = U.hh)(a, b, c, d, e, f, h, k, l, m, n, q), si = g.dynCall_iiiijjii = (a, b, c, d, e, f, h, k) => (si = g.dynCall_iiiijjii = U.ih)(a, b, c, d, e, f, h, k), ti = g.dynCall_iiiiiijjjii = (a, b, c, d, e, f, h, k, l, m, n) => (ti = g.dynCall_iiiiiijjjii = U.jh)(a, b, c, d, e, f, h, k, l, m, n), ui = g.dynCall_iiijiii = (a, b, c, d, e, f, h) => (ui = g.dynCall_iiijiii = U.kh)(a, b, c, d, e, f, h), vi = g.dynCall_iiiiiiiijjjfi = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (vi = g.dynCall_iiiiiiiijjjfi = U.lh)(a, b, c, d, e, f, h, k, l, m, n, q, r), wi = g.dynCall_iijiiii = (a, b, c, d, e, f, h) => (wi = g.dynCall_iijiiii = U.mh)(a, b, c, d, e, f, h), xi = g.dynCall_iijjjii = (a, b, c, d, e, f, h) => (xi = g.dynCall_iijjjii = U.nh)(a, b, c, d, e, f, h), yi = g.dynCall_jij = (a, b, c) => (yi = g.dynCall_jij = U.oh)(a, b, c), zi = g.dynCall_iiji = (a, b, c, d) => (zi = g.dynCall_iiji = U.ph)(a, b, c, d), Ai = g.dynCall_iiif = (a, b, c, d) => (Ai = g.dynCall_iiif = U.qh)(a, b, c, d), Bi = g.dynCall_vidi = (a, b, c, d) => (Bi = g.dynCall_vidi = U.rh)(a, b, c, d), Ci = g.dynCall_vjiii = (a, b, c, d, e) => (Ci = g.dynCall_vjiii = U.sh)(a, b, c, d, e), Di = g.dynCall_diiii = (a, b, c, d, e) => (Di = g.dynCall_diiii = U.th)(a, b, c, d, e), Ei = g.dynCall_diiiii = (a, b, c, d, e, f) => (Ei = g.dynCall_diiiii = U.uh)(a, b, c, d, e, f), Fi = g.dynCall_viiijjiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q) => (Fi = g.dynCall_viiijjiiiiii = U.vh)(a, b, c, d, e, f, h, k, l, m, n, q), Gi = g.dynCall_viijjijjjjiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Gi = g.dynCall_viijjijjjjiii = U.wh)(a, b, c, d, e, f, h, k, l, m, n, q, r), Hi = g.dynCall_iiiij = (a, b, c, d, e) => (Hi = g.dynCall_iiiij = U.xh)(a, b, c, d, e), Ii = g.dynCall_viiijii = (a, b, c, d, e, f, h) => (Ii = g.dynCall_viiijii = U.yh)(a, b, c, d, e, f, h), Ji = g.dynCall_viijiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r) => (Ji = g.dynCall_viijiiiiiiiii = U.zh)(a, b, c, d, e, f, h, k, l, m, n, q, r), Ki = g.dynCall_fiiii = (a, b, c, d, e) => (Ki = g.dynCall_fiiii = U.Ah)(a, b, c, d, e), Li = g.dynCall_jfi = (a, b, c) => (Li = g.dynCall_jfi = U.Bh)(a, b, c), Mi = g.dynCall_viiiiiiiiiiiiii = (a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) => (Mi = g.dynCall_viiiiiiiiiiiiii = U.Ch)(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u), Ni = g.dynCall_jiij = (a, b, c, d) => (Ni = g.dynCall_jiij = U.Dh)(a, b, c, d), Mb = (a) => (Mb = U.Eh)(a), Bb = () => (Bb = U.Fh)(), Lb = (a) => (Lb = U.Gh)(a), Nb = () => (Nb = U.Hh)();\n          g.___start_em_js = 1275044;\n          g.___stop_em_js = 1275205;\n          function Dc(a, b, c, d) {\n            var e = Z();\n            try {\n              return Ff(a, b, c, d);\n            } catch (f) {\n              Y(e);\n              if (f !== f + 0)\n                throw f;\n              X(1, 0);\n            }\n          }\n          function Bc(a, b, c) {\n            var d = Z();\n            try {\n              return dynCall_iii(a, b, c);\n            } catch (e) {\n              Y(d);\n              if (e !== e + 0)\n                throw e;\n              X(1, 0);\n            }\n          }\n          function Jd(a, b, c) {\n            var d = Z();\n            try {\n              dynCall_vii(a, b, c);\n            } catch (e) {\n              Y(d);\n              if (e !== e + 0)\n                throw e;\n              X(1, 0);\n            }\n          }\n          function yc(a, b) {\n            var c = Z();\n            try {\n              return Gf(a, b);\n            } catch (d) {\n              Y(c);\n              if (d !== d + 0)\n                throw d;\n              X(1, 0);\n            }\n          }\n          function Fd(a, b) {\n            var c = Z();\n            try {\n              dynCall_vi(a, b);\n            } catch (d) {\n              Y(c);\n              if (d !== d + 0)\n                throw d;\n              X(1, 0);\n            }\n          }\n          function dd(a, b, c, d) {\n            var e = Z();\n            try {\n              return Jf(a, b, c, d);\n            } catch (f) {\n              Y(e);\n              if (f !== f + 0)\n                throw f;\n              X(1, 0);\n            }\n          }\n          function Dd(a) {\n            var b = Z();\n            try {\n              dynCall_v(a);\n            } catch (c) {\n              Y(b);\n              if (c !== c + 0)\n                throw c;\n              X(1, 0);\n            }\n          }\n          function Ic(a, b, c, d, e, f, h) {\n            var k = Z();\n            try {\n              return Hf(a, b, c, d, e, f, h);\n            } catch (l) {\n              Y(k);\n              if (l !== l + 0)\n                throw l;\n              X(1, 0);\n            }\n          }\n          function Hc(a, b, c, d, e, f) {\n            var h = Z();\n            try {\n              return If(a, b, c, d, e, f);\n            } catch (k) {\n              Y(h);\n              if (k !== k + 0)\n                throw k;\n              X(1, 0);\n            }\n          }\n          function Fc(a, b, c, d, e) {\n            var f = Z();\n            try {\n              return Kf(a, b, c, d, e);\n            } catch (h) {\n              Y(f);\n              if (h !== h + 0)\n                throw h;\n              X(1, 0);\n            }\n          }\n          function Qd(a, b, c, d) {\n            var e = Z();\n            try {\n              Lf(a, b, c, d);\n            } catch (f) {\n              Y(e);\n              if (f !== f + 0)\n                throw f;\n              X(1, 0);\n            }\n          }\n          function Td(a, b, c, d, e) {\n            var f = Z();\n            try {\n              Nf(a, b, c, d, e);\n            } catch (h) {\n              Y(f);\n              if (h !== h + 0)\n                throw h;\n              X(1, 0);\n            }\n          }\n          function Vd(a, b, c, d, e, f) {\n            var h = Z();\n            try {\n              Mf(a, b, c, d, e, f);\n            } catch (k) {\n              Y(h);\n              if (k !== k + 0)\n                throw k;\n              X(1, 0);\n            }\n          }\n          function Zd(a, b, c, d, e, f, h) {\n            var k = Z();\n            try {\n              Of(a, b, c, d, e, f, h);\n            } catch (l) {\n              Y(k);\n              if (l !== l + 0)\n                throw l;\n              X(1, 0);\n            }\n          }\n          function ke(a, b, c, d, e, f, h, k, l, m, n, q) {\n            var r = Z();\n            try {\n              Qf(a, b, c, d, e, f, h, k, l, m, n, q);\n            } catch (p) {\n              Y(r);\n              if (p !== p + 0)\n                throw p;\n              X(1, 0);\n            }\n          }\n          function zc(a, b, c) {\n            var d = Z();\n            try {\n              return Sf(a, b, c);\n            } catch (e) {\n              Y(d);\n              if (e !== e + 0)\n                throw e;\n              X(1, 0);\n            }\n          }\n          function Ac(a, b, c) {\n            var d = Z();\n            try {\n              return Tf(a, b, c);\n            } catch (e) {\n              Y(d);\n              if (e !== e + 0)\n                throw e;\n              X(1, 0);\n            }\n          }\n          function md(a, b, c) {\n            var d = Z();\n            try {\n              return Uf(a, b, c);\n            } catch (e) {\n              Y(d);\n              if (e !== e + 0)\n                throw e;\n              X(1, 0);\n            }\n          }\n          function yd(a, b, c) {\n            var d = Z();\n            try {\n              return Vf(a, b, c);\n            } catch (e) {\n              Y(d);\n              if (e !== e + 0)\n                throw e;\n              X(1, 0);\n              return 0n;\n            }\n          }\n          function ee(a, b, c, d, e, f, h, k, l) {\n            var m = Z();\n            try {\n              Xf(a, b, c, d, e, f, h, k, l);\n            } catch (n) {\n              Y(m);\n              if (n !== n + 0)\n                throw n;\n              X(1, 0);\n            }\n          }\n          function xc(a) {\n            var b = Z();\n            try {\n              return Wf(a);\n            } catch (c) {\n              Y(b);\n              if (c !== c + 0)\n                throw c;\n              X(1, 0);\n            }\n          }\n          function df(a, b, c) {\n            var d = Z();\n            try {\n              fg(a, b, c);\n            } catch (e) {\n              Y(d);\n              if (e !== e + 0)\n                throw e;\n              X(1, 0);\n            }\n          }\n          function We(a, b, c, d, e) {\n            var f = Z();\n            try {\n              Pf(a, b, c, d, e);\n            } catch (h) {\n              Y(f);\n              if (h !== h + 0)\n                throw h;\n              X(1, 0);\n            }\n          }\n          function Ce(a, b, c, d, e, f, h) {\n            var k = Z();\n            try {\n              Yf(a, b, c, d, e, f, h);\n            } catch (l) {\n              Y(k);\n              if (l !== l + 0)\n                throw l;\n              X(1, 0);\n            }\n          }\n          function cf(a, b, c, d, e, f, h, k, l, m, n, q) {\n            var r = Z();\n            try {\n              gg(a, b, c, d, e, f, h, k, l, m, n, q);\n            } catch (p) {\n              Y(r);\n              if (p !== p + 0)\n                throw p;\n              X(1, 0);\n            }\n          }\n          function Re(a, b, c, d, e, f, h, k, l, m, n, q) {\n            var r = Z();\n            try {\n              hg(a, b, c, d, e, f, h, k, l, m, n, q);\n            } catch (p) {\n              Y(r);\n              if (p !== p + 0)\n                throw p;\n              X(1, 0);\n            }\n          }\n          function Jc(a, b, c, d, e, f, h, k) {\n            var l = Z();\n            try {\n              return ig(a, b, c, d, e, f, h, k);\n            } catch (m) {\n              Y(l);\n              if (m !== m + 0)\n                throw m;\n              X(1, 0);\n            }\n          }\n          function de(a, b, c, d, e, f, h, k) {\n            var l = Z();\n            try {\n              jg(a, b, c, d, e, f, h, k);\n            } catch (m) {\n              Y(l);\n              if (m !== m + 0)\n                throw m;\n              X(1, 0);\n            }\n          }\n          function Nc(a, b, c, d, e, f, h, k, l, m, n, q) {\n            var r = Z();\n            try {\n              return ag(a, b, c, d, e, f, h, k, l, m, n, q);\n            } catch (p) {\n              Y(r);\n              if (p !== p + 0)\n                throw p;\n              X(1, 0);\n            }\n          }\n          function fe(a, b, c, d, e, f, h, k, l, m) {\n            var n = Z();\n            try {\n              bg(a, b, c, d, e, f, h, k, l, m);\n            } catch (q) {\n              Y(n);\n              if (q !== q + 0)\n                throw q;\n              X(1, 0);\n            }\n          }\n          function me(a, b, c, d, e, f, h, k, l, m, n, q, r, p) {\n            var u = Z();\n            try {\n              lg(a, b, c, d, e, f, h, k, l, m, n, q, r, p);\n            } catch (y) {\n              Y(u);\n              if (y !== y + 0)\n                throw y;\n              X(1, 0);\n            }\n          }\n          function Yc(a, b, c, d, e, f, h, k, l, m, n) {\n            var q = Z();\n            try {\n              return ng(a, b, c, d, e, f, h, k, l, m, n);\n            } catch (r) {\n              Y(q);\n              if (r !== r + 0)\n                throw r;\n              X(1, 0);\n            }\n          }\n          function Kc(a, b, c, d, e, f, h, k, l) {\n            var m = Z();\n            try {\n              return mg(a, b, c, d, e, f, h, k, l);\n            } catch (n) {\n              Y(m);\n              if (n !== n + 0)\n                throw n;\n              X(1, 0);\n            }\n          }\n          function nf(a, b, c, d, e, f, h, k, l) {\n            var m = Z();\n            try {\n              og(a, b, c, d, e, f, h, k, l);\n            } catch (n) {\n              Y(m);\n              if (n !== n + 0)\n                throw n;\n              X(1, 0);\n            }\n          }\n          function Ve(a, b, c, d) {\n            var e = Z();\n            try {\n              $f(a, b, c, d);\n            } catch (f) {\n              Y(e);\n              if (f !== f + 0)\n                throw f;\n              X(1, 0);\n            }\n          }\n          function tc(a, b) {\n            var c = Z();\n            try {\n              return pg(a, b);\n            } catch (d) {\n              Y(c);\n              if (d !== d + 0)\n                throw d;\n              X(1, 0);\n            }\n          }\n          function xd(a, b) {\n            var c = Z();\n            try {\n              return Zf(a, b);\n            } catch (d) {\n              Y(c);\n              if (d !== d + 0)\n                throw d;\n              X(1, 0);\n              return 0n;\n            }\n          }\n          function nc(a, b) {\n            var c = Z();\n            try {\n              return rg(a, b);\n            } catch (d) {\n              Y(c);\n              if (d !== d + 0)\n                throw d;\n              X(1, 0);\n            }\n          }\n          function jf(a, b, c, d) {\n            var e = Z();\n            try {\n              tg(a, b, c, d);\n            } catch (f) {\n              Y(e);\n              if (f !== f + 0)\n                throw f;\n              X(1, 0);\n            }\n          }\n          function Oe(a, b, c, d, e, f, h) {\n            var k = Z();\n            try {\n              Ii(a, b, c, d, e, f, h);\n            } catch (l) {\n              Y(k);\n              if (l !== l + 0)\n                throw l;\n              X(1, 0);\n            }\n          }\n          function Ze(a, b, c, d, e) {\n            var f = Z();\n            try {\n              zh(a, b, c, d, e);\n            } catch (h) {\n              Y(f);\n              if (h !== h + 0)\n                throw h;\n              X(1, 0);\n            }\n          }\n          function Lc(a, b, c, d, e, f, h, k, l, m) {\n            var n = Z();\n            try {\n              return ug(a, b, c, d, e, f, h, k, l, m);\n            } catch (q) {\n              Y(n);\n              if (q !== q + 0)\n                throw q;\n              X(1, 0);\n            }\n          }\n          function Xe(a, b, c, d, e, f, h) {\n            var k = Z();\n            try {\n              vg(a, b, c, d, e, f, h);\n            } catch (l) {\n              Y(k);\n              if (l !== l + 0)\n                throw l;\n              X(1, 0);\n            }\n          }\n          function Kd(a, b, c, d) {\n            var e = Z();\n            try {\n              wg(a, b, c, d);\n            } catch (f) {\n              Y(e);\n              if (f !== f + 0)\n                throw f;\n              X(1, 0);\n            }\n          }\n          function Tc(a, b, c, d, e, f, h, k, l) {\n            var m = Z();\n            try {\n              return kg(a, b, c, d, e, f, h, k, l);\n            } catch (n) {\n              Y(m);\n              if (n !== n + 0)\n                throw n;\n              X(1, 0);\n            }\n          }\n          function Id(a, b, c, d, e, f, h) {\n            var k = Z();\n            try {\n              xg(a, b, c, d, e, f, h);\n            } catch (l) {\n              Y(k);\n              if (l !== l + 0)\n                throw l;\n              X(1, 0);\n            }\n          }\n          function Ue(a, b, c, d, e, f, h, k, l) {\n            var m = Z();\n            try {\n              Rf(a, b, c, d, e, f, h, k, l);\n            } catch (n) {\n              Y(m);\n              if (n !== n + 0)\n                throw n;\n              X(1, 0);\n            }\n          }\n          function Pd(a, b, c, d, e, f, h) {\n            var k = Z();\n            try {\n              yg(a, b, c, d, e, f, h);\n            } catch (l) {\n              Y(k);\n              if (l !== l + 0)\n                throw l;\n              X(1, 0);\n            }\n          }\n          function Wd(a, b, c, d, e, f, h, k, l, m, n) {\n            var q = Z();\n            try {\n              zg(a, b, c, d, e, f, h, k, l, m, n);\n            } catch (r) {\n              Y(q);\n              if (r !== r + 0)\n                throw r;\n              X(1, 0);\n            }\n          }\n          function zd(a, b, c, d) {\n            var e = Z();\n            try {\n              return Bg(a, b, c, d);\n            } catch (f) {\n              Y(e);\n              if (f !== f + 0)\n                throw f;\n              X(1, 0);\n              return 0n;\n            }\n          }\n          function uf(a, b, c, d, e, f, h, k) {\n            var l = Z();\n            try {\n              Cg(a, b, c, d, e, f, h, k);\n            } catch (m) {\n              Y(l);\n              if (m !== m + 0)\n                throw m;\n              X(1, 0);\n            }\n          }\n          function Rd(a, b, c, d, e) {\n            var f = Z();\n            try {\n              Dg(a, b, c, d, e);\n            } catch (h) {\n              Y(f);\n              if (h !== h + 0)\n                throw h;\n              X(1, 0);\n            }\n          }\n          function ef(a, b, c, d) {\n            var e = Z();\n            try {\n              Fg(a, b, c, d);\n            } catch (f) {\n              Y(e);\n              if (f !== f + 0)\n                throw f;\n              X(1, 0);\n            }\n          }\n          function rf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) {\n            var A = Z();\n            try {\n              Gg(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y);\n            } catch (B) {\n              Y(A);\n              if (B !== B + 0)\n                throw B;\n              X(1, 0);\n            }\n          }\n          function Ne(a, b, c, d, e, f) {\n            var h = Z();\n            try {\n              Hg(a, b, c, d, e, f);\n            } catch (k) {\n              Y(h);\n              if (k !== k + 0)\n                throw k;\n              X(1, 0);\n            }\n          }\n          function of(a, b, c, d, e, f, h, k, l) {\n            var m = Z();\n            try {\n              Ig(a, b, c, d, e, f, h, k, l);\n            } catch (n) {\n              Y(m);\n              if (n !== n + 0)\n                throw n;\n              X(1, 0);\n            }\n          }\n          function ed(a, b, c, d, e) {\n            var f = Z();\n            try {\n              return Jg(a, b, c, d, e);\n            } catch (h) {\n              Y(f);\n              if (h !== h + 0)\n                throw h;\n              X(1, 0);\n            }\n          }\n          function kd(a, b, c, d, e, f, h, k, l, m, n, q, r, p) {\n            var u = Z();\n            try {\n              return Kg(a, b, c, d, e, f, h, k, l, m, n, q, r, p);\n            } catch (y) {\n              Y(u);\n              if (y !== y + 0)\n                throw y;\n              X(1, 0);\n            }\n          }\n          function sf(a, b) {\n            var c = Z();\n            try {\n              Lg(a, b);\n            } catch (d) {\n              Y(c);\n              if (d !== d + 0)\n                throw d;\n              X(1, 0);\n            }\n          }\n          function Cd(a, b, c) {\n            var d = Z();\n            try {\n              return Mg(a, b, c);\n            } catch (e) {\n              Y(d);\n              if (e !== e + 0)\n                throw e;\n              X(1, 0);\n              return 0n;\n            }\n          }\n          function jd(a, b, c, d, e, f, h, k, l, m) {\n            var n = Z();\n            try {\n              return Ng(a, b, c, d, e, f, h, k, l, m);\n            } catch (q) {\n              Y(n);\n              if (q !== q + 0)\n                throw q;\n              X(1, 0);\n            }\n          }\n          function ie(a, b, c, d, e, f, h, k, l, m, n, q, r, p) {\n            var u = Z();\n            try {\n              Sg(a, b, c, d, e, f, h, k, l, m, n, q, r, p);\n            } catch (y) {\n              Y(u);\n              if (y !== y + 0)\n                throw y;\n              X(1, 0);\n            }\n          }\n          function Ed(a, b, c, d, e) {\n            var f = Z();\n            try {\n              Og(a, b, c, d, e);\n            } catch (h) {\n              Y(f);\n              if (h !== h + 0)\n                throw h;\n              X(1, 0);\n            }\n          }\n          function Ud(a, b, c, d, e, f, h) {\n            var k = Z();\n            try {\n              Pg(a, b, c, d, e, f, h);\n            } catch (l) {\n              Y(k);\n              if (l !== l + 0)\n                throw l;\n              X(1, 0);\n            }\n          }\n          function Md(a, b, c, d, e) {\n            var f = Z();\n            try {\n              Rg(a, b, c, d, e);\n            } catch (h) {\n              Y(f);\n              if (h !== h + 0)\n                throw h;\n              X(1, 0);\n            }\n          }\n          function Xd(a, b, c, d, e, f, h, k) {\n            var l = Z();\n            try {\n              Qg(a, b, c, d, e, f, h, k);\n            } catch (m) {\n              Y(l);\n              if (m !== m + 0)\n                throw m;\n              X(1, 0);\n            }\n          }\n          function ue(a, b, c, d, e, f, h, k, l, m, n) {\n            var q = Z();\n            try {\n              Tg(a, b, c, d, e, f, h, k, l, m, n);\n            } catch (r) {\n              Y(q);\n              if (r !== r + 0)\n                throw r;\n              X(1, 0);\n            }\n          }\n          function Oc(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) {\n            var B = Z();\n            try {\n              return Ug(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A);\n            } catch (C) {\n              Y(B);\n              if (C !== C + 0)\n                throw C;\n              X(1, 0);\n            }\n          }\n          function le(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n            var p = Z();\n            try {\n              Vg(a, b, c, d, e, f, h, k, l, m, n, q, r);\n            } catch (u) {\n              Y(p);\n              if (u !== u + 0)\n                throw u;\n              X(1, 0);\n            }\n          }\n          function sd(a, b) {\n            var c = Z();\n            try {\n              return cg(a, b);\n            } catch (d) {\n              Y(c);\n              if (d !== d + 0)\n                throw d;\n              X(1, 0);\n            }\n          }\n          function wc(a, b, c, d, e) {\n            var f = Z();\n            try {\n              return Ki(a, b, c, d, e);\n            } catch (h) {\n              Y(f);\n              if (h !== h + 0)\n                throw h;\n              X(1, 0);\n            }\n          }\n          function Pc(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) {\n            var F = Z();\n            try {\n              return Wg(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D);\n            } catch (H) {\n              Y(F);\n              if (H !== H + 0)\n                throw H;\n              X(1, 0);\n            }\n          }\n          function mf(a, b, c, d, e, f, h, k, l, m) {\n            var n = Z();\n            try {\n              Xg(a, b, c, d, e, f, h, k, l, m);\n            } catch (q) {\n              Y(n);\n              if (q !== q + 0)\n                throw q;\n              X(1, 0);\n            }\n          }\n          function cd(a, b, c, d, e, f, h) {\n            var k = Z();\n            try {\n              return Yg(a, b, c, d, e, f, h);\n            } catch (l) {\n              Y(k);\n              if (l !== l + 0)\n                throw l;\n              X(1, 0);\n            }\n          }\n          function je(a, b, c, d, e, f, h, k, l, m, n) {\n            var q = Z();\n            try {\n              Zg(a, b, c, d, e, f, h, k, l, m, n);\n            } catch (r) {\n              Y(q);\n              if (r !== r + 0)\n                throw r;\n              X(1, 0);\n            }\n          }\n          function ld(a, b, c, d, e, f) {\n            var h = Z();\n            try {\n              return $g(a, b, c, d, e, f);\n            } catch (k) {\n              Y(h);\n              if (k !== k + 0)\n                throw k;\n              X(1, 0);\n            }\n          }\n          function Ie(a, b, c, d, e, f) {\n            var h = Z();\n            try {\n              bh(a, b, c, d, e, f);\n            } catch (k) {\n              Y(h);\n              if (k !== k + 0)\n                throw k;\n              X(1, 0);\n            }\n          }\n          function ye(a, b, c, d, e, f, h, k, l, m, n, q, r, p) {\n            var u = Z();\n            try {\n              ch(a, b, c, d, e, f, h, k, l, m, n, q, r, p);\n            } catch (y) {\n              Y(u);\n              if (y !== y + 0)\n                throw y;\n              X(1, 0);\n            }\n          }\n          function zf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B) {\n            var C = Z();\n            try {\n              dh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B);\n            } catch (D) {\n              Y(C);\n              if (D !== D + 0)\n                throw D;\n              X(1, 0);\n            }\n          }\n          function ae(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) {\n            var B = Z();\n            try {\n              eh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A);\n            } catch (C) {\n              Y(B);\n              if (C !== C + 0)\n                throw C;\n              X(1, 0);\n            }\n          }\n          function $d(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) {\n            var A = Z();\n            try {\n              fh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y);\n            } catch (B) {\n              Y(A);\n              if (B !== B + 0)\n                throw B;\n              X(1, 0);\n            }\n          }\n          function be(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) {\n            var y = Z();\n            try {\n              gh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u);\n            } catch (A) {\n              Y(y);\n              if (A !== A + 0)\n                throw A;\n              X(1, 0);\n            }\n          }\n          function Af(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) {\n            var H = Z();\n            try {\n              hh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F);\n            } catch (K) {\n              Y(H);\n              if (K !== K + 0)\n                throw K;\n              X(1, 0);\n            }\n          }\n          function yf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C) {\n            var D = Z();\n            try {\n              ih(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C);\n            } catch (F) {\n              Y(D);\n              if (F !== F + 0)\n                throw F;\n              X(1, 0);\n            }\n          }\n          function xf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B) {\n            var C = Z();\n            try {\n              jh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B);\n            } catch (D) {\n              Y(C);\n              if (D !== D + 0)\n                throw D;\n              X(1, 0);\n            }\n          }\n          function Bf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) {\n            var H = Z();\n            try {\n              kh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F);\n            } catch (K) {\n              Y(H);\n              if (K !== K + 0)\n                throw K;\n              X(1, 0);\n            }\n          }\n          function gf(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n            var p = Z();\n            try {\n              lh(a, b, c, d, e, f, h, k, l, m, n, q, r);\n            } catch (u) {\n              Y(p);\n              if (u !== u + 0)\n                throw u;\n              X(1, 0);\n            }\n          }\n          function kf(a, b, c, d, e, f, h, k, l, m) {\n            var n = Z();\n            try {\n              mh(a, b, c, d, e, f, h, k, l, m);\n            } catch (q) {\n              Y(n);\n              if (q !== q + 0)\n                throw q;\n              X(1, 0);\n            }\n          }\n          function ve(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n            var p = Z();\n            try {\n              nh(a, b, c, d, e, f, h, k, l, m, n, q, r);\n            } catch (u) {\n              Y(p);\n              if (u !== u + 0)\n                throw u;\n              X(1, 0);\n            }\n          }\n          function qf(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) {\n            var y = Z();\n            try {\n              oh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u);\n            } catch (A) {\n              Y(y);\n              if (A !== A + 0)\n                throw A;\n              X(1, 0);\n            }\n          }\n          function wf(a, b, c, d, e, f, h, k, l, m) {\n            var n = Z();\n            try {\n              qh(a, b, c, d, e, f, h, k, l, m);\n            } catch (q) {\n              Y(n);\n              if (q !== q + 0)\n                throw q;\n              X(1, 0);\n            }\n          }\n          function vf(a, b, c, d, e, f, h, k, l) {\n            var m = Z();\n            try {\n              rh(a, b, c, d, e, f, h, k, l);\n            } catch (n) {\n              Y(m);\n              if (n !== n + 0)\n                throw n;\n              X(1, 0);\n            }\n          }\n          function sc(a, b, c, d, e, f, h) {\n            var k = Z();\n            try {\n              return ah(a, b, c, d, e, f, h);\n            } catch (l) {\n              Y(k);\n              if (l !== l + 0)\n                throw l;\n              X(1, 0);\n            }\n          }\n          function Nd(a, b, c, d, e) {\n            var f = Z();\n            try {\n              ph(a, b, c, d, e);\n            } catch (h) {\n              Y(f);\n              if (h !== h + 0)\n                throw h;\n              X(1, 0);\n            }\n          }\n          function wd(a, b, c) {\n            var d = Z();\n            try {\n              return Li(a, b, c);\n            } catch (e) {\n              Y(d);\n              if (e !== e + 0)\n                throw e;\n              X(1, 0);\n              return 0n;\n            }\n          }\n          function ze(a, b, c, d, e, f, h, k, l, m, n, q, r, p) {\n            var u = Z();\n            try {\n              sh(a, b, c, d, e, f, h, k, l, m, n, q, r, p);\n            } catch (y) {\n              Y(u);\n              if (y !== y + 0)\n                throw y;\n              X(1, 0);\n            }\n          }\n          function Ge(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n            var p = Z();\n            try {\n              uh(a, b, c, d, e, f, h, k, l, m, n, q, r);\n            } catch (u) {\n              Y(p);\n              if (u !== u + 0)\n                throw u;\n              X(1, 0);\n            }\n          }\n          function Xc(a, b, c, d, e, f, h) {\n            var k = Z();\n            try {\n              return vh(a, b, c, d, e, f, h);\n            } catch (l) {\n              Y(k);\n              if (l !== l + 0)\n                throw l;\n              X(1, 0);\n            }\n          }\n          function ad(a, b, c, d, e, f) {\n            var h = Z();\n            try {\n              return wh(a, b, c, d, e, f);\n            } catch (k) {\n              Y(h);\n              if (k !== k + 0)\n                throw k;\n              X(1, 0);\n            }\n          }\n          function De(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n            var p = Z();\n            try {\n              xh(a, b, c, d, e, f, h, k, l, m, n, q, r);\n            } catch (u) {\n              Y(p);\n              if (u !== u + 0)\n                throw u;\n              X(1, 0);\n            }\n          }\n          function lf(a, b, c, d, e, f) {\n            var h = Z();\n            try {\n              th(a, b, c, d, e, f);\n            } catch (k) {\n              Y(h);\n              if (k !== k + 0)\n                throw k;\n              X(1, 0);\n            }\n          }\n          function Qe(a, b, c, d, e, f, h, k, l, m, n) {\n            var q = Z();\n            try {\n              yh(a, b, c, d, e, f, h, k, l, m, n);\n            } catch (r) {\n              Y(q);\n              if (r !== r + 0)\n                throw r;\n              X(1, 0);\n            }\n          }\n          function Ke(a, b, c, d, e, f, h, k) {\n            var l = Z();\n            try {\n              Ah(a, b, c, d, e, f, h, k);\n            } catch (m) {\n              Y(l);\n              if (m !== m + 0)\n                throw m;\n              X(1, 0);\n            }\n          }\n          function af(a, b, c, d, e, f, h, k) {\n            var l = Z();\n            try {\n              Bh(a, b, c, d, e, f, h, k);\n            } catch (m) {\n              Y(l);\n              if (m !== m + 0)\n                throw m;\n              X(1, 0);\n            }\n          }\n          function td(a, b, c, d) {\n            var e = Z();\n            try {\n              return Ch(a, b, c, d);\n            } catch (f) {\n              Y(e);\n              if (f !== f + 0)\n                throw f;\n              X(1, 0);\n            }\n          }\n          function He(a, b, c, d, e, f, h, k, l, m) {\n            var n = Z();\n            try {\n              Dh(a, b, c, d, e, f, h, k, l, m);\n            } catch (q) {\n              Y(n);\n              if (q !== q + 0)\n                throw q;\n              X(1, 0);\n            }\n          }\n          function pf(a, b, c, d, e, f, h, k, l) {\n            var m = Z();\n            try {\n              Eh(a, b, c, d, e, f, h, k, l);\n            } catch (n) {\n              Y(m);\n              if (n !== n + 0)\n                throw n;\n              X(1, 0);\n            }\n          }\n          function Fe(a, b, c, d, e, f, h, k, l) {\n            var m = Z();\n            try {\n              Fh(a, b, c, d, e, f, h, k, l);\n            } catch (n) {\n              Y(m);\n              if (n !== n + 0)\n                throw n;\n              X(1, 0);\n            }\n          }\n          function Ae(a, b, c, d, e, f, h, k, l, m) {\n            var n = Z();\n            try {\n              Gh(a, b, c, d, e, f, h, k, l, m);\n            } catch (q) {\n              Y(n);\n              if (q !== q + 0)\n                throw q;\n              X(1, 0);\n            }\n          }\n          function ff(a, b, c, d, e, f) {\n            var h = Z();\n            try {\n              Hh(a, b, c, d, e, f);\n            } catch (k) {\n              Y(h);\n              if (k !== k + 0)\n                throw k;\n              X(1, 0);\n            }\n          }\n          function he(a, b, c, d, e, f, h, k, l, m, n, q) {\n            var r = Z();\n            try {\n              Ih(a, b, c, d, e, f, h, k, l, m, n, q);\n            } catch (p) {\n              Y(r);\n              if (p !== p + 0)\n                throw p;\n              X(1, 0);\n            }\n          }\n          function hd(a, b, c, d, e, f, h, k) {\n            var l = Z();\n            try {\n              return Jh(a, b, c, d, e, f, h, k);\n            } catch (m) {\n              Y(l);\n              if (m !== m + 0)\n                throw m;\n              X(1, 0);\n            }\n          }\n          function ne(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) {\n            var y = Z();\n            try {\n              Mi(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u);\n            } catch (A) {\n              Y(y);\n              if (A !== A + 0)\n                throw A;\n              X(1, 0);\n            }\n          }\n          function Be(a, b, c, d, e, f, h, k, l, m, n, q, r, p) {\n            var u = Z();\n            try {\n              Kh(a, b, c, d, e, f, h, k, l, m, n, q, r, p);\n            } catch (y) {\n              Y(u);\n              if (y !== y + 0)\n                throw y;\n              X(1, 0);\n            }\n          }\n          function we(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u) {\n            var y = Z();\n            try {\n              Lh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u);\n            } catch (A) {\n              Y(y);\n              if (A !== A + 0)\n                throw A;\n              X(1, 0);\n            }\n          }\n          function Hd(a, b, c) {\n            var d = Z();\n            try {\n              Mh(a, b, c);\n            } catch (e) {\n              Y(d);\n              if (e !== e + 0)\n                throw e;\n              X(1, 0);\n            }\n          }\n          function vc(a, b, c, d) {\n            var e = Z();\n            try {\n              return Oh(a, b, c, d);\n            } catch (f) {\n              Y(e);\n              if (f !== f + 0)\n                throw f;\n              X(1, 0);\n            }\n          }\n          function pc(a, b, c, d) {\n            var e = Z();\n            try {\n              return Ph(a, b, c, d);\n            } catch (f) {\n              Y(e);\n              if (f !== f + 0)\n                throw f;\n              X(1, 0);\n            }\n          }\n          function ce(a, b, c, d, e, f, h, k, l, m) {\n            var n = Z();\n            try {\n              Qh(a, b, c, d, e, f, h, k, l, m);\n            } catch (q) {\n              Y(n);\n              if (q !== q + 0)\n                throw q;\n              X(1, 0);\n            }\n          }\n          function Ee(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F, H, K, Va, Wa, Xa) {\n            var Qi = Z();\n            try {\n              Rh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F, H, K, Va, Wa, Xa);\n            } catch (Ya) {\n              Y(Qi);\n              if (Ya !== Ya + 0)\n                throw Ya;\n              X(1, 0);\n            }\n          }\n          function $e(a, b, c, d, e, f) {\n            var h = Z();\n            try {\n              Sh(a, b, c, d, e, f);\n            } catch (k) {\n              Y(h);\n              if (k !== k + 0)\n                throw k;\n              X(1, 0);\n            }\n          }\n          function Rc(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n            var p = Z();\n            try {\n              return Th(a, b, c, d, e, f, h, k, l, m, n, q, r);\n            } catch (u) {\n              Y(p);\n              if (u !== u + 0)\n                throw u;\n              X(1, 0);\n            }\n          }\n          function Od(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n            var p = Z();\n            try {\n              Uh(a, b, c, d, e, f, h, k, l, m, n, q, r);\n            } catch (u) {\n              Y(p);\n              if (u !== u + 0)\n                throw u;\n              X(1, 0);\n            }\n          }\n          function se(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F) {\n            var H = Z();\n            try {\n              Vh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D, F);\n            } catch (K) {\n              Y(H);\n              if (K !== K + 0)\n                throw K;\n              X(1, 0);\n            }\n          }\n          function Yd(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n            var p = Z();\n            try {\n              Wh(a, b, c, d, e, f, h, k, l, m, n, q, r);\n            } catch (u) {\n              Y(p);\n              if (u !== u + 0)\n                throw u;\n              X(1, 0);\n            }\n          }\n          function hf(a, b, c, d, e, f, h, k, l, m, n, q, r, p) {\n            var u = Z();\n            try {\n              Xh(a, b, c, d, e, f, h, k, l, m, n, q, r, p);\n            } catch (y) {\n              Y(u);\n              if (y !== y + 0)\n                throw y;\n              X(1, 0);\n            }\n          }\n          function re(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) {\n            var F = Z();\n            try {\n              Zh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D);\n            } catch (H) {\n              Y(F);\n              if (H !== H + 0)\n                throw H;\n              X(1, 0);\n            }\n          }\n          function pe(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A) {\n            var B = Z();\n            try {\n              ai(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A);\n            } catch (C) {\n              Y(B);\n              if (C !== C + 0)\n                throw C;\n              X(1, 0);\n            }\n          }\n          function qe(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C) {\n            var D = Z();\n            try {\n              Yh(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C);\n            } catch (F) {\n              Y(D);\n              if (F !== F + 0)\n                throw F;\n              X(1, 0);\n            }\n          }\n          function Le(a, b, c, d, e, f, h, k) {\n            var l = Z();\n            try {\n              bi(a, b, c, d, e, f, h, k);\n            } catch (m) {\n              Y(l);\n              if (m !== m + 0)\n                throw m;\n              X(1, 0);\n            }\n          }\n          function xe(a, b, c, d, e, f, h, k, l, m, n) {\n            var q = Z();\n            try {\n              di(a, b, c, d, e, f, h, k, l, m, n);\n            } catch (r) {\n              Y(q);\n              if (r !== r + 0)\n                throw r;\n              X(1, 0);\n            }\n          }\n          function Mc(a, b, c, d, e, f, h, k, l, m, n) {\n            var q = Z();\n            try {\n              return ei(a, b, c, d, e, f, h, k, l, m, n);\n            } catch (r) {\n              Y(q);\n              if (r !== r + 0)\n                throw r;\n              X(1, 0);\n            }\n          }\n          function Qc(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D) {\n            var F = Z();\n            try {\n              return fi(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y, A, B, C, D);\n            } catch (H) {\n              Y(F);\n              if (H !== H + 0)\n                throw H;\n              X(1, 0);\n            }\n          }\n          function Sd(a, b, c, d, e) {\n            var f = Z();\n            try {\n              gi(a, b, c, d, e);\n            } catch (h) {\n              Y(f);\n              if (h !== h + 0)\n                throw h;\n              X(1, 0);\n            }\n          }\n          function ge(a, b, c, d, e, f, h, k, l, m, n, q) {\n            var r = Z();\n            try {\n              Ag(a, b, c, d, e, f, h, k, l, m, n, q);\n            } catch (p) {\n              Y(r);\n              if (p !== p + 0)\n                throw p;\n              X(1, 0);\n            }\n          }\n          function Pe(a, b, c, d, e, f, h, k, l, m) {\n            var n = Z();\n            try {\n              hi(a, b, c, d, e, f, h, k, l, m);\n            } catch (q) {\n              Y(n);\n              if (q !== q + 0)\n                throw q;\n              X(1, 0);\n            }\n          }\n          function Me(a, b, c, d, e) {\n            var f = Z();\n            try {\n              ii(a, b, c, d, e);\n            } catch (h) {\n              Y(f);\n              if (h !== h + 0)\n                throw h;\n              X(1, 0);\n            }\n          }\n          function Ye(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n            var p = Z();\n            try {\n              Ji(a, b, c, d, e, f, h, k, l, m, n, q, r);\n            } catch (u) {\n              Y(p);\n              if (u !== u + 0)\n                throw u;\n              X(1, 0);\n            }\n          }\n          function pd(a, b, c, d, e) {\n            var f = Z();\n            try {\n              return ji(a, b, c, d, e);\n            } catch (h) {\n              Y(f);\n              if (h !== h + 0)\n                throw h;\n              X(1, 0);\n            }\n          }\n          function Ad(a, b, c, d) {\n            var e = Z();\n            try {\n              return Ni(a, b, c, d);\n            } catch (f) {\n              Y(e);\n              if (f !== f + 0)\n                throw f;\n              X(1, 0);\n              return 0n;\n            }\n          }\n          function Je(a, b, c, d, e, f, h) {\n            var k = Z();\n            try {\n              ki(a, b, c, d, e, f, h);\n            } catch (l) {\n              Y(k);\n              if (l !== l + 0)\n                throw l;\n              X(1, 0);\n            }\n          }\n          function qd(a, b, c, d, e, f) {\n            var h = Z();\n            try {\n              return li(a, b, c, d, e, f);\n            } catch (k) {\n              Y(h);\n              if (k !== k + 0)\n                throw k;\n              X(1, 0);\n            }\n          }\n          function ud(a, b, c, d, e, f) {\n            var h = Z();\n            try {\n              return mi(a, b, c, d, e, f);\n            } catch (k) {\n              Y(h);\n              if (k !== k + 0)\n                throw k;\n              X(1, 0);\n            }\n          }\n          function Se(a, b, c, d, e, f, h, k, l) {\n            var m = Z();\n            try {\n              ni(a, b, c, d, e, f, h, k, l);\n            } catch (n) {\n              Y(m);\n              if (n !== n + 0)\n                throw n;\n              X(1, 0);\n            }\n          }\n          function Ld(a, b, c, d) {\n            var e = Z();\n            try {\n              Nh(a, b, c, d);\n            } catch (f) {\n              Y(e);\n              if (f !== f + 0)\n                throw f;\n              X(1, 0);\n            }\n          }\n          function Zc(a, b, c, d, e, f, h, k) {\n            var l = Z();\n            try {\n              return oi(a, b, c, d, e, f, h, k);\n            } catch (m) {\n              Y(l);\n              if (m !== m + 0)\n                throw m;\n              X(1, 0);\n            }\n          }\n          function Ec(a, b, c, d, e, f) {\n            var h = Z();\n            try {\n              return pi(a, b, c, d, e, f);\n            } catch (k) {\n              Y(h);\n              if (k !== k + 0)\n                throw k;\n              X(1, 0);\n            }\n          }\n          function fd(a, b, c, d, e, f) {\n            var h = Z();\n            try {\n              return qi(a, b, c, d, e, f);\n            } catch (k) {\n              Y(h);\n              if (k !== k + 0)\n                throw k;\n              X(1, 0);\n            }\n          }\n          function Sc(a, b, c, d, e, f, h, k, l, m, n, q) {\n            var r = Z();\n            try {\n              return ri(a, b, c, d, e, f, h, k, l, m, n, q);\n            } catch (p) {\n              Y(r);\n              if (p !== p + 0)\n                throw p;\n              X(1, 0);\n            }\n          }\n          function bd(a, b, c, d, e, f, h, k) {\n            var l = Z();\n            try {\n              return si(a, b, c, d, e, f, h, k);\n            } catch (m) {\n              Y(l);\n              if (m !== m + 0)\n                throw m;\n              X(1, 0);\n            }\n          }\n          function Vc(a, b, c, d, e, f, h, k, l, m, n) {\n            var q = Z();\n            try {\n              return ti(a, b, c, d, e, f, h, k, l, m, n);\n            } catch (r) {\n              Y(q);\n              if (r !== r + 0)\n                throw r;\n              X(1, 0);\n            }\n          }\n          function gd(a, b, c, d, e, f, h) {\n            var k = Z();\n            try {\n              return ui(a, b, c, d, e, f, h);\n            } catch (l) {\n              Y(k);\n              if (l !== l + 0)\n                throw l;\n              X(1, 0);\n            }\n          }\n          function Uc(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n            var p = Z();\n            try {\n              return vi(a, b, c, d, e, f, h, k, l, m, n, q, r);\n            } catch (u) {\n              Y(p);\n              if (u !== u + 0)\n                throw u;\n              X(1, 0);\n            }\n          }\n          function od(a, b, c, d, e, f, h) {\n            var k = Z();\n            try {\n              return wi(a, b, c, d, e, f, h);\n            } catch (l) {\n              Y(k);\n              if (l !== l + 0)\n                throw l;\n              X(1, 0);\n            }\n          }\n          function rd(a, b, c, d, e, f, h) {\n            var k = Z();\n            try {\n              return xi(a, b, c, d, e, f, h);\n            } catch (l) {\n              Y(k);\n              if (l !== l + 0)\n                throw l;\n              X(1, 0);\n            }\n          }\n          function Bd(a, b, c) {\n            var d = Z();\n            try {\n              return yi(a, b, c);\n            } catch (e) {\n              Y(d);\n              if (e !== e + 0)\n                throw e;\n              X(1, 0);\n              return 0n;\n            }\n          }\n          function nd(a, b, c, d) {\n            var e = Z();\n            try {\n              return zi(a, b, c, d);\n            } catch (f) {\n              Y(e);\n              if (f !== f + 0)\n                throw f;\n              X(1, 0);\n            }\n          }\n          function Gd(a, b, c, d) {\n            var e = Z();\n            try {\n              Bi(a, b, c, d);\n            } catch (f) {\n              Y(e);\n              if (f !== f + 0)\n                throw f;\n              X(1, 0);\n            }\n          }\n          function Cc(a, b, c, d) {\n            var e = Z();\n            try {\n              return Ai(a, b, c, d);\n            } catch (f) {\n              Y(e);\n              if (f !== f + 0)\n                throw f;\n              X(1, 0);\n            }\n          }\n          function tf(a, b, c, d, e) {\n            var f = Z();\n            try {\n              Ci(a, b, c, d, e);\n            } catch (h) {\n              Y(f);\n              if (h !== h + 0)\n                throw h;\n              X(1, 0);\n            }\n          }\n          function qc(a, b, c, d, e) {\n            var f = Z();\n            try {\n              return Di(a, b, c, d, e);\n            } catch (h) {\n              Y(f);\n              if (h !== h + 0)\n                throw h;\n              X(1, 0);\n            }\n          }\n          function rc(a, b, c, d, e, f) {\n            var h = Z();\n            try {\n              return Ei(a, b, c, d, e, f);\n            } catch (k) {\n              Y(h);\n              if (k !== k + 0)\n                throw k;\n              X(1, 0);\n            }\n          }\n          function Te(a, b, c, d, e, f, h, k, l, m, n, q) {\n            var r = Z();\n            try {\n              Fi(a, b, c, d, e, f, h, k, l, m, n, q);\n            } catch (p) {\n              Y(r);\n              if (p !== p + 0)\n                throw p;\n              X(1, 0);\n            }\n          }\n          function bf(a, b, c, d, e, f, h, k, l, m, n, q, r) {\n            var p = Z();\n            try {\n              Gi(a, b, c, d, e, f, h, k, l, m, n, q, r);\n            } catch (u) {\n              Y(p);\n              if (u !== u + 0)\n                throw u;\n              X(1, 0);\n            }\n          }\n          function te(a, b, c, d, e, f, h, k, l, m, n, q) {\n            var r = Z();\n            try {\n              Eg(a, b, c, d, e, f, h, k, l, m, n, q);\n            } catch (p) {\n              Y(r);\n              if (p !== p + 0)\n                throw p;\n              X(1, 0);\n            }\n          }\n          function $c(a, b, c, d, e) {\n            var f = Z();\n            try {\n              return Hi(a, b, c, d, e);\n            } catch (h) {\n              Y(f);\n              if (h !== h + 0)\n                throw h;\n              X(1, 0);\n            }\n          }\n          function vd(a) {\n            var b = Z();\n            try {\n              return eg(a);\n            } catch (c) {\n              Y(b);\n              if (c !== c + 0)\n                throw c;\n              X(1, 0);\n              return 0n;\n            }\n          }\n          function Wc(a, b, c, d, e, f) {\n            var h = Z();\n            try {\n              return dg(a, b, c, d, e, f);\n            } catch (k) {\n              Y(h);\n              if (k !== k + 0)\n                throw k;\n              X(1, 0);\n            }\n          }\n          function Gc(a, b, c, d, e, f) {\n            var h = Z();\n            try {\n              return ci(a, b, c, d, e, f);\n            } catch (k) {\n              Y(h);\n              if (k !== k + 0)\n                throw k;\n              X(1, 0);\n            }\n          }\n          function oe(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y) {\n            var A = Z();\n            try {\n              $h(a, b, c, d, e, f, h, k, l, m, n, q, r, p, u, y);\n            } catch (B) {\n              Y(A);\n              if (B !== B + 0)\n                throw B;\n              X(1, 0);\n            }\n          }\n          function uc(a, b, c) {\n            var d = Z();\n            try {\n              return qg(a, b, c);\n            } catch (e) {\n              Y(d);\n              if (e !== e + 0)\n                throw e;\n              X(1, 0);\n            }\n          }\n          function oc(a, b, c) {\n            var d = Z();\n            try {\n              return sg(a, b, c);\n            } catch (e) {\n              Y(d);\n              if (e !== e + 0)\n                throw e;\n              X(1, 0);\n            }\n          }\n          function Df() {\n            var a = U;\n            a = Object.assign({}, a);\n            var b = (c) => (d) => c(d) >>> 0;\n            a.Fd = b(a.Fd);\n            a.he = b(a.he);\n            a.ne = b(a.ne);\n            a.oe = ((c) => () => c() >>> 0)(a.oe);\n            return a;\n          }\n          g.stackSave = () => Z();\n          g.stackRestore = (a) => Y(a);\n          g.stackAlloc = (a) => Ef(a);\n          g.UTF8ToString = J;\n          g.stringToUTF8 = (a, b, c) => M(a, E, b, c);\n          g.lengthBytesUTF8 = bb;\n          var Oi;\n          Fa = function Pi() {\n            Oi || Ri();\n            Oi || (Fa = Pi);\n          };\n          function Ri() {\n            if (!(0 < Da)) {\n              if (g.preRun)\n                for (\"function\" == typeof g.preRun && (g.preRun = [g.preRun]); g.preRun.length; ) {\n                  var a = g.preRun.shift();\n                  Aa.unshift(a);\n                }\n              for (; 0 < Aa.length; )\n                Aa.shift()(g);\n              if (!(0 < Da || Oi || (Oi = true, g.calledRun = true, x))) {\n                for (; 0 < Ba.length; )\n                  Ba.shift()(g);\n                for (aa(g); 0 < Ca.length; )\n                  Ca.shift()(g);\n              }\n            }\n          }\n          Ri();\n          return readyPromise;\n        };\n      })();\n      if (typeof exports === \"object\" && typeof module === \"object\")\n        module.exports = ortWasm;\n      else if (typeof define === \"function\" && define[\"amd\"])\n        define([], () => ortWasm);\n    }\n  });\n\n  // nodejs-ignore:worker_threads\n  var require_worker_threads = __commonJS({\n    \"nodejs-ignore:worker_threads\"() {\n    }\n  });\n\n  // nodejs-ignore:perf_hooks\n  var require_perf_hooks = __commonJS({\n    \"nodejs-ignore:perf_hooks\"() {\n    }\n  });\n\n  // nodejs-ignore:os\n  var os_exports = {};\n  __export(os_exports, {\n    cpus: () => cpus\n  });\n  var cpus;\n  var init_os = __esm({\n    \"nodejs-ignore:os\"() {\n      cpus = void 0;\n    }\n  });\n\n  // web/lib/wasm/binding/ort-wasm-simd-threaded.jsep.js\n  var require_ort_wasm_simd_threaded_jsep = __commonJS({\n    \"web/lib/wasm/binding/ort-wasm-simd-threaded.jsep.js\"(exports, module) {\n      \"use strict\";\n      var ortWasmThreaded = (() => {\n        var _scriptDir = typeof document !== \"undefined\" && document.currentScript ? document.currentScript.src : void 0;\n        if (typeof __filename !== \"undefined\")\n          _scriptDir = _scriptDir || __filename;\n        return function(moduleArg = {}) {\n          function d() {\n            l.buffer != p.buffer && t();\n            return p;\n          }\n          function v() {\n            l.buffer != p.buffer && t();\n            return aa;\n          }\n          function z() {\n            l.buffer != p.buffer && t();\n            return ba;\n          }\n          function A() {\n            l.buffer != p.buffer && t();\n            return ca;\n          }\n          function da() {\n            l.buffer != p.buffer && t();\n            return ea;\n          }\n          var B = moduleArg, fa, C;\n          B.ready = new Promise((a, b) => {\n            fa = a;\n            C = b;\n          });\n          \"use strict\";\n          B.jsepInit = (a, b, c, e, f, h, k, q) => {\n            B.Qb = a;\n            B.wb = b;\n            B.yb = c;\n            B.jb = e;\n            B.xb = f;\n            B.Ea = h;\n            B.zb = k;\n            B.Ab = q;\n            b = (n, m, r) => (...w) => {\n              const x = D, g = m?.();\n              w = n(...w);\n              const u = m?.();\n              g !== u && (n = u, r(g), m = r = null);\n              return D != x ? ha() : w;\n            };\n            c = (n) => async (...m) => {\n              try {\n                if (B.bb)\n                  throw Error(\"Session already started\");\n                const r = B.bb = { Fb: m[0], errors: [] }, w = await n(...m);\n                if (B.bb !== r)\n                  throw Error(\"Session mismatch\");\n                a.flush();\n                const x = r.errors;\n                if (0 < x.length) {\n                  let g = await Promise.all(x);\n                  g = g.filter((u) => u);\n                  if (0 < g.length)\n                    throw Error(g.join(\"\\n\"));\n                }\n                return w;\n              } finally {\n                B.bb = null;\n              }\n            };\n            B._OrtRun = c(b(B._OrtRun, () => B._OrtRun, (n) => B._OrtRun = n));\n            B._OrtRunWithBinding = c(b(B._OrtRunWithBinding, () => B._OrtRunWithBinding, (n) => B._OrtRunWithBinding = n));\n            B._OrtBindInput = b(B._OrtBindInput, () => B._OrtBindInput, (n) => B._OrtBindInput = n);\n            B.jsepRegisterBuffer = (n, m, r, w) => a.registerBuffer(n, m, r, w);\n            B.jsepUnregisterBuffers = (n) => {\n              a.unregisterBuffers(n);\n            };\n            B.jsepGetBuffer = (n) => a.getBuffer(n);\n            B.jsepCreateDownloader = (n, m, r) => a.createDownloader(n, m, r);\n          };\n          var ia = Object.assign({}, B), ja = \"./this.program\", E = (a, b) => {\n            throw b;\n          }, ka = \"object\" == typeof window, F = \"function\" == typeof importScripts, G = \"object\" == typeof process && \"object\" == typeof process.versions && \"string\" == typeof process.versions.node, H = B.ENVIRONMENT_IS_PTHREAD || false, I = \"\";\n          function la(a) {\n            return B.locateFile ? B.locateFile(a, I) : I + a;\n          }\n          var ma, J, na;\n          if (G) {\n            var fs = (init_fs(), __toCommonJS(fs_exports)), oa = (init_path(), __toCommonJS(path_exports));\n            I = F ? oa.dirname(I) + \"/\" : __dirname + \"/\";\n            ma = (b, c) => {\n              b = b.startsWith(\"file://\") ? new URL(b) : oa.normalize(b);\n              return fs.readFileSync(b, c ? void 0 : \"utf8\");\n            };\n            na = (b) => {\n              b = ma(b, true);\n              b.buffer || (b = new Uint8Array(b));\n              return b;\n            };\n            J = (b, c, e, f = true) => {\n              b = b.startsWith(\"file://\") ? new URL(b) : oa.normalize(b);\n              fs.readFile(b, f ? void 0 : \"utf8\", (h, k) => {\n                h ? e(h) : c(f ? k.buffer : k);\n              });\n            };\n            !B.thisProgram && 1 < process.argv.length && (ja = process.argv[1].replace(/\\\\/g, \"/\"));\n            process.argv.slice(2);\n            E = (b, c) => {\n              process.exitCode = b;\n              throw c;\n            };\n            B.inspect = () => \"[Emscripten Module object]\";\n            let a;\n            try {\n              a = require_worker_threads();\n            } catch (b) {\n              throw console.error('The \"worker_threads\" module is not supported in this node.js build - perhaps a newer version is needed?'), b;\n            }\n            global.Worker = a.Worker;\n          } else if (ka || F)\n            F ? I = self.location.href : \"undefined\" != typeof document && document.currentScript && (I = document.currentScript.src), typeof _scriptDir !== \"undefined\" && _scriptDir && (I = _scriptDir), 0 !== I.indexOf(\"blob:\") ? I = I.substr(0, I.replace(/[?#].*/, \"\").lastIndexOf(\"/\") + 1) : I = \"\", G || (ma = (a) => {\n              var b = new XMLHttpRequest();\n              b.open(\"GET\", a, false);\n              b.send(null);\n              return b.responseText;\n            }, F && (na = (a) => {\n              var b = new XMLHttpRequest();\n              b.open(\"GET\", a, false);\n              b.responseType = \"arraybuffer\";\n              b.send(null);\n              return new Uint8Array(b.response);\n            }), J = (a, b, c) => {\n              var e = new XMLHttpRequest();\n              e.open(\"GET\", a, true);\n              e.responseType = \"arraybuffer\";\n              e.onload = () => {\n                200 == e.status || 0 == e.status && e.response ? b(e.response) : c();\n              };\n              e.onerror = c;\n              e.send(null);\n            });\n          G && \"undefined\" == typeof performance && (global.performance = require_perf_hooks().performance);\n          var pa = console.log.bind(console), qa = console.error.bind(console);\n          G && (pa = (...a) => fs.writeSync(1, a.join(\" \") + \"\\n\"), qa = (...a) => fs.writeSync(2, a.join(\" \") + \"\\n\"));\n          var ra = B.print || pa, K = B.printErr || qa;\n          Object.assign(B, ia);\n          ia = null;\n          B.thisProgram && (ja = B.thisProgram);\n          B.quit && (E = B.quit);\n          var L;\n          B.wasmBinary && (L = B.wasmBinary);\n          var noExitRuntime = B.noExitRuntime || true;\n          \"object\" != typeof WebAssembly && M(\"no native wasm support detected\");\n          var l, N, sa, P = false, Q, p, aa, ba, ca, ea;\n          function t() {\n            var a = l.buffer;\n            B.HEAP8 = p = new Int8Array(a);\n            B.HEAP16 = new Int16Array(a);\n            B.HEAP32 = ba = new Int32Array(a);\n            B.HEAPU8 = aa = new Uint8Array(a);\n            B.HEAPU16 = new Uint16Array(a);\n            B.HEAPU32 = ca = new Uint32Array(a);\n            B.HEAPF32 = new Float32Array(a);\n            B.HEAPF64 = ea = new Float64Array(a);\n          }\n          var ta = B.INITIAL_MEMORY || 16777216;\n          5242880 <= ta || M(\"INITIAL_MEMORY should be larger than STACK_SIZE, was \" + ta + \"! (STACK_SIZE=5242880)\");\n          if (H)\n            l = B.wasmMemory;\n          else if (B.wasmMemory)\n            l = B.wasmMemory;\n          else if (l = new WebAssembly.Memory({ initial: ta / 65536, maximum: 65536, shared: true }), !(l.buffer instanceof SharedArrayBuffer))\n            throw K(\"requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag\"), G && K(\"(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and/or recent version)\"), Error(\"bad memory\");\n          t();\n          ta = l.buffer.byteLength;\n          var ua = [], va = [], wa = [], xa = 0;\n          function ya() {\n            return noExitRuntime || 0 < xa;\n          }\n          var R = 0, za = null, S = null;\n          function Aa() {\n            R++;\n            B.monitorRunDependencies && B.monitorRunDependencies(R);\n          }\n          function Ba() {\n            R--;\n            B.monitorRunDependencies && B.monitorRunDependencies(R);\n            if (0 == R && (null !== za && (clearInterval(za), za = null), S)) {\n              var a = S;\n              S = null;\n              a();\n            }\n          }\n          function M(a) {\n            if (B.onAbort)\n              B.onAbort(a);\n            a = \"Aborted(\" + a + \")\";\n            K(a);\n            P = true;\n            Q = 1;\n            a = new WebAssembly.RuntimeError(a + \". Build with -sASSERTIONS for more info.\");\n            C(a);\n            throw a;\n          }\n          function Ca(a) {\n            return a.startsWith(\"data:application/octet-stream;base64,\");\n          }\n          var T;\n          T = \"ort-wasm-simd-threaded.wasm\";\n          Ca(T) || (T = la(T));\n          function Da(a) {\n            if (a == T && L)\n              return new Uint8Array(L);\n            if (na)\n              return na(a);\n            throw \"both async and sync fetching of the wasm failed\";\n          }\n          function Ea(a) {\n            if (!L && (ka || F)) {\n              if (\"function\" == typeof fetch && !a.startsWith(\"file://\"))\n                return fetch(a, { credentials: \"same-origin\" }).then((b) => {\n                  if (!b.ok)\n                    throw \"failed to load wasm binary file at '\" + a + \"'\";\n                  return b.arrayBuffer();\n                }).catch(() => Da(a));\n              if (J)\n                return new Promise((b, c) => {\n                  J(a, (e) => b(new Uint8Array(e)), c);\n                });\n            }\n            return Promise.resolve().then(() => Da(a));\n          }\n          function Fa(a, b, c) {\n            return Ea(a).then((e) => WebAssembly.instantiate(e, b)).then((e) => e).then(c, (e) => {\n              K(\"failed to asynchronously prepare wasm: \" + e);\n              M(e);\n            });\n          }\n          function Ga(a, b) {\n            var c = T;\n            return L || \"function\" != typeof WebAssembly.instantiateStreaming || Ca(c) || c.startsWith(\"file://\") || G || \"function\" != typeof fetch ? Fa(c, a, b) : fetch(c, { credentials: \"same-origin\" }).then((e) => WebAssembly.instantiateStreaming(e, a).then(b, function(f) {\n              K(\"wasm streaming compile failed: \" + f);\n              K(\"falling back to ArrayBuffer instantiation\");\n              return Fa(c, a, b);\n            }));\n          }\n          var U, Ha = {\n            906828: (a) => {\n              B.Ea(\"Abs\", a, void 0);\n            },\n            906879: (a) => {\n              B.Ea(\"Neg\", a, void 0);\n            },\n            906930: (a) => {\n              B.Ea(\"Floor\", a, void 0);\n            },\n            906983: (a) => {\n              B.Ea(\"Ceil\", a, void 0);\n            },\n            907035: (a) => {\n              B.Ea(\"Reciprocal\", a, void 0);\n            },\n            907093: (a) => {\n              B.Ea(\"Sqrt\", a, void 0);\n            },\n            907145: (a) => {\n              B.Ea(\"Exp\", a, void 0);\n            },\n            907196: (a) => {\n              B.Ea(\"Erf\", a, void 0);\n            },\n            907247: (a) => {\n              B.Ea(\"Sigmoid\", a, void 0);\n            },\n            907302: (a) => {\n              B.Ea(\"Log\", a, void 0);\n            },\n            907353: (a) => {\n              B.Ea(\"Sin\", a, void 0);\n            },\n            907404: (a) => {\n              B.Ea(\"Cos\", a, void 0);\n            },\n            907455: (a) => {\n              B.Ea(\"Tan\", a, void 0);\n            },\n            907506: (a) => {\n              B.Ea(\"Asin\", a, void 0);\n            },\n            907558: (a) => {\n              B.Ea(\n                \"Acos\",\n                a,\n                void 0\n              );\n            },\n            907610: (a) => {\n              B.Ea(\"Atan\", a, void 0);\n            },\n            907662: (a) => {\n              B.Ea(\"Sinh\", a, void 0);\n            },\n            907714: (a) => {\n              B.Ea(\"Cosh\", a, void 0);\n            },\n            907766: (a) => {\n              B.Ea(\"Asinh\", a, void 0);\n            },\n            907819: (a) => {\n              B.Ea(\"Acosh\", a, void 0);\n            },\n            907872: (a) => {\n              B.Ea(\"Atanh\", a, void 0);\n            },\n            907925: (a) => {\n              B.Ea(\"Tanh\", a, void 0);\n            },\n            907977: (a) => {\n              B.Ea(\"Not\", a, void 0);\n            },\n            908028: (a, b, c) => {\n              B.Ea(\"ClipV10\", a, { min: b, max: c });\n            },\n            908100: (a) => {\n              B.Ea(\"Clip\", a, void 0);\n            },\n            908152: (a, b) => {\n              B.Ea(\"Elu\", a, { alpha: b });\n            },\n            908210: (a) => {\n              B.Ea(\"Relu\", a, void 0);\n            },\n            908262: (a, b) => {\n              B.Ea(\"LeakyRelu\", a, { alpha: b });\n            },\n            908326: (a, b) => {\n              B.Ea(\"ThresholdedRelu\", a, { alpha: b });\n            },\n            908396: (a, b) => {\n              B.Ea(\"Cast\", a, { to: b });\n            },\n            908454: (a) => {\n              B.Ea(\"Add\", a, void 0);\n            },\n            908505: (a) => {\n              B.Ea(\"Sub\", a, void 0);\n            },\n            908556: (a) => {\n              B.Ea(\"Mul\", a, void 0);\n            },\n            908607: (a) => {\n              B.Ea(\"Div\", a, void 0);\n            },\n            908658: (a) => {\n              B.Ea(\"Pow\", a, void 0);\n            },\n            908709: (a) => {\n              B.Ea(\"Equal\", a, void 0);\n            },\n            908762: (a) => {\n              B.Ea(\"Greater\", a, void 0);\n            },\n            908817: (a) => {\n              B.Ea(\"GreaterOrEqual\", a, void 0);\n            },\n            908879: (a) => {\n              B.Ea(\"Less\", a, void 0);\n            },\n            908931: (a) => {\n              B.Ea(\"LessOrEqual\", a, void 0);\n            },\n            908990: (a, b, c, e, f) => {\n              B.Ea(\"ReduceMean\", a, {\n                keepDims: !!b,\n                noopWithEmptyAxes: !!c,\n                axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : []\n              });\n            },\n            909154: (a, b, c, e, f) => {\n              B.Ea(\"ReduceMax\", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n            },\n            909317: (a, b, c, e, f) => {\n              B.Ea(\"ReduceMin\", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n            },\n            909480: (a, b, c, e, f) => {\n              B.Ea(\"ReduceProd\", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n            },\n            909644: (a, b, c, e, f) => {\n              B.Ea(\"ReduceSum\", a, {\n                keepDims: !!b,\n                noopWithEmptyAxes: !!c,\n                axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : []\n              });\n            },\n            909807: (a, b, c, e, f) => {\n              B.Ea(\"ReduceL1\", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n            },\n            909969: (a, b, c, e, f) => {\n              B.Ea(\"ReduceL2\", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n            },\n            910131: (a, b, c, e, f) => {\n              B.Ea(\"ReduceLogSum\", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n            },\n            910297: (a, b, c, e, f) => {\n              B.Ea(\"ReduceSumSquare\", a, {\n                keepDims: !!b,\n                noopWithEmptyAxes: !!c,\n                axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : []\n              });\n            },\n            910466: (a, b, c, e, f) => {\n              B.Ea(\"ReduceLogSumExp\", a, { keepDims: !!b, noopWithEmptyAxes: !!c, axes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n            },\n            910635: (a) => {\n              B.Ea(\"Where\", a, void 0);\n            },\n            910688: (a, b, c) => {\n              B.Ea(\"Transpose\", a, { perm: b ? Array.from(z().subarray(c >>> 0, c + b >>> 0)) : [] });\n            },\n            910801: (a, b, c, e, f, h, k, q, n, m) => {\n              B.Ea(\"Conv\", a, { format: n ? \"NHWC\" : \"NCHW\", auto_pad: b, dilations: [c], group: e, kernel_shape: [f], pads: [h, k], strides: [q], w_is_const: () => !!d()[m >>> 0] });\n            },\n            911029: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u) => {\n              B.Ea(\"Conv\", a, { format: g ? \"NHWC\" : \"NCHW\", auto_pad: b, dilations: [c, e], group: f, kernel_shape: [h, k], pads: [q, n, m, r], strides: [w, x], w_is_const: () => !!d()[u >>> 0] });\n            },\n            911288: (a, b, c, e, f, h, k, q, n, m) => {\n              B.Ea(\"Conv\", a, { format: n ? \"NHWC\" : \"NCHW\", auto_pad: b, dilations: [c], group: e, kernel_shape: [f], pads: [h, k], strides: [q], w_is_const: () => !!d()[m >>> 0] });\n            },\n            911516: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u) => {\n              B.Ea(\"Conv\", a, { format: g ? \"NHWC\" : \"NCHW\", auto_pad: b, dilations: [c, e], group: f, kernel_shape: [\n                h,\n                k\n              ], pads: [q, n, m, r], strides: [w, x], w_is_const: () => !!d()[u >>> 0] });\n            },\n            911775: (a, b, c, e, f, h, k, q, n, m, r, w, x, g) => {\n              B.Ea(\"ConvTranspose\", a, { format: n ? \"NHWC\" : \"NCHW\", autoPad: b, dilations: [c], group: e, kernel_shape: [f], pads: [h, k], strides: [q], wIsConst: () => !!d()[m >>> 0], outputPadding: r ? Array.from(z().subarray(w >>> 0, w + r >>> 0)) : [], outputShape: x ? Array.from(z().subarray(g >>> 0, g + x >>> 0)) : [] });\n            },\n            912155: (a, b, c, e, f, h, k, q, n, m, r, w, x) => {\n              B.Ea(\"ConvTranspose\", a, { format: q ? \"NHWC\" : \"NCHW\", autoPad: b, dilations: Array.from(z().subarray(c >>> 0, c + 2 >>> 0)), group: e, kernelShape: Array.from(z().subarray(f >>> 0, f + 2 >>> 0)), pads: Array.from(z().subarray(h >>> 0, h + 4 >>> 0)), strides: Array.from(z().subarray(k >>> 0, k + 2 >>> 0)), wIsConst: () => !!d()[n >>> 0], outputPadding: 0 < m ? Array.from(z().subarray(r >>> 0, r + m >>> 0)) : [], outputShape: 0 < w ? Array.from(z().subarray(x >>> 0, x + w >>> 0)) : [] });\n            },\n            912678: (a, b, c, e, f, h, k, q, n, m, r, w, x, g) => {\n              B.Ea(\"ConvTranspose\", a, { format: n ? \"NHWC\" : \"NCHW\", autoPad: b, dilations: [c], group: e, kernel_shape: [f], pads: [h, k], strides: [q], wIsConst: () => !!d()[m >>> 0], outputPadding: r ? Array.from(z().subarray(w >>> 0, w + r >>> 0)) : [], outputShape: x ? Array.from(z().subarray(g >>> 0, g + x >>> 0)) : [] });\n            },\n            913058: (a, b, c, e, f, h, k, q, n, m, r, w, x) => {\n              B.Ea(\"ConvTranspose\", a, { format: q ? \"NHWC\" : \"NCHW\", autoPad: b, dilations: Array.from(z().subarray(c >>> 0, c + 2 >>> 0)), group: e, kernelShape: Array.from(z().subarray(f >>> 0, f + 2 >>> 0)), pads: Array.from(z().subarray(h >>> 0, h + 4 >>> 0)), strides: Array.from(z().subarray(k >>> 0, k + 2 >>> 0)), wIsConst: () => !!d()[n >>> 0], outputPadding: 0 < m ? Array.from(z().subarray(r >>> 0, r + m >>> 0)) : [], outputShape: 0 < w ? Array.from(z().subarray(x >>> 0, x + w >>> 0)) : [] });\n            },\n            913581: (a, b) => {\n              B.Ea(\"GlobalAveragePool\", a, { format: b ? \"NHWC\" : \"NCHW\" });\n            },\n            913672: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u, y) => {\n              B.Ea(\"AveragePool\", a, { format: y ? \"NHWC\" : \"NCHW\", auto_pad: b, ceil_mode: c, count_include_pad: e, storage_order: f, dilations: [h, k], kernel_shape: [q, n], pads: [m, r, w, x], strides: [g, u] });\n            },\n            913956: (a, b) => {\n              B.Ea(\"GlobalAveragePool\", a, { format: b ? \"NHWC\" : \"NCHW\" });\n            },\n            914047: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u, y) => {\n              B.Ea(\"AveragePool\", a, {\n                format: y ? \"NHWC\" : \"NCHW\",\n                auto_pad: b,\n                ceil_mode: c,\n                count_include_pad: e,\n                storage_order: f,\n                dilations: [h, k],\n                kernel_shape: [q, n],\n                pads: [m, r, w, x],\n                strides: [g, u]\n              });\n            },\n            914331: (a, b) => {\n              B.Ea(\"GlobalMaxPool\", a, { format: b ? \"NHWC\" : \"NCHW\" });\n            },\n            914418: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u, y) => {\n              B.Ea(\"MaxPool\", a, { format: y ? \"NHWC\" : \"NCHW\", auto_pad: b, ceil_mode: c, count_include_pad: e, storage_order: f, dilations: [h, k], kernel_shape: [q, n], pads: [m, r, w, x], strides: [g, u] });\n            },\n            914698: (a, b) => {\n              B.Ea(\"GlobalMaxPool\", a, { format: b ? \"NHWC\" : \"NCHW\" });\n            },\n            914785: (a, b, c, e, f, h, k, q, n, m, r, w, x, g, u, y) => {\n              B.Ea(\n                \"MaxPool\",\n                a,\n                { format: y ? \"NHWC\" : \"NCHW\", auto_pad: b, ceil_mode: c, count_include_pad: e, storage_order: f, dilations: [h, k], kernel_shape: [q, n], pads: [m, r, w, x], strides: [g, u] }\n              );\n            },\n            915065: (a, b, c, e, f) => {\n              B.Ea(\"Gemm\", a, { alpha: b, beta: c, transA: e, transB: f });\n            },\n            915169: (a) => {\n              B.Ea(\"MatMul\", a, void 0);\n            },\n            915223: (a, b, c, e) => {\n              B.Ea(\"ArgMax\", a, { keepDims: !!b, selectLastIndex: !!c, axis: e });\n            },\n            915331: (a, b, c, e) => {\n              B.Ea(\"ArgMin\", a, { keepDims: !!b, selectLastIndex: !!c, axis: e });\n            },\n            915439: (a, b) => {\n              B.Ea(\"Softmax\", a, { axis: b });\n            },\n            915502: (a, b) => {\n              B.Ea(\"Concat\", a, { axis: b });\n            },\n            915562: (a, b, c, e, f) => {\n              B.Ea(\"Split\", a, { axis: b, numOutputs: c, splitSizes: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n            },\n            915707: (a) => {\n              B.Ea(\"Expand\", a, void 0);\n            },\n            915761: (a, b) => {\n              B.Ea(\"Gather\", a, { axis: Number(b) });\n            },\n            915832: (a, b) => {\n              B.Ea(\"GatherElements\", a, { axis: Number(b) });\n            },\n            915911: (a, b, c, e, f, h, k, q, n, m, r) => {\n              B.Ea(\"Resize\", a, { antialias: b, axes: c ? Array.from(z().subarray(e >>> 0, e + c >>> 0)) : [], coordinateTransformMode: V(f), cubicCoeffA: h, excludeOutside: k, extrapolationValue: q, keepAspectRatioPolicy: V(n), mode: V(m), nearestMode: V(r) });\n            },\n            916262: (a, b, c, e, f, h, k) => {\n              B.Ea(\"Slice\", a, { starts: b ? Array.from(z().subarray(c >>> 0, c + b >>> 0)) : [], ends: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [], axes: h ? Array.from(z().subarray(k >>> 0, k + h >>> 0)) : [] });\n            },\n            916493: (a) => {\n              B.Ea(\"Tile\", a, void 0);\n            },\n            916545: (a, b, c) => {\n              B.Ea(\"LayerNormalization\", a, { axis: Number(b), epsilon: Number(c) });\n            },\n            916652: (a, b, c) => {\n              B.Ea(\"InstanceNormalization\", a, { epsilon: b, format: c ? \"NHWC\" : \"NCHW\" });\n            },\n            916766: (a, b, c) => {\n              B.Ea(\"InstanceNormalization\", a, { epsilon: b, format: c ? \"NHWC\" : \"NCHW\" });\n            },\n            916880: (a) => {\n              B.Ea(\n                \"Range\",\n                a,\n                void 0\n              );\n            },\n            916933: (a, b) => {\n              B.Ea(\"Einsum\", a, { equation: V(b) });\n            },\n            917014: (a, b, c, e, f) => {\n              B.Ea(\"Pad\", a, { mode: b, value: c, pads: e ? Array.from(z().subarray(f >>> 0, f + e >>> 0)) : [] });\n            },\n            917146: (a) => {\n              B.Ea(\"Gelu\", a, void 0);\n            },\n            917198: (a) => {\n              B.Ea(\"BiasAdd\", a, void 0);\n            },\n            917253: (a) => {\n              B.Ea(\"BiasSplitGelu\", a, void 0);\n            },\n            917314: (a, b) => {\n              B.Ea(\"SkipLayerNormalization\", a, { epsilon: b });\n            },\n            917395: (a) => {\n              B.zb(a);\n            },\n            917429: (a, b) => B.Ab(a, b, B.bb.Fb, B.bb.errors),\n            917541: (a) => B.wb(a),\n            917574: (a) => B.yb(a),\n            917606: (a, b, c) => {\n              B.jb(a, b, c, true);\n            },\n            917645: (a, b, c) => {\n              B.jb(a, b, c);\n            }\n          };\n          function Ia(a) {\n            this.name = \"ExitStatus\";\n            this.message = `Program terminated with exit(${a})`;\n            this.status = a;\n          }\n          function Ja(a) {\n            a.terminate();\n            a.onmessage = () => {\n            };\n          }\n          function Ka(a) {\n            (a = W.Qa[a]) || M();\n            W.Eb(a);\n          }\n          function La(a) {\n            var b = W.tb();\n            if (!b)\n              return 6;\n            W.Ya.push(b);\n            W.Qa[a.Xa] = b;\n            b.Xa = a.Xa;\n            var c = { cmd: \"run\", start_routine: a.Gb, arg: a.rb, pthread_ptr: a.Xa };\n            G && b.unref();\n            b.postMessage(c, a.Mb);\n            return 0;\n          }\n          var Ma = \"undefined\" != typeof TextDecoder ? new TextDecoder(\"utf8\") : void 0, Na = (a, b, c) => {\n            b >>>= 0;\n            var e = b + c;\n            for (c = b; a[c] && !(c >= e); )\n              ++c;\n            if (16 < c - b && a.buffer && Ma)\n              return Ma.decode(a.buffer instanceof SharedArrayBuffer ? a.slice(b, c) : a.subarray(b, c));\n            for (e = \"\"; b < c; ) {\n              var f = a[b++];\n              if (f & 128) {\n                var h = a[b++] & 63;\n                if (192 == (f & 224))\n                  e += String.fromCharCode((f & 31) << 6 | h);\n                else {\n                  var k = a[b++] & 63;\n                  f = 224 == (f & 240) ? (f & 15) << 12 | h << 6 | k : (f & 7) << 18 | h << 12 | k << 6 | a[b++] & 63;\n                  65536 > f ? e += String.fromCharCode(f) : (f -= 65536, e += String.fromCharCode(55296 | f >> 10, 56320 | f & 1023));\n                }\n              } else\n                e += String.fromCharCode(f);\n            }\n            return e;\n          }, V = (a, b) => (a >>>= 0) ? Na(v(), a, b) : \"\";\n          function Oa(a) {\n            if (H)\n              return X(1, 1, a);\n            Q = a;\n            if (!ya()) {\n              W.Hb();\n              if (B.onExit)\n                B.onExit(a);\n              P = true;\n            }\n            E(a, new Ia(a));\n          }\n          var Qa = (a) => {\n            Q = a;\n            if (H)\n              throw Pa(a), \"unwind\";\n            Oa(a);\n          }, W = {\n            ab: [],\n            Ya: [],\n            mb: [],\n            Qa: {},\n            gb: function() {\n              H ? W.vb() : W.ub();\n            },\n            ub: function() {\n              ua.unshift(() => {\n                Aa();\n                W.Bb(() => Ba());\n              });\n            },\n            vb: function() {\n              W.receiveObjectTransfer = W.Db;\n              W.threadInitTLS = W.lb;\n              W.setExitStatus = W.kb;\n              noExitRuntime = false;\n            },\n            kb: function(a) {\n              Q = a;\n            },\n            Sb: [\"$terminateWorker\"],\n            Hb: function() {\n              for (var a of W.Ya)\n                Ja(a);\n              for (a of W.ab)\n                Ja(a);\n              W.ab = [];\n              W.Ya = [];\n              W.Qa = [];\n            },\n            Eb: function(a) {\n              var b = a.Xa;\n              delete W.Qa[b];\n              W.ab.push(a);\n              W.Ya.splice(W.Ya.indexOf(a), 1);\n              a.Xa = 0;\n              Ra(b);\n            },\n            Db: function() {\n            },\n            lb: function() {\n              W.mb.forEach((a) => a());\n            },\n            Cb: (a) => new Promise((b) => {\n              a.onmessage = (h) => {\n                h = h.data;\n                var k = h.cmd;\n                if (h.targetThread && h.targetThread != Sa()) {\n                  var q = W.Qa[h.Rb];\n                  q ? q.postMessage(h, h.transferList) : K('Internal error! Worker sent a message \"' + k + '\" to target pthread ' + h.targetThread + \", but that thread no longer exists!\");\n                } else if (\"checkMailbox\" === k)\n                  Ta();\n                else if (\"spawnThread\" === k)\n                  La(h);\n                else if (\"cleanupThread\" === k)\n                  Ka(h.thread);\n                else if (\"killThread\" === k)\n                  h = h.thread, k = W.Qa[h], delete W.Qa[h], Ja(k), Ra(h), W.Ya.splice(\n                    W.Ya.indexOf(k),\n                    1\n                  ), k.Xa = 0;\n                else if (\"cancelThread\" === k)\n                  W.Qa[h.thread].postMessage({ cmd: \"cancel\" });\n                else if (\"loaded\" === k)\n                  a.loaded = true, b(a);\n                else if (\"alert\" === k)\n                  alert(\"Thread \" + h.threadId + \": \" + h.text);\n                else if (\"setimmediate\" === h.target)\n                  a.postMessage(h);\n                else if (\"callHandler\" === k)\n                  B[h.handler](...h.args);\n                else\n                  k && K(\"worker sent an unknown command \" + k);\n              };\n              a.onerror = (h) => {\n                K(\"worker sent an error! \" + h.filename + \":\" + h.lineno + \": \" + h.message);\n                throw h;\n              };\n              G && (a.on(\"message\", function(h) {\n                a.onmessage({ data: h });\n              }), a.on(\"error\", function(h) {\n                a.onerror(h);\n              }));\n              var c = [], e = [\"onExit\", \"onAbort\", \"print\", \"printErr\"], f;\n              for (f of e)\n                B.hasOwnProperty(f) && c.push(f);\n              a.postMessage({ cmd: \"load\", handlers: c, urlOrBlob: B.mainScriptUrlOrBlob || _scriptDir, wasmMemory: l, wasmModule: sa });\n            }),\n            Bb: function(a) {\n              a();\n            },\n            qb: function() {\n              var a = la(\"ort-wasm-simd-threaded.worker.js\");\n              a = new Worker(a);\n              W.ab.push(a);\n            },\n            tb: function() {\n              0 == W.ab.length && (W.qb(), W.Cb(W.ab[0]));\n              return W.ab.pop();\n            }\n          };\n          B.PThread = W;\n          var Ua = (a) => {\n            for (; 0 < a.length; )\n              a.shift()(B);\n          };\n          B.establishStackSpace = function() {\n            var a = Sa(), b = z()[a + 52 >> 2 >>> 0];\n            a = z()[a + 56 >> 2 >>> 0];\n            Va(b, b - a);\n            Wa(b);\n          };\n          function Pa(a) {\n            if (H)\n              return X(2, 0, a);\n            Qa(a);\n          }\n          B.invokeEntryPoint = function(a, b) {\n            a = Xa.apply(null, [a, b]);\n            ya() ? W.kb(a) : Ya(a);\n          };\n          function Za(a) {\n            this.fb = a - 24;\n            this.pb = function(b) {\n              A()[this.fb + 4 >> 2 >>> 0] = b;\n            };\n            this.ob = function(b) {\n              A()[this.fb + 8 >> 2 >>> 0] = b;\n            };\n            this.gb = function(b, c) {\n              this.nb();\n              this.pb(b);\n              this.ob(c);\n            };\n            this.nb = function() {\n              A()[this.fb + 16 >> 2 >>> 0] = 0;\n            };\n          }\n          var $a = 0, ab = 0;\n          function bb(a, b, c, e) {\n            return H ? X(3, 1, a, b, c, e) : cb(a, b, c, e);\n          }\n          function cb(a, b, c, e) {\n            a >>>= 0;\n            b >>>= 0;\n            c >>>= 0;\n            e >>>= 0;\n            if (\"undefined\" == typeof SharedArrayBuffer)\n              return K(\"Current environment does not support SharedArrayBuffer, pthreads are not available!\"), 6;\n            var f = [];\n            if (H && 0 === f.length)\n              return bb(a, b, c, e);\n            a = { Gb: c, Xa: a, rb: e, Mb: f };\n            return H ? (a.Ob = \"spawnThread\", postMessage(a, f), 0) : La(a);\n          }\n          function db(a, b, c) {\n            return H ? X(4, 1, a, b, c) : 0;\n          }\n          function eb(a, b) {\n            if (H)\n              return X(5, 1, a, b);\n          }\n          var fb = (a) => {\n            for (var b = 0, c = 0; c < a.length; ++c) {\n              var e = a.charCodeAt(c);\n              127 >= e ? b++ : 2047 >= e ? b += 2 : 55296 <= e && 57343 >= e ? (b += 4, ++c) : b += 3;\n            }\n            return b;\n          }, gb = (a, b, c, e) => {\n            c >>>= 0;\n            if (!(0 < e))\n              return 0;\n            var f = c;\n            e = c + e - 1;\n            for (var h = 0; h < a.length; ++h) {\n              var k = a.charCodeAt(h);\n              if (55296 <= k && 57343 >= k) {\n                var q = a.charCodeAt(++h);\n                k = 65536 + ((k & 1023) << 10) | q & 1023;\n              }\n              if (127 >= k) {\n                if (c >= e)\n                  break;\n                b[c++ >>> 0] = k;\n              } else {\n                if (2047 >= k) {\n                  if (c + 1 >= e)\n                    break;\n                  b[c++ >>> 0] = 192 | k >> 6;\n                } else {\n                  if (65535 >= k) {\n                    if (c + 2 >= e)\n                      break;\n                    b[c++ >>> 0] = 224 | k >> 12;\n                  } else {\n                    if (c + 3 >= e)\n                      break;\n                    b[c++ >>> 0] = 240 | k >> 18;\n                    b[c++ >>> 0] = 128 | k >> 12 & 63;\n                  }\n                  b[c++ >>> 0] = 128 | k >> 6 & 63;\n                }\n                b[c++ >>> 0] = 128 | k & 63;\n              }\n            }\n            b[c >>> 0] = 0;\n            return c - f;\n          }, hb = (a, b, c) => gb(a, v(), b, c);\n          function ib(a, b) {\n            if (H)\n              return X(6, 1, a, b);\n          }\n          function jb(a, b, c) {\n            if (H)\n              return X(7, 1, a, b, c);\n          }\n          function kb(a, b, c) {\n            return H ? X(8, 1, a, b, c) : 0;\n          }\n          function lb(a, b) {\n            if (H)\n              return X(9, 1, a, b);\n          }\n          function mb(a, b, c) {\n            if (H)\n              return X(10, 1, a, b, c);\n          }\n          function nb(a, b, c, e) {\n            if (H)\n              return X(11, 1, a, b, c, e);\n          }\n          function ob(a, b, c, e) {\n            if (H)\n              return X(12, 1, a, b, c, e);\n          }\n          function pb(a, b, c, e) {\n            if (H)\n              return X(13, 1, a, b, c, e);\n          }\n          function qb(a) {\n            if (H)\n              return X(14, 1, a);\n          }\n          function rb(a, b) {\n            if (H)\n              return X(15, 1, a, b);\n          }\n          function sb(a, b, c) {\n            if (H)\n              return X(16, 1, a, b, c);\n          }\n          var tb = (a) => {\n            if (!P)\n              try {\n                if (a(), !ya())\n                  try {\n                    H ? Ya(Q) : Qa(Q);\n                  } catch (b) {\n                    b instanceof Ia || \"unwind\" == b || E(1, b);\n                  }\n              } catch (b) {\n                b instanceof Ia || \"unwind\" == b || E(1, b);\n              }\n          };\n          function ub(a) {\n            a >>>= 0;\n            \"function\" === typeof Atomics.Nb && (Atomics.Nb(z(), a >> 2, a).value.then(Ta), a += 128, Atomics.store(z(), a >> 2, 1));\n          }\n          B.__emscripten_thread_mailbox_await = ub;\n          function Ta() {\n            var a = Sa();\n            a && (ub(a), tb(() => vb()));\n          }\n          B.checkMailbox = Ta;\n          var Y = (a) => 0 === a % 4 && (0 !== a % 100 || 0 === a % 400), wb = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335], xb = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];\n          function yb(a, b, c, e, f, h, k, q) {\n            return H ? X(17, 1, a, b, c, e, f, h, k, q) : -52;\n          }\n          function zb(a, b, c, e, f, h, k) {\n            if (H)\n              return X(18, 1, a, b, c, e, f, h, k);\n          }\n          var Bb = (a) => {\n            var b = fb(a) + 1, c = Ab(b);\n            c && hb(a, c, b);\n            return c;\n          }, Cb = [], Db = (a, b) => {\n            Cb.length = 0;\n            var c;\n            for (b >>= 2; c = v()[a++ >>> 0]; )\n              b += 105 != c & b, Cb.push(105 == c ? z()[b >>> 0] : da()[b++ >>> 1]), ++b;\n            return Cb;\n          }, Fb = (a) => {\n            var b = Eb();\n            a = a();\n            Wa(b);\n            return a;\n          };\n          function X(a, b) {\n            var c = arguments.length - 2, e = arguments;\n            return Fb(() => {\n              for (var f = Gb(8 * c), h = f >> 3, k = 0; k < c; k++) {\n                var q = e[2 + k];\n                da()[h + k >>> 0] = q;\n              }\n              return Hb(a, c, f, b);\n            });\n          }\n          var Ib = [], Jb = {}, Lb = () => {\n            if (!Kb) {\n              var a = { USER: \"web_user\", LOGNAME: \"web_user\", PATH: \"/\", PWD: \"/\", HOME: \"/home/web_user\", LANG: (\"object\" == typeof navigator && navigator.languages && navigator.languages[0] || \"C\").replace(\"-\", \"_\") + \".UTF-8\", _: ja || \"./this.program\" }, b;\n              for (b in Jb)\n                void 0 === Jb[b] ? delete a[b] : a[b] = Jb[b];\n              var c = [];\n              for (b in a)\n                c.push(`${b}=${a[b]}`);\n              Kb = c;\n            }\n            return Kb;\n          }, Kb;\n          function Mb(a, b) {\n            if (H)\n              return X(19, 1, a, b);\n            a >>>= 0;\n            b >>>= 0;\n            var c = 0;\n            Lb().forEach(function(e, f) {\n              var h = b + c;\n              f = A()[a + 4 * f >> 2 >>> 0] = h;\n              for (h = 0; h < e.length; ++h)\n                d()[f++ >> 0 >>> 0] = e.charCodeAt(h);\n              d()[f >> 0 >>> 0] = 0;\n              c += e.length + 1;\n            });\n            return 0;\n          }\n          function Nb(a, b) {\n            if (H)\n              return X(20, 1, a, b);\n            a >>>= 0;\n            b >>>= 0;\n            var c = Lb();\n            A()[a >> 2 >>> 0] = c.length;\n            var e = 0;\n            c.forEach(function(f) {\n              e += f.length + 1;\n            });\n            A()[b >> 2 >>> 0] = e;\n            return 0;\n          }\n          function Ob(a) {\n            return H ? X(21, 1, a) : 52;\n          }\n          function Pb(a, b, c, e) {\n            return H ? X(22, 1, a, b, c, e) : 52;\n          }\n          function Qb(a, b, c, e, f) {\n            return H ? X(23, 1, a, b, c, e, f) : 70;\n          }\n          var Rb = [null, [], []];\n          function Tb(a, b, c, e) {\n            if (H)\n              return X(24, 1, a, b, c, e);\n            b >>>= 0;\n            c >>>= 0;\n            e >>>= 0;\n            for (var f = 0, h = 0; h < c; h++) {\n              var k = A()[b >> 2 >>> 0], q = A()[b + 4 >> 2 >>> 0];\n              b += 8;\n              for (var n = 0; n < q; n++) {\n                var m = v()[k + n >>> 0], r = Rb[a];\n                0 === m || 10 === m ? ((1 === a ? ra : K)(Na(r, 0)), r.length = 0) : r.push(m);\n              }\n              f += q;\n            }\n            A()[e >> 2 >>> 0] = f;\n            return 0;\n          }\n          var Ub = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], Vb = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];\n          function Wb(a) {\n            var b = Array(fb(a) + 1);\n            gb(a, b, 0, b.length);\n            return b;\n          }\n          var Xb = (a, b) => {\n            d().set(a, b >>> 0);\n          };\n          function Yb(a, b, c, e) {\n            function f(g, u, y) {\n              for (g = \"number\" == typeof g ? g.toString() : g || \"\"; g.length < u; )\n                g = y[0] + g;\n              return g;\n            }\n            function h(g, u) {\n              return f(g, u, \"0\");\n            }\n            function k(g, u) {\n              function y(Sb) {\n                return 0 > Sb ? -1 : 0 < Sb ? 1 : 0;\n              }\n              var O;\n              0 === (O = y(g.getFullYear() - u.getFullYear())) && 0 === (O = y(g.getMonth() - u.getMonth())) && (O = y(g.getDate() - u.getDate()));\n              return O;\n            }\n            function q(g) {\n              switch (g.getDay()) {\n                case 0:\n                  return new Date(g.getFullYear() - 1, 11, 29);\n                case 1:\n                  return g;\n                case 2:\n                  return new Date(g.getFullYear(), 0, 3);\n                case 3:\n                  return new Date(\n                    g.getFullYear(),\n                    0,\n                    2\n                  );\n                case 4:\n                  return new Date(g.getFullYear(), 0, 1);\n                case 5:\n                  return new Date(g.getFullYear() - 1, 11, 31);\n                case 6:\n                  return new Date(g.getFullYear() - 1, 11, 30);\n              }\n            }\n            function n(g) {\n              var u = g.Za;\n              for (g = new Date(new Date(g.$a + 1900, 0, 1).getTime()); 0 < u; ) {\n                var y = g.getMonth(), O = (Y(g.getFullYear()) ? Ub : Vb)[y];\n                if (u > O - g.getDate())\n                  u -= O - g.getDate() + 1, g.setDate(1), 11 > y ? g.setMonth(y + 1) : (g.setMonth(0), g.setFullYear(g.getFullYear() + 1));\n                else {\n                  g.setDate(g.getDate() + u);\n                  break;\n                }\n              }\n              y = new Date(g.getFullYear() + 1, 0, 4);\n              u = q(new Date(\n                g.getFullYear(),\n                0,\n                4\n              ));\n              y = q(y);\n              return 0 >= k(u, g) ? 0 >= k(y, g) ? g.getFullYear() + 1 : g.getFullYear() : g.getFullYear() - 1;\n            }\n            a >>>= 0;\n            b >>>= 0;\n            c >>>= 0;\n            e >>>= 0;\n            var m = z()[e + 40 >> 2 >>> 0];\n            e = { Kb: z()[e >> 2 >>> 0], Jb: z()[e + 4 >> 2 >>> 0], cb: z()[e + 8 >> 2 >>> 0], ib: z()[e + 12 >> 2 >>> 0], eb: z()[e + 16 >> 2 >>> 0], $a: z()[e + 20 >> 2 >>> 0], Wa: z()[e + 24 >> 2 >>> 0], Za: z()[e + 28 >> 2 >>> 0], Tb: z()[e + 32 >> 2 >>> 0], Ib: z()[e + 36 >> 2 >>> 0], Lb: m ? V(m) : \"\" };\n            c = V(c);\n            m = {\n              \"%c\": \"%a %b %d %H:%M:%S %Y\",\n              \"%D\": \"%m/%d/%y\",\n              \"%F\": \"%Y-%m-%d\",\n              \"%h\": \"%b\",\n              \"%r\": \"%I:%M:%S %p\",\n              \"%R\": \"%H:%M\",\n              \"%T\": \"%H:%M:%S\",\n              \"%x\": \"%m/%d/%y\",\n              \"%X\": \"%H:%M:%S\",\n              \"%Ec\": \"%c\",\n              \"%EC\": \"%C\",\n              \"%Ex\": \"%m/%d/%y\",\n              \"%EX\": \"%H:%M:%S\",\n              \"%Ey\": \"%y\",\n              \"%EY\": \"%Y\",\n              \"%Od\": \"%d\",\n              \"%Oe\": \"%e\",\n              \"%OH\": \"%H\",\n              \"%OI\": \"%I\",\n              \"%Om\": \"%m\",\n              \"%OM\": \"%M\",\n              \"%OS\": \"%S\",\n              \"%Ou\": \"%u\",\n              \"%OU\": \"%U\",\n              \"%OV\": \"%V\",\n              \"%Ow\": \"%w\",\n              \"%OW\": \"%W\",\n              \"%Oy\": \"%y\"\n            };\n            for (var r in m)\n              c = c.replace(new RegExp(r, \"g\"), m[r]);\n            var w = \"Sunday Monday Tuesday Wednesday Thursday Friday Saturday\".split(\" \"), x = \"January February March April May June July August September October November December\".split(\" \");\n            m = { \"%a\": (g) => w[g.Wa].substring(0, 3), \"%A\": (g) => w[g.Wa], \"%b\": (g) => x[g.eb].substring(0, 3), \"%B\": (g) => x[g.eb], \"%C\": (g) => h((g.$a + 1900) / 100 | 0, 2), \"%d\": (g) => h(g.ib, 2), \"%e\": (g) => f(g.ib, 2, \" \"), \"%g\": (g) => n(g).toString().substring(2), \"%G\": (g) => n(g), \"%H\": (g) => h(g.cb, 2), \"%I\": (g) => {\n              g = g.cb;\n              0 == g ? g = 12 : 12 < g && (g -= 12);\n              return h(g, 2);\n            }, \"%j\": (g) => {\n              for (var u = 0, y = 0; y <= g.eb - 1; u += (Y(g.$a + 1900) ? Ub : Vb)[y++])\n                ;\n              return h(g.ib + u, 3);\n            }, \"%m\": (g) => h(g.eb + 1, 2), \"%M\": (g) => h(g.Jb, 2), \"%n\": () => \"\\n\", \"%p\": (g) => 0 <= g.cb && 12 > g.cb ? \"AM\" : \"PM\", \"%S\": (g) => h(g.Kb, 2), \"%t\": () => \"\t\", \"%u\": (g) => g.Wa || 7, \"%U\": (g) => h(Math.floor((g.Za + 7 - g.Wa) / 7), 2), \"%V\": (g) => {\n              var u = Math.floor((g.Za + 7 - (g.Wa + 6) % 7) / 7);\n              2 >= (g.Wa + 371 - g.Za - 2) % 7 && u++;\n              if (u)\n                53 == u && (y = (g.Wa + 371 - g.Za) % 7, 4 == y || 3 == y && Y(g.$a) || (u = 1));\n              else {\n                u = 52;\n                var y = (g.Wa + 7 - g.Za - 1) % 7;\n                (4 == y || 5 == y && Y(g.$a % 400 - 1)) && u++;\n              }\n              return h(u, 2);\n            }, \"%w\": (g) => g.Wa, \"%W\": (g) => h(Math.floor((g.Za + 7 - (g.Wa + 6) % 7) / 7), 2), \"%y\": (g) => (g.$a + 1900).toString().substring(2), \"%Y\": (g) => g.$a + 1900, \"%z\": (g) => {\n              g = g.Ib;\n              var u = 0 <= g;\n              g = Math.abs(g) / 60;\n              return (u ? \"+\" : \"-\") + String(\"0000\" + (g / 60 * 100 + g % 60)).slice(-4);\n            }, \"%Z\": (g) => g.Lb, \"%%\": () => \"%\" };\n            c = c.replace(/%%/g, \"\\0\\0\");\n            for (r in m)\n              c.includes(r) && (c = c.replace(new RegExp(r, \"g\"), m[r](e)));\n            c = c.replace(/\\0\\0/g, \"%\");\n            r = Wb(c);\n            if (r.length > b)\n              return 0;\n            Xb(r, a);\n            return r.length - 1;\n          }\n          function Zb(a) {\n            try {\n              a();\n            } catch (b) {\n              M(b);\n            }\n          }\n          function $b(a) {\n            var b = {}, c;\n            for (c in a)\n              (function(e) {\n                var f = a[e];\n                b[e] = \"function\" == typeof f ? function() {\n                  ac.push(e);\n                  try {\n                    return f.apply(null, arguments);\n                  } finally {\n                    P || (ac.pop() === e || M(), D && 1 === Z && 0 === ac.length && (Z = 0, xa += 1, Zb(bc), \"undefined\" != typeof Fibers && Fibers.Ub()));\n                  }\n                } : f;\n              })(c);\n            return b;\n          }\n          var Z = 0, D = null, cc = 0, ac = [], dc = {}, ec = {}, fc = 0, gc = null, hc = [];\n          function ha() {\n            return new Promise((a, b) => {\n              gc = { resolve: a, reject: b };\n            });\n          }\n          function ic() {\n            var a = Ab(65548), b = a + 12;\n            A()[a >> 2 >>> 0] = b;\n            A()[a + 4 >> 2 >>> 0] = b + 65536;\n            b = ac[0];\n            var c = dc[b];\n            void 0 === c && (c = fc++, dc[b] = c, ec[c] = b);\n            b = c;\n            z()[a + 8 >> 2 >>> 0] = b;\n            return a;\n          }\n          function jc() {\n            var a = z()[D + 8 >> 2 >>> 0];\n            a = N[ec[a]];\n            --xa;\n            return a();\n          }\n          function kc(a) {\n            if (!P) {\n              if (0 === Z) {\n                var b = false, c = false;\n                a((e = 0) => {\n                  if (!P && (cc = e, b = true, c)) {\n                    Z = 2;\n                    Zb(() => lc(D));\n                    \"undefined\" != typeof Browser && Browser.hb.sb && Browser.hb.resume();\n                    e = false;\n                    try {\n                      var f = jc();\n                    } catch (q) {\n                      f = q, e = true;\n                    }\n                    var h = false;\n                    if (!D) {\n                      var k = gc;\n                      k && (gc = null, (e ? k.reject : k.resolve)(f), h = true);\n                    }\n                    if (e && !h)\n                      throw f;\n                  }\n                });\n                c = true;\n                b || (Z = 1, D = ic(), \"undefined\" != typeof Browser && Browser.hb.sb && Browser.hb.pause(), Zb(() => mc(D)));\n              } else\n                2 === Z ? (Z = 0, Zb(nc), oc(D), D = null, hc.forEach((e) => tb(e))) : M(`invalid state: ${Z}`);\n              return cc;\n            }\n          }\n          function pc(a) {\n            return kc((b) => {\n              a().then(b);\n            });\n          }\n          W.gb();\n          var qc = [null, Oa, Pa, bb, db, eb, ib, jb, kb, lb, mb, nb, ob, pb, qb, rb, sb, yb, zb, Mb, Nb, Ob, Pb, Qb, Tb], tc = {\n            r: function(a, b, c) {\n              return pc(async () => {\n                await B.xb(a, b, c);\n              });\n            },\n            b: function(a, b, c) {\n              a >>>= 0;\n              new Za(a).gb(b >>> 0, c >>> 0);\n              $a = a;\n              ab++;\n              throw $a;\n            },\n            O: function(a) {\n              rc(a >>> 0, !F, 1, !ka, 131072, false);\n              W.lb();\n            },\n            l: function(a) {\n              a >>>= 0;\n              H ? postMessage({ cmd: \"cleanupThread\", thread: a }) : Ka(a);\n            },\n            I: cb,\n            i: db,\n            U: eb,\n            E: ib,\n            G: jb,\n            V: kb,\n            S: lb,\n            K: mb,\n            R: nb,\n            p: ob,\n            F: pb,\n            C: qb,\n            T: rb,\n            D: sb,\n            q: () => true,\n            A: function(a, b) {\n              a >>>= 0;\n              a == b >>> 0 ? setTimeout(() => Ta()) : H ? postMessage({\n                targetThread: a,\n                cmd: \"checkMailbox\"\n              }) : (a = W.Qa[a]) && a.postMessage({ cmd: \"checkMailbox\" });\n            },\n            M: function() {\n              return -1;\n            },\n            N: ub,\n            X: function(a) {\n              G && W.Qa[a >>> 0].ref();\n            },\n            u: function(a, b, c) {\n              a = b + 2097152 >>> 0 < 4194305 - !!a ? (a >>> 0) + 4294967296 * b : NaN;\n              c >>>= 0;\n              a = new Date(1e3 * a);\n              z()[c >> 2 >>> 0] = a.getUTCSeconds();\n              z()[c + 4 >> 2 >>> 0] = a.getUTCMinutes();\n              z()[c + 8 >> 2 >>> 0] = a.getUTCHours();\n              z()[c + 12 >> 2 >>> 0] = a.getUTCDate();\n              z()[c + 16 >> 2 >>> 0] = a.getUTCMonth();\n              z()[c + 20 >> 2 >>> 0] = a.getUTCFullYear() - 1900;\n              z()[c + 24 >> 2 >>> 0] = a.getUTCDay();\n              a = (a.getTime() - Date.UTC(\n                a.getUTCFullYear(),\n                0,\n                1,\n                0,\n                0,\n                0,\n                0\n              )) / 864e5 | 0;\n              z()[c + 28 >> 2 >>> 0] = a;\n            },\n            v: function(a, b, c) {\n              a = b + 2097152 >>> 0 < 4194305 - !!a ? (a >>> 0) + 4294967296 * b : NaN;\n              c >>>= 0;\n              a = new Date(1e3 * a);\n              z()[c >> 2 >>> 0] = a.getSeconds();\n              z()[c + 4 >> 2 >>> 0] = a.getMinutes();\n              z()[c + 8 >> 2 >>> 0] = a.getHours();\n              z()[c + 12 >> 2 >>> 0] = a.getDate();\n              z()[c + 16 >> 2 >>> 0] = a.getMonth();\n              z()[c + 20 >> 2 >>> 0] = a.getFullYear() - 1900;\n              z()[c + 24 >> 2 >>> 0] = a.getDay();\n              b = (Y(a.getFullYear()) ? wb : xb)[a.getMonth()] + a.getDate() - 1 | 0;\n              z()[c + 28 >> 2 >>> 0] = b;\n              z()[c + 36 >> 2 >>> 0] = -(60 * a.getTimezoneOffset());\n              b = new Date(\n                a.getFullYear(),\n                6,\n                1\n              ).getTimezoneOffset();\n              var e = new Date(a.getFullYear(), 0, 1).getTimezoneOffset();\n              a = (b != e && a.getTimezoneOffset() == Math.min(e, b)) | 0;\n              z()[c + 32 >> 2 >>> 0] = a;\n            },\n            w: function(a) {\n              a >>>= 0;\n              var b = new Date(z()[a + 20 >> 2 >>> 0] + 1900, z()[a + 16 >> 2 >>> 0], z()[a + 12 >> 2 >>> 0], z()[a + 8 >> 2 >>> 0], z()[a + 4 >> 2 >>> 0], z()[a >> 2 >>> 0], 0), c = z()[a + 32 >> 2 >>> 0], e = b.getTimezoneOffset(), f = new Date(b.getFullYear(), 6, 1).getTimezoneOffset(), h = new Date(b.getFullYear(), 0, 1).getTimezoneOffset(), k = Math.min(h, f);\n              0 > c ? z()[a + 32 >> 2 >>> 0] = Number(f != h && k == e) : 0 < c != (k == e) && (f = Math.max(h, f), b.setTime(b.getTime() + 6e4 * ((0 < c ? k : f) - e)));\n              z()[a + 24 >> 2 >>> 0] = b.getDay();\n              c = (Y(b.getFullYear()) ? wb : xb)[b.getMonth()] + b.getDate() - 1 | 0;\n              z()[a + 28 >> 2 >>> 0] = c;\n              z()[a >> 2 >>> 0] = b.getSeconds();\n              z()[a + 4 >> 2 >>> 0] = b.getMinutes();\n              z()[a + 8 >> 2 >>> 0] = b.getHours();\n              z()[a + 12 >> 2 >>> 0] = b.getDate();\n              z()[a + 16 >> 2 >>> 0] = b.getMonth();\n              z()[a + 20 >> 2 >>> 0] = b.getYear();\n              a = b.getTime() / 1e3;\n              return sc((U = a, 1 <= +Math.abs(U) ? 0 < U ? +Math.floor(U / 4294967296) >>> 0 : ~~+Math.ceil((U - +(~~U >>> 0)) / 4294967296) >>> 0 : 0)), a >>> 0;\n            },\n            s: yb,\n            t: zb,\n            z: function(a, b, c) {\n              function e(m) {\n                return (m = m.toTimeString().match(/\\(([A-Za-z ]+)\\)$/)) ? m[1] : \"GMT\";\n              }\n              a >>>= 0;\n              b >>>= 0;\n              c >>>= 0;\n              var f = (/* @__PURE__ */ new Date()).getFullYear(), h = new Date(f, 0, 1), k = new Date(f, 6, 1);\n              f = h.getTimezoneOffset();\n              var q = k.getTimezoneOffset(), n = Math.max(f, q);\n              A()[a >> 2 >>> 0] = 60 * n;\n              z()[b >> 2 >>> 0] = Number(f != q);\n              a = e(h);\n              b = e(k);\n              a = Bb(a);\n              b = Bb(b);\n              q < f ? (A()[c >> 2 >>> 0] = a, A()[c + 4 >> 2 >>> 0] = b) : (A()[c >> 2 >>> 0] = b, A()[c + 4 >> 2 >>> 0] = a);\n            },\n            d: () => {\n              M(\"\");\n            },\n            c: function(a, b, c) {\n              a >>>= 0;\n              b = Db(b >>> 0, c >>> 0);\n              return Ha[a].apply(null, b);\n            },\n            k: function(a, b, c) {\n              a >>>= 0;\n              b = Db(b >>> 0, c >>> 0);\n              return Ha[a].apply(null, b);\n            },\n            m: function() {\n            },\n            j: function() {\n              return Date.now();\n            },\n            W: () => {\n              xa += 1;\n              throw \"unwind\";\n            },\n            B: function() {\n              return 4294901760;\n            },\n            f: () => performance.timeOrigin + performance.now(),\n            g: function() {\n              return G ? (init_os(), __toCommonJS(os_exports)).cpus().length : navigator.hardwareConcurrency;\n            },\n            L: function(a, b, c, e) {\n              W.Pb = b >>> 0;\n              Ib.length = c;\n              b = e >>> 0 >> 3;\n              for (e = 0; e < c; e++)\n                Ib[e] = da()[b + e >>> 0];\n              return (0 > a ? Ha[-a - 1] : qc[a]).apply(null, Ib);\n            },\n            y: function(a) {\n              a >>>= 0;\n              var b = v().length;\n              if (a <= b || 4294901760 < a)\n                return false;\n              for (var c = 1; 4 >= c; c *= 2) {\n                var e = b * (1 + 0.2 / c);\n                e = Math.min(e, a + 100663296);\n                var f = Math;\n                e = Math.max(a, e);\n                a: {\n                  f = f.min.call(f, 4294901760, e + (65536 - e % 65536) % 65536) - l.buffer.byteLength + 65535 >>> 16;\n                  try {\n                    l.grow(f);\n                    t();\n                    var h = 1;\n                    break a;\n                  } catch (k) {\n                  }\n                  h = void 0;\n                }\n                if (h)\n                  return true;\n              }\n              return false;\n            },\n            P: Mb,\n            Q: Nb,\n            H: Qa,\n            h: Ob,\n            o: Pb,\n            x: Qb,\n            n: Tb,\n            a: l || B.wasmMemory,\n            J: Yb,\n            e: function(a, b, c, e) {\n              return Yb(a >>> 0, b >>> 0, c >>> 0, e >>> 0);\n            }\n          };\n          (function() {\n            function a(c, e) {\n              c = c.exports;\n              c = $b(c);\n              N = c = uc(c);\n              W.mb.push(N.Da);\n              va.unshift(N.Y);\n              sa = e;\n              Ba();\n              return c;\n            }\n            var b = { a: tc };\n            Aa();\n            if (B.instantiateWasm)\n              try {\n                return B.instantiateWasm(b, a);\n              } catch (c) {\n                K(\"Module.instantiateWasm callback failed with error: \" + c), C(c);\n              }\n            Ga(b, function(c) {\n              a(c.instance, c.module);\n            }).catch(C);\n            return {};\n          })();\n          B._OrtInit = (a, b) => (B._OrtInit = N.Z)(a, b);\n          B._OrtGetLastError = (a, b) => (B._OrtGetLastError = N._)(a, b);\n          B._OrtCreateSessionOptions = (a, b, c, e, f, h, k, q, n, m) => (B._OrtCreateSessionOptions = N.$)(a, b, c, e, f, h, k, q, n, m);\n          B._OrtAppendExecutionProvider = (a, b) => (B._OrtAppendExecutionProvider = N.aa)(a, b);\n          B._OrtAddFreeDimensionOverride = (a, b, c) => (B._OrtAddFreeDimensionOverride = N.ba)(a, b, c);\n          B._OrtAddSessionConfigEntry = (a, b, c) => (B._OrtAddSessionConfigEntry = N.ca)(a, b, c);\n          B._OrtReleaseSessionOptions = (a) => (B._OrtReleaseSessionOptions = N.da)(a);\n          B._OrtCreateSession = (a, b, c) => (B._OrtCreateSession = N.ea)(a, b, c);\n          B._OrtReleaseSession = (a) => (B._OrtReleaseSession = N.fa)(a);\n          B._OrtGetInputOutputCount = (a, b, c) => (B._OrtGetInputOutputCount = N.ga)(a, b, c);\n          B._OrtGetInputName = (a, b) => (B._OrtGetInputName = N.ha)(a, b);\n          B._OrtGetOutputName = (a, b) => (B._OrtGetOutputName = N.ia)(a, b);\n          B._OrtFree = (a) => (B._OrtFree = N.ja)(a);\n          B._OrtCreateTensor = (a, b, c, e, f, h) => (B._OrtCreateTensor = N.ka)(a, b, c, e, f, h);\n          B._OrtGetTensorData = (a, b, c, e, f) => (B._OrtGetTensorData = N.la)(a, b, c, e, f);\n          B._OrtReleaseTensor = (a) => (B._OrtReleaseTensor = N.ma)(a);\n          B._OrtCreateRunOptions = (a, b, c, e) => (B._OrtCreateRunOptions = N.na)(a, b, c, e);\n          B._OrtAddRunConfigEntry = (a, b, c) => (B._OrtAddRunConfigEntry = N.oa)(a, b, c);\n          B._OrtReleaseRunOptions = (a) => (B._OrtReleaseRunOptions = N.pa)(a);\n          B._OrtCreateBinding = (a) => (B._OrtCreateBinding = N.qa)(a);\n          B._OrtBindInput = (a, b, c) => (B._OrtBindInput = N.ra)(a, b, c);\n          B._OrtBindOutput = (a, b, c, e) => (B._OrtBindOutput = N.sa)(a, b, c, e);\n          B._OrtClearBoundOutputs = (a) => (B._OrtClearBoundOutputs = N.ta)(a);\n          B._OrtReleaseBinding = (a) => (B._OrtReleaseBinding = N.ua)(a);\n          B._OrtRunWithBinding = (a, b, c, e, f) => (B._OrtRunWithBinding = N.va)(a, b, c, e, f);\n          B._OrtRun = (a, b, c, e, f, h, k, q) => (B._OrtRun = N.wa)(a, b, c, e, f, h, k, q);\n          B._OrtEndProfiling = (a) => (B._OrtEndProfiling = N.xa)(a);\n          B._JsepOutput = (a, b, c) => (B._JsepOutput = N.ya)(a, b, c);\n          B._JsepGetNodeName = (a) => (B._JsepGetNodeName = N.za)(a);\n          var Sa = B._pthread_self = () => (Sa = B._pthread_self = N.Aa)(), Ab = B._malloc = (a) => (Ab = B._malloc = N.Ba)(a), oc = B._free = (a) => (oc = B._free = N.Ca)(a);\n          B.__emscripten_tls_init = () => (B.__emscripten_tls_init = N.Da)();\n          var rc = B.__emscripten_thread_init = (a, b, c, e, f, h) => (rc = B.__emscripten_thread_init = N.Fa)(a, b, c, e, f, h);\n          B.__emscripten_thread_crashed = () => (B.__emscripten_thread_crashed = N.Ga)();\n          var Hb = (a, b, c, e) => (Hb = N.Ha)(a, b, c, e), Ra = (a) => (Ra = N.Ia)(a), Ya = B.__emscripten_thread_exit = (a) => (Ya = B.__emscripten_thread_exit = N.Ja)(a), vb = B.__emscripten_check_mailbox = () => (vb = B.__emscripten_check_mailbox = N.Ka)(), sc = (a) => (sc = N.La)(a), Va = (a, b) => (Va = N.Ma)(a, b), Eb = () => (Eb = N.Na)(), Wa = (a) => (Wa = N.Oa)(a), Gb = (a) => (Gb = N.Pa)(a), Xa = B.dynCall_ii = (a, b) => (Xa = B.dynCall_ii = N.Ra)(a, b), mc = (a) => (mc = N.Sa)(a), bc = () => (bc = N.Ta)(), lc = (a) => (lc = N.Ua)(a), nc = () => (nc = N.Va)();\n          B.___start_em_js = 917678;\n          B.___stop_em_js = 917839;\n          function uc(a) {\n            a = Object.assign({}, a);\n            var b = (e) => () => e() >>> 0, c = (e) => (f) => e(f) >>> 0;\n            a.__errno_location = b(a.__errno_location);\n            a.pthread_self = b(a.pthread_self);\n            a.malloc = c(a.malloc);\n            a.stackSave = b(a.stackSave);\n            a.stackAlloc = c(a.stackAlloc);\n            return a;\n          }\n          B.keepRuntimeAlive = ya;\n          B.wasmMemory = l;\n          B.stackAlloc = Gb;\n          B.stackSave = Eb;\n          B.stackRestore = Wa;\n          B.UTF8ToString = V;\n          B.stringToUTF8 = hb;\n          B.lengthBytesUTF8 = fb;\n          B.ExitStatus = Ia;\n          B.PThread = W;\n          var vc;\n          S = function wc() {\n            vc || xc();\n            vc || (S = wc);\n          };\n          function xc() {\n            function a() {\n              if (!vc && (vc = true, B.calledRun = true, !P)) {\n                H || Ua(va);\n                fa(B);\n                if (B.onRuntimeInitialized)\n                  B.onRuntimeInitialized();\n                if (!H) {\n                  if (B.postRun)\n                    for (\"function\" == typeof B.postRun && (B.postRun = [B.postRun]); B.postRun.length; ) {\n                      var b = B.postRun.shift();\n                      wa.unshift(b);\n                    }\n                  Ua(wa);\n                }\n              }\n            }\n            if (!(0 < R))\n              if (H)\n                fa(B), H || Ua(va), startWorker(B);\n              else {\n                if (B.preRun)\n                  for (\"function\" == typeof B.preRun && (B.preRun = [B.preRun]); B.preRun.length; )\n                    ua.unshift(B.preRun.shift());\n                Ua(ua);\n                0 < R || (B.setStatus ? (B.setStatus(\"Running...\"), setTimeout(function() {\n                  setTimeout(\n                    function() {\n                      B.setStatus(\"\");\n                    },\n                    1\n                  );\n                  a();\n                }, 1)) : a());\n              }\n          }\n          if (B.preInit)\n            for (\"function\" == typeof B.preInit && (B.preInit = [B.preInit]); 0 < B.preInit.length; )\n              B.preInit.pop()();\n          xc();\n          return moduleArg.ready;\n        };\n      })();\n      if (typeof exports === \"object\" && typeof module === \"object\")\n        module.exports = ortWasmThreaded;\n      else if (typeof define === \"function\" && define[\"amd\"])\n        define([], () => ortWasmThreaded);\n    }\n  });\n\n  // web/lib/wasm/binding/ort-wasm-threaded.worker.js\n  var require_ort_wasm_threaded_worker = __commonJS({\n    \"web/lib/wasm/binding/ort-wasm-threaded.worker.js\"(exports, module) {\n      module.exports = '\"use strict\";var Module={};var ENVIRONMENT_IS_NODE=typeof process==\"object\"&&typeof process.versions==\"object\"&&typeof process.versions.node==\"string\";if(ENVIRONMENT_IS_NODE){var nodeWorkerThreads=require(\"worker_threads\");var parentPort=nodeWorkerThreads.parentPort;parentPort.on(\"message\",data=>onmessage({data:data}));var fs=require(\"fs\");Object.assign(global,{self:global,require:require,Module:Module,location:{href:__filename},Worker:nodeWorkerThreads.Worker,importScripts:f=>(0,eval)(fs.readFileSync(f,\"utf8\")+\"//# sourceURL=\"+f),postMessage:msg=>parentPort.postMessage(msg),performance:global.performance||{now:Date.now}})}var initializedJS=false;function threadPrintErr(){var text=Array.prototype.slice.call(arguments).join(\" \");if(ENVIRONMENT_IS_NODE){fs.writeSync(2,text+\"\\\\n\");return}console.error(text)}function threadAlert(){var text=Array.prototype.slice.call(arguments).join(\" \");postMessage({cmd:\"alert\",text:text,threadId:Module[\"_pthread_self\"]()})}var err=threadPrintErr;self.alert=threadAlert;Module[\"instantiateWasm\"]=(info,receiveInstance)=>{var module=Module[\"wasmModule\"];Module[\"wasmModule\"]=null;var instance=new WebAssembly.Instance(module,info);return receiveInstance(instance)};self.onunhandledrejection=e=>{throw e.reason??e};function handleMessage(e){try{if(e.data.cmd===\"load\"){let messageQueue=[];self.onmessage=e=>messageQueue.push(e);self.startWorker=instance=>{Module=instance;postMessage({\"cmd\":\"loaded\"});for(let msg of messageQueue){handleMessage(msg)}self.onmessage=handleMessage};Module[\"wasmModule\"]=e.data.wasmModule;for(const handler of e.data.handlers){Module[handler]=(...args)=>{postMessage({cmd:\"callHandler\",handler:handler,args:args})}}Module[\"wasmMemory\"]=e.data.wasmMemory;Module[\"buffer\"]=Module[\"wasmMemory\"].buffer;Module[\"ENVIRONMENT_IS_PTHREAD\"]=true;if(typeof e.data.urlOrBlob==\"string\"){importScripts(e.data.urlOrBlob)}else{var objectUrl=URL.createObjectURL(e.data.urlOrBlob);importScripts(objectUrl);URL.revokeObjectURL(objectUrl)}ortWasmThreaded(Module)}else if(e.data.cmd===\"run\"){Module[\"__emscripten_thread_init\"](e.data.pthread_ptr,/*isMainBrowserThread=*/0,/*isMainRuntimeThread=*/0,/*canBlock=*/1);Module[\"__emscripten_thread_mailbox_await\"](e.data.pthread_ptr);Module[\"establishStackSpace\"]();Module[\"PThread\"].receiveObjectTransfer(e.data);Module[\"PThread\"].threadInitTLS();if(!initializedJS){initializedJS=true}try{Module[\"invokeEntryPoint\"](e.data.start_routine,e.data.arg)}catch(ex){if(ex!=\"unwind\"){throw ex}}}else if(e.data.cmd===\"cancel\"){if(Module[\"_pthread_self\"]()){Module[\"__emscripten_thread_exit\"](-1)}}else if(e.data.target===\"setimmediate\"){}else if(e.data.cmd===\"checkMailbox\"){if(initializedJS){Module[\"checkMailbox\"]()}}else if(e.data.cmd){err(\"worker.js received unknown command \"+e.data.cmd);err(e.data)}}catch(ex){if(Module[\"__emscripten_thread_crashed\"]){Module[\"__emscripten_thread_crashed\"]()}throw ex}}self.onmessage=handleMessage;\\n';\n    }\n  });\n\n  // web/lib/wasm/wasm-common.ts\n  var tensorDataTypeStringToEnum, tensorDataTypeEnumToString, getTensorElementSize, tensorTypeToTypedArrayConstructor, logLevelStringToEnum, isGpuBufferSupportedType, dataLocationStringToEnum;\n  var init_wasm_common = __esm({\n    \"web/lib/wasm/wasm-common.ts\"() {\n      \"use strict\";\n      tensorDataTypeStringToEnum = (type) => {\n        switch (type) {\n          case \"int8\":\n            return 3 /* int8 */;\n          case \"uint8\":\n            return 2 /* uint8 */;\n          case \"bool\":\n            return 9 /* bool */;\n          case \"int16\":\n            return 5 /* int16 */;\n          case \"uint16\":\n            return 4 /* uint16 */;\n          case \"int32\":\n            return 6 /* int32 */;\n          case \"uint32\":\n            return 12 /* uint32 */;\n          case \"float16\":\n            return 10 /* float16 */;\n          case \"float32\":\n            return 1 /* float */;\n          case \"float64\":\n            return 11 /* double */;\n          case \"string\":\n            return 8 /* string */;\n          case \"int64\":\n            return 7 /* int64 */;\n          case \"uint64\":\n            return 13 /* uint64 */;\n          default:\n            throw new Error(`unsupported data type: ${type}`);\n        }\n      };\n      tensorDataTypeEnumToString = (typeProto) => {\n        switch (typeProto) {\n          case 3 /* int8 */:\n            return \"int8\";\n          case 2 /* uint8 */:\n            return \"uint8\";\n          case 9 /* bool */:\n            return \"bool\";\n          case 5 /* int16 */:\n            return \"int16\";\n          case 4 /* uint16 */:\n            return \"uint16\";\n          case 6 /* int32 */:\n            return \"int32\";\n          case 12 /* uint32 */:\n            return \"uint32\";\n          case 10 /* float16 */:\n            return \"float16\";\n          case 1 /* float */:\n            return \"float32\";\n          case 11 /* double */:\n            return \"float64\";\n          case 8 /* string */:\n            return \"string\";\n          case 7 /* int64 */:\n            return \"int64\";\n          case 13 /* uint64 */:\n            return \"uint64\";\n          default:\n            throw new Error(`unsupported data type: ${typeProto}`);\n        }\n      };\n      getTensorElementSize = (dateType) => [void 0, 4, 1, 1, 2, 2, 4, 8, void 0, 1, 2, 8, 4, 8, void 0, void 0, void 0][dateType];\n      tensorTypeToTypedArrayConstructor = (type) => {\n        switch (type) {\n          case \"float16\":\n            return typeof Float16Array !== \"undefined\" && Float16Array.from ? Float16Array : Uint16Array;\n          case \"float32\":\n            return Float32Array;\n          case \"uint8\":\n            return Uint8Array;\n          case \"int8\":\n            return Int8Array;\n          case \"uint16\":\n            return Uint16Array;\n          case \"int16\":\n            return Int16Array;\n          case \"int32\":\n            return Int32Array;\n          case \"bool\":\n            return Uint8Array;\n          case \"float64\":\n            return Float64Array;\n          case \"uint32\":\n            return Uint32Array;\n          case \"int64\":\n            return BigInt64Array;\n          case \"uint64\":\n            return BigUint64Array;\n          default:\n            throw new Error(`unsupported type: ${type}`);\n        }\n      };\n      logLevelStringToEnum = (logLevel) => {\n        switch (logLevel) {\n          case \"verbose\":\n            return 0;\n          case \"info\":\n            return 1;\n          case \"warning\":\n            return 2;\n          case \"error\":\n            return 3;\n          case \"fatal\":\n            return 4;\n          default:\n            throw new Error(`unsupported logging level: ${logLevel}`);\n        }\n      };\n      isGpuBufferSupportedType = (type) => type === \"float32\" || type === \"float16\" || type === \"int32\" || type === \"int64\" || type === \"uint32\" || type === \"uint8\" || type === \"bool\";\n      dataLocationStringToEnum = (location) => {\n        switch (location) {\n          case \"none\":\n            return 0;\n          case \"cpu\":\n            return 1;\n          case \"cpu-pinned\":\n            return 2;\n          case \"texture\":\n            return 3;\n          case \"gpu-buffer\":\n            return 4;\n          default:\n            throw new Error(`unsupported data location: ${location}`);\n        }\n      };\n    }\n  });\n\n  // common/dist/esm/backend-impl.js\n  var init_backend_impl = __esm({\n    \"common/dist/esm/backend-impl.js\"() {\n      \"use strict\";\n    }\n  });\n\n  // common/dist/esm/backend.js\n  var init_backend = __esm({\n    \"common/dist/esm/backend.js\"() {\n      \"use strict\";\n      init_backend_impl();\n    }\n  });\n\n  // common/dist/esm/version.js\n  var version;\n  var init_version = __esm({\n    \"common/dist/esm/version.js\"() {\n      \"use strict\";\n      version = \"1.18.0\";\n    }\n  });\n\n  // common/dist/esm/env-impl.js\n  var logLevelValue, env;\n  var init_env_impl = __esm({\n    \"common/dist/esm/env-impl.js\"() {\n      \"use strict\";\n      init_version();\n      logLevelValue = \"warning\";\n      env = {\n        wasm: {},\n        webgl: {},\n        webgpu: {},\n        versions: { common: version },\n        set logLevel(value) {\n          if (value === void 0) {\n            return;\n          }\n          if (typeof value !== \"string\" || [\"verbose\", \"info\", \"warning\", \"error\", \"fatal\"].indexOf(value) === -1) {\n            throw new Error(`Unsupported logging level: ${value}`);\n          }\n          logLevelValue = value;\n        },\n        get logLevel() {\n          return logLevelValue;\n        }\n      };\n      Object.defineProperty(env, \"logLevel\", { enumerable: true });\n    }\n  });\n\n  // common/dist/esm/env.js\n  var env2;\n  var init_env = __esm({\n    \"common/dist/esm/env.js\"() {\n      \"use strict\";\n      init_env_impl();\n      env2 = env;\n    }\n  });\n\n  // common/dist/esm/tensor-conversion-impl.js\n  var init_tensor_conversion_impl = __esm({\n    \"common/dist/esm/tensor-conversion-impl.js\"() {\n      \"use strict\";\n    }\n  });\n\n  // common/dist/esm/tensor-factory-impl.js\n  var init_tensor_factory_impl = __esm({\n    \"common/dist/esm/tensor-factory-impl.js\"() {\n      \"use strict\";\n      init_tensor_impl();\n    }\n  });\n\n  // common/dist/esm/tensor-impl-type-mapping.js\n  var init_tensor_impl_type_mapping = __esm({\n    \"common/dist/esm/tensor-impl-type-mapping.js\"() {\n      \"use strict\";\n    }\n  });\n\n  // common/dist/esm/tensor-utils-impl.js\n  var init_tensor_utils_impl = __esm({\n    \"common/dist/esm/tensor-utils-impl.js\"() {\n      \"use strict\";\n      init_tensor_impl();\n    }\n  });\n\n  // common/dist/esm/tensor-impl.js\n  var init_tensor_impl = __esm({\n    \"common/dist/esm/tensor-impl.js\"() {\n      \"use strict\";\n      init_tensor_conversion_impl();\n      init_tensor_factory_impl();\n      init_tensor_impl_type_mapping();\n      init_tensor_utils_impl();\n    }\n  });\n\n  // common/dist/esm/tensor.js\n  var init_tensor = __esm({\n    \"common/dist/esm/tensor.js\"() {\n      \"use strict\";\n      init_tensor_impl();\n    }\n  });\n\n  // common/dist/esm/trace.js\n  var TRACE, TRACE_FUNC, TRACE_FUNC_BEGIN, TRACE_FUNC_END;\n  var init_trace = __esm({\n    \"common/dist/esm/trace.js\"() {\n      \"use strict\";\n      init_env_impl();\n      TRACE = (deviceType, label) => {\n        if (typeof env.trace === \"undefined\" ? !env.wasm.trace : !env.trace) {\n          return;\n        }\n        console.timeStamp(`${deviceType}::ORT::${label}`);\n      };\n      TRACE_FUNC = (msg, extraMsg) => {\n        const stack = new Error().stack?.split(/\\r\\n|\\r|\\n/g) || [];\n        let hasTraceFunc = false;\n        for (let i = 0; i < stack.length; i++) {\n          if (hasTraceFunc && !stack[i].includes(\"TRACE_FUNC\")) {\n            let label = `FUNC_${msg}::${stack[i].trim().split(\" \")[1]}`;\n            if (extraMsg) {\n              label += `::${extraMsg}`;\n            }\n            TRACE(\"CPU\", label);\n            return;\n          }\n          if (stack[i].includes(\"TRACE_FUNC\")) {\n            hasTraceFunc = true;\n          }\n        }\n      };\n      TRACE_FUNC_BEGIN = (extraMsg) => {\n        if (typeof env.trace === \"undefined\" ? !env.wasm.trace : !env.trace) {\n          return;\n        }\n        TRACE_FUNC(\"BEGIN\", extraMsg);\n      };\n      TRACE_FUNC_END = (extraMsg) => {\n        if (typeof env.trace === \"undefined\" ? !env.wasm.trace : !env.trace) {\n          return;\n        }\n        TRACE_FUNC(\"END\", extraMsg);\n      };\n    }\n  });\n\n  // common/dist/esm/inference-session-impl.js\n  var init_inference_session_impl = __esm({\n    \"common/dist/esm/inference-session-impl.js\"() {\n      \"use strict\";\n      init_backend_impl();\n      init_tensor();\n      init_trace();\n    }\n  });\n\n  // common/dist/esm/inference-session.js\n  var init_inference_session = __esm({\n    \"common/dist/esm/inference-session.js\"() {\n      \"use strict\";\n      init_inference_session_impl();\n    }\n  });\n\n  // common/dist/esm/tensor-conversion.js\n  var init_tensor_conversion = __esm({\n    \"common/dist/esm/tensor-conversion.js\"() {\n      \"use strict\";\n    }\n  });\n\n  // common/dist/esm/tensor-factory.js\n  var init_tensor_factory = __esm({\n    \"common/dist/esm/tensor-factory.js\"() {\n      \"use strict\";\n    }\n  });\n\n  // common/dist/esm/onnx-model.js\n  var init_onnx_model = __esm({\n    \"common/dist/esm/onnx-model.js\"() {\n      \"use strict\";\n    }\n  });\n\n  // common/dist/esm/onnx-value.js\n  var init_onnx_value = __esm({\n    \"common/dist/esm/onnx-value.js\"() {\n      \"use strict\";\n    }\n  });\n\n  // common/dist/esm/training-session-impl.js\n  var init_training_session_impl = __esm({\n    \"common/dist/esm/training-session-impl.js\"() {\n      \"use strict\";\n      init_backend_impl();\n      init_tensor();\n    }\n  });\n\n  // common/dist/esm/training-session.js\n  var init_training_session = __esm({\n    \"common/dist/esm/training-session.js\"() {\n      \"use strict\";\n      init_training_session_impl();\n    }\n  });\n\n  // common/dist/esm/index.js\n  var init_esm = __esm({\n    \"common/dist/esm/index.js\"() {\n      \"use strict\";\n      init_backend();\n      init_env();\n      init_inference_session();\n      init_tensor();\n      init_tensor_conversion();\n      init_tensor_factory();\n      init_trace();\n      init_onnx_model();\n      init_onnx_value();\n      init_training_session();\n    }\n  });\n\n  // web/lib/wasm/jsep/log.ts\n  var logLevelPrefix, doLog, configLogLevel, debug, configureLogger, LOG, LOG_DEBUG;\n  var init_log = __esm({\n    \"web/lib/wasm/jsep/log.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      logLevelPrefix = [\"V\", \"I\", \"W\", \"E\", \"F\"];\n      doLog = (level, message) => {\n        console.log(`[${logLevelPrefix[level]},${(/* @__PURE__ */ new Date()).toISOString()}]${message}`);\n      };\n      configureLogger = ($configLogLevel, $debug) => {\n        configLogLevel = $configLogLevel;\n        debug = $debug;\n      };\n      LOG = (logLevel, msg) => {\n        const messageLevel = logLevelStringToEnum(logLevel);\n        const configLevel = logLevelStringToEnum(configLogLevel);\n        if (messageLevel >= configLevel) {\n          doLog(messageLevel, typeof msg === \"function\" ? msg() : msg);\n        }\n      };\n      LOG_DEBUG = (...args) => {\n        if (debug) {\n          LOG(...args);\n        }\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/tensor-view.ts\n  var createView;\n  var init_tensor_view = __esm({\n    \"web/lib/wasm/jsep/tensor-view.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      createView = (dataBuffer, type) => new (tensorTypeToTypedArrayConstructor(type))(dataBuffer);\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/types.ts\n  var init_types = __esm({\n    \"web/lib/wasm/jsep/webgpu/types.ts\"() {\n      \"use strict\";\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/gpu-data-manager.ts\n  var bucketFreelist, bucketArr, calcNormalizedBufferSize, calcBucketBufferSize, guid, createNewGpuDataId, downloadGpuData, GpuDataManagerImpl, createGpuDataManager;\n  var init_gpu_data_manager = __esm({\n    \"web/lib/wasm/jsep/webgpu/gpu-data-manager.ts\"() {\n      \"use strict\";\n      init_log();\n      init_types();\n      bucketFreelist = /* @__PURE__ */ new Map([\n        [64, 250],\n        [128, 200],\n        [256, 200],\n        [512, 200],\n        [2048, 230],\n        [4096, 200],\n        [8192, 50],\n        [16384, 50],\n        [32768, 50],\n        [65536, 50],\n        [131072, 50],\n        [262144, 50],\n        [524288, 50],\n        [1048576, 50],\n        [2097152, 30],\n        [4194304, 20],\n        [8388608, 10],\n        [12582912, 10],\n        [16777216, 10],\n        [26214400, 15],\n        [33554432, 22],\n        [44236800, 2],\n        [58982400, 6],\n        // we don't want to cache the bucket sizes below but not caching them\n        // results in some major performance hits for models like sd-turbo.\n        [67108864, 6],\n        [134217728, 6],\n        [167772160, 6]\n      ]);\n      bucketArr = [];\n      calcNormalizedBufferSize = (size) => Math.ceil(size / 16) * 16;\n      calcBucketBufferSize = (size) => {\n        for (let idx = 0; idx < bucketArr.length; idx++) {\n          const sizeForBucket = bucketArr[idx];\n          if (size <= sizeForBucket) {\n            return sizeForBucket;\n          }\n        }\n        return Math.ceil(size / 16) * 16;\n      };\n      guid = 1;\n      createNewGpuDataId = () => guid++;\n      downloadGpuData = async (backend, gpuBuffer, originalSize, getTargetBuffer) => {\n        const bufferSize = calcNormalizedBufferSize(originalSize);\n        const gpuReadBuffer = backend.device.createBuffer(\n          // eslint-disable-next-line no-bitwise\n          { size: bufferSize, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ }\n        );\n        try {\n          const commandEncoder = backend.getCommandEncoder();\n          backend.endComputePass();\n          commandEncoder.copyBufferToBuffer(\n            gpuBuffer,\n            0,\n            gpuReadBuffer,\n            0,\n            bufferSize\n            /* size */\n          );\n          backend.flush();\n          await gpuReadBuffer.mapAsync(GPUMapMode.READ);\n          const arrayBuffer = gpuReadBuffer.getMappedRange();\n          if (getTargetBuffer) {\n            const targetBuffer = getTargetBuffer();\n            targetBuffer.set(new Uint8Array(arrayBuffer, 0, originalSize));\n            return targetBuffer;\n          } else {\n            return new Uint8Array(arrayBuffer.slice(0, originalSize));\n          }\n        } finally {\n          gpuReadBuffer.destroy();\n        }\n      };\n      GpuDataManagerImpl = class {\n        constructor(backend) {\n          this.backend = backend;\n          this.storageCache = /* @__PURE__ */ new Map();\n          this.freeBuffers = /* @__PURE__ */ new Map();\n          this.freeUniformBuffers = /* @__PURE__ */ new Map();\n          this.buffersForUploadingPending = [];\n          this.buffersPending = [];\n          this.externalBuffers = /* @__PURE__ */ new Map();\n          this.capturedPendingBuffers = /* @__PURE__ */ new Map();\n          for (const [key] of bucketFreelist) {\n            bucketArr.push(key);\n            this.freeBuffers.set(key, []);\n            this.freeUniformBuffers.set(key, []);\n          }\n        }\n        upload(id, data) {\n          const srcArrayBuffer = data.buffer;\n          const srcOffset = data.byteOffset;\n          const srcLength = data.byteLength;\n          const size = calcNormalizedBufferSize(srcLength);\n          const gpuDataCache = this.storageCache.get(id);\n          if (!gpuDataCache) {\n            throw new Error(\"gpu data for uploading does not exist\");\n          }\n          if (gpuDataCache.originalSize !== srcLength) {\n            throw new Error(`inconsistent data size. gpu data size=${gpuDataCache.originalSize}, data size=${srcLength}`);\n          }\n          const gpuBufferForUploading = this.backend.device.createBuffer(\n            // eslint-disable-next-line no-bitwise\n            { mappedAtCreation: true, size, usage: GPUBufferUsage.MAP_WRITE | GPUBufferUsage.COPY_SRC }\n          );\n          const arrayBuffer = gpuBufferForUploading.getMappedRange();\n          new Uint8Array(arrayBuffer).set(new Uint8Array(srcArrayBuffer, srcOffset, srcLength));\n          gpuBufferForUploading.unmap();\n          const commandEncoder = this.backend.getCommandEncoder();\n          this.backend.endComputePass();\n          commandEncoder.copyBufferToBuffer(gpuBufferForUploading, 0, gpuDataCache.gpuData.buffer, 0, size);\n          LOG_DEBUG(\"verbose\", () => `[WebGPU] GpuDataManager.upload(id=${id})`);\n          this.buffersForUploadingPending.push(gpuBufferForUploading);\n        }\n        memcpy(sourceId, destinationId) {\n          const sourceGpuDataCache = this.storageCache.get(sourceId);\n          if (!sourceGpuDataCache) {\n            throw new Error(\"source gpu data for memcpy does not exist\");\n          }\n          const destinationGpuDataCache = this.storageCache.get(destinationId);\n          if (!destinationGpuDataCache) {\n            throw new Error(\"destination gpu data for memcpy does not exist\");\n          }\n          if (sourceGpuDataCache.originalSize !== destinationGpuDataCache.originalSize) {\n            throw new Error(\"inconsistent source and destination gpu data size\");\n          }\n          const size = calcNormalizedBufferSize(sourceGpuDataCache.originalSize);\n          const commandEncoder = this.backend.getCommandEncoder();\n          this.backend.endComputePass();\n          commandEncoder.copyBufferToBuffer(\n            sourceGpuDataCache.gpuData.buffer,\n            0,\n            destinationGpuDataCache.gpuData.buffer,\n            0,\n            size\n          );\n        }\n        registerExternalBuffer(buffer, originalSize, previousBuffer) {\n          let id;\n          if (previousBuffer) {\n            id = this.externalBuffers.get(previousBuffer);\n            if (id === void 0) {\n              throw new Error(\"previous buffer is not registered\");\n            }\n            if (buffer === previousBuffer) {\n              LOG_DEBUG(\n                \"verbose\",\n                () => `[WebGPU] GpuDataManager.registerExternalBuffer(size=${originalSize}) => id=${id}, buffer is the same, skip.`\n              );\n              return id;\n            } else if (this.backend.capturedCommandList.has(this.backend.currentSessionId)) {\n              throw new Error(`Registering a different external buffer under graph capture mode is not supported yet.\n             Please use the previous external buffer!`);\n            }\n            this.externalBuffers.delete(previousBuffer);\n          } else {\n            id = createNewGpuDataId();\n          }\n          this.storageCache.set(id, { gpuData: { id, type: 0 /* default */, buffer }, originalSize });\n          this.externalBuffers.set(buffer, id);\n          LOG_DEBUG(\n            \"verbose\",\n            () => `[WebGPU] GpuDataManager.registerExternalBuffer(size=${originalSize}) => id=${id}, registered.`\n          );\n          return id;\n        }\n        unregisterExternalBuffer(buffer) {\n          const id = this.externalBuffers.get(buffer);\n          if (id !== void 0) {\n            this.storageCache.delete(id);\n            this.externalBuffers.delete(buffer);\n            LOG_DEBUG(\"verbose\", () => `[WebGPU] GpuDataManager.unregisterExternalBuffer() => id=${id}`);\n          }\n        }\n        // eslint-disable-next-line no-bitwise\n        create(size, usage = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST) {\n          const bufferSize = calcBucketBufferSize(size);\n          let gpuBuffer;\n          const isStorage = (usage & GPUBufferUsage.STORAGE) === GPUBufferUsage.STORAGE;\n          const isUniform = (usage & GPUBufferUsage.UNIFORM) === GPUBufferUsage.UNIFORM;\n          if (isStorage || isUniform) {\n            const freeBuffers = isStorage ? this.freeBuffers : this.freeUniformBuffers;\n            const buffers = freeBuffers.get(bufferSize);\n            if (!buffers) {\n              gpuBuffer = this.backend.device.createBuffer({ size: bufferSize, usage });\n            } else {\n              if (buffers.length > 0) {\n                gpuBuffer = buffers.pop();\n              } else {\n                gpuBuffer = this.backend.device.createBuffer({ size: bufferSize, usage });\n              }\n            }\n          } else {\n            gpuBuffer = this.backend.device.createBuffer({ size: bufferSize, usage });\n          }\n          const gpuData = { id: createNewGpuDataId(), type: 0 /* default */, buffer: gpuBuffer };\n          this.storageCache.set(gpuData.id, { gpuData, originalSize: size });\n          LOG_DEBUG(\"verbose\", () => `[WebGPU] GpuDataManager.create(size=${size}) => id=${gpuData.id}`);\n          return gpuData;\n        }\n        get(id) {\n          return this.storageCache.get(id)?.gpuData;\n        }\n        release(id) {\n          const cachedData = this.storageCache.get(id);\n          if (!cachedData) {\n            throw new Error(\"releasing data does not exist\");\n          }\n          LOG_DEBUG(\"verbose\", () => `[WebGPU] GpuDataManager.release(id=${id}), gpuDataId=${cachedData.gpuData.id}`);\n          this.storageCache.delete(id);\n          this.buffersPending.push(cachedData.gpuData.buffer);\n          return cachedData.originalSize;\n        }\n        async download(id, getTargetBuffer) {\n          const cachedData = this.storageCache.get(id);\n          if (!cachedData) {\n            throw new Error(\"data does not exist\");\n          }\n          await downloadGpuData(this.backend, cachedData.gpuData.buffer, cachedData.originalSize, getTargetBuffer);\n        }\n        refreshPendingBuffers() {\n          for (const buffer of this.buffersForUploadingPending) {\n            buffer.destroy();\n          }\n          this.buffersForUploadingPending = [];\n          if (this.buffersPending.length === 0) {\n            return;\n          }\n          if (this.backend.sessionStatus === \"default\") {\n            for (const buffer of this.buffersPending) {\n              const maxInFreeList = bucketFreelist.get(buffer.size);\n              if ((buffer.usage & GPUBufferUsage.STORAGE) === GPUBufferUsage.STORAGE) {\n                const freelist = this.freeBuffers.get(buffer.size) || [];\n                if (maxInFreeList === void 0 || freelist.length >= maxInFreeList) {\n                  buffer.destroy();\n                } else {\n                  freelist.push(buffer);\n                }\n              } else if ((buffer.usage & GPUBufferUsage.UNIFORM) === GPUBufferUsage.UNIFORM) {\n                const freelist = this.freeUniformBuffers.get(buffer.size) || [];\n                if (maxInFreeList === void 0 || freelist.length >= maxInFreeList) {\n                  buffer.destroy();\n                } else {\n                  freelist.push(buffer);\n                }\n              } else {\n                buffer.destroy();\n              }\n            }\n            this.buffersPending = [];\n          } else {\n            let capturedBuffers = this.capturedPendingBuffers.get(this.backend.currentSessionId);\n            if (!capturedBuffers) {\n              capturedBuffers = [];\n              this.capturedPendingBuffers.set(this.backend.currentSessionId, capturedBuffers);\n            }\n            for (const buffer of this.buffersPending) {\n              capturedBuffers.push(buffer);\n            }\n            this.buffersPending = [];\n          }\n        }\n        dispose() {\n          this.freeBuffers.forEach((buffers) => {\n            buffers.forEach((buffer) => {\n              buffer.destroy();\n            });\n          });\n          this.freeUniformBuffers.forEach((buffers) => {\n            buffers.forEach((buffer) => {\n              buffer.destroy();\n            });\n          });\n          this.storageCache.forEach((storage) => {\n            storage.gpuData.buffer.destroy();\n          });\n          this.capturedPendingBuffers.forEach((buffers) => {\n            buffers.forEach((buffer) => {\n              buffer.destroy();\n            });\n          });\n          this.storageCache = /* @__PURE__ */ new Map();\n          this.freeBuffers = /* @__PURE__ */ new Map();\n          this.freeUniformBuffers = /* @__PURE__ */ new Map();\n          this.capturedPendingBuffers = /* @__PURE__ */ new Map();\n        }\n        onReleaseSession(sessionId) {\n          const pendingBuffers = this.capturedPendingBuffers.get(sessionId);\n          if (pendingBuffers) {\n            pendingBuffers.forEach((buffer) => {\n              buffer.destroy();\n            });\n            this.capturedPendingBuffers.delete(sessionId);\n          }\n        }\n      };\n      createGpuDataManager = (...args) => new GpuDataManagerImpl(...args);\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/attribute-with-cache-key.ts\n  var AttributeWithCacheKeyImpl, createAttributeWithCacheKey;\n  var init_attribute_with_cache_key = __esm({\n    \"web/lib/wasm/jsep/webgpu/attribute-with-cache-key.ts\"() {\n      \"use strict\";\n      AttributeWithCacheKeyImpl = class {\n        constructor(attribute) {\n          Object.assign(this, attribute);\n        }\n        get cacheKey() {\n          if (!this.key) {\n            this.key = Object.getOwnPropertyNames(this).sort().map((name) => `${this[name]}`).join(\";\");\n          }\n          return this.key;\n        }\n      };\n      createAttributeWithCacheKey = (attribute) => new AttributeWithCacheKeyImpl(attribute);\n    }\n  });\n\n  // web/lib/wasm/jsep/util.ts\n  var MatMulUtil, BroadcastUtil, ShapeUtil, PoolConvUtil, GemmUtil, MIN_CLIP, MAX_CLIP;\n  var init_util = __esm({\n    \"web/lib/wasm/jsep/util.ts\"() {\n      \"use strict\";\n      MatMulUtil = class {\n        /**\n         * Calculate the expected shape when matrix multiplication\n         * @param a The shape of tensor A. Should be a tuple of 2 positive integers\n         * @param b The shape of tensor B. Should be a tuple of 2 positive integers\n         * @returns The expected shape of the result, or undefined if N/A\n         */\n        static calcMatMulShape(a, b) {\n          return a[1] !== b[0] ? void 0 : [a[0], b[1]];\n        }\n      };\n      BroadcastUtil = class {\n        /**\n         * Calculate the expected shape when broadcasting 2 tensors\n         * @param a The shape of tensor A. Should be an array of positive integers\n         * @param b The shape of tensor B. Should be an array of positive integers\n         * @param isMatMul Whether the operation is MatMul\n         * @returns The expected shape of the result, or undefined if N/A\n         */\n        static calcShape(adims, bdims, isMatMul = false) {\n          const arank = adims.length;\n          const brank = bdims.length;\n          if (arank === 0) {\n            return bdims;\n          }\n          if (brank === 0) {\n            return adims;\n          }\n          const crank = Math.max(adims.length, bdims.length);\n          const cdims = new Array(crank);\n          if (isMatMul) {\n            if (arank < 2 || brank < 2) {\n              return void 0;\n            }\n            const cShapeMatMul = MatMulUtil.calcMatMulShape([adims[arank - 2], adims[arank - 1]], [bdims[brank - 2], bdims[brank - 1]]);\n            if (cShapeMatMul === void 0) {\n              return void 0;\n            }\n            [cdims[crank - 2], cdims[crank - 1]] = cShapeMatMul;\n          }\n          for (let i = isMatMul ? 3 : 1; i <= crank; i++) {\n            const aLen = arank - i < 0 ? 1 : adims[arank - i];\n            const bLen = brank - i < 0 ? 1 : bdims[brank - i];\n            if (aLen !== bLen && aLen > 1 && bLen > 1) {\n              return void 0;\n            }\n            const max = Math.max(aLen, bLen);\n            if (aLen && bLen) {\n              cdims[crank - i] = Math.max(aLen, bLen);\n            } else {\n              if (max > 1) {\n                return void 0;\n              }\n              cdims[crank - i] = 0;\n            }\n          }\n          return cdims;\n        }\n        /**\n         * Determine if a shape is unidirectional broadcastable to another shape\n         * @param shape The input shape\n         * @param finalShape The desired shape after broadcasting\n         */\n        static isValidBroadcast(shape, finalShape) {\n          const inputRank = shape.length;\n          const finalRank = finalShape.length;\n          if (inputRank > finalRank) {\n            return false;\n          }\n          for (let i = 1; i <= inputRank; i++) {\n            if (shape[inputRank - i] !== 1 && shape[inputRank - i] !== finalShape[finalRank - i]) {\n              return false;\n            }\n          }\n          return true;\n        }\n      };\n      ShapeUtil = class _ShapeUtil {\n        /**\n         * calculate the size (number of elements)\n         */\n        static size(dims) {\n          return _ShapeUtil.getSizeFromDimensionRange(dims, 0, dims.length);\n        }\n        /**\n         * convert dims corresponding to type change to pack. ex. uint8 data to uint32\n         */\n        static convertShape(dims, size = 4) {\n          const rank = dims.length;\n          if (rank === 0) {\n            return [];\n          }\n          const newDims = new Array(rank);\n          let i = rank - 1;\n          while (i >= 0) {\n            if (dims[i] % size === 0) {\n              newDims[i] = dims[i] / size;\n              break;\n            }\n            if (size % dims[i] !== 0) {\n              throw new Error(\"cannot convert shape\");\n            }\n            newDims[i] = 1;\n            size /= dims[i];\n            i--;\n          }\n          for (i--; i >= 0; i--) {\n            newDims[i] = dims[i];\n          }\n          return newDims;\n        }\n        /**\n         * calculate the size (number of elements) from the given axis (inclusive)\n         */\n        static sizeFromDimension(dims, axis) {\n          if (axis < 0 || axis > dims.length) {\n            throw new Error(`invalid dimension of ${axis} for sizeFromDimension as Tensor has ${dims.length} dimensions.`);\n          }\n          return _ShapeUtil.getSizeFromDimensionRange(dims, axis, dims.length);\n        }\n        /**\n         * calculate the size (number of elements) to the given axis (exclusive)\n         */\n        static sizeToDimension(dims, axis) {\n          if (axis < 0 || axis > dims.length) {\n            throw new Error(`invalid dimension of ${axis} for sizeToDimension as Tensor has ${dims.length} dimensions.`);\n          }\n          return _ShapeUtil.getSizeFromDimensionRange(dims, 0, axis);\n        }\n        /**\n         * calculate the size (number of elements) from and to the given axis [start, end)\n         */\n        static getSizeFromDimensionRange(dims, start, end) {\n          let size = 1;\n          for (let i = start; i < end; i++) {\n            if (dims[i] < 0) {\n              throw new Error(\n                // eslint-disable-next-line max-len\n                \"cannot get valid size from specified dimension range. Most likely the range contains negative values in them.\"\n              );\n            }\n            size *= dims[i];\n          }\n          return size;\n        }\n        static computeStrides(dims) {\n          const rank = dims.length;\n          if (rank === 0) {\n            return [];\n          } else if (rank === 1) {\n            return [1];\n          }\n          const strides = new Array(rank);\n          strides[rank - 1] = 1;\n          strides[rank - 2] = dims[rank - 1];\n          for (let i = rank - 3; i >= 0; --i) {\n            strides[i] = strides[i + 1] * dims[i + 1];\n          }\n          return strides;\n        }\n        /**\n         * normailze axis of range [-r, r) into [0, r).\n         */\n        static normalizeAxis(axis, tensorRank) {\n          if (axis < -tensorRank && axis >= tensorRank) {\n            throw new Error(\"unsupported axis for this operation.\");\n          }\n          return axis < 0 ? axis + tensorRank : axis;\n        }\n        static normalizeAxes(axes, tensorRank) {\n          return axes.map((x) => this.normalizeAxis(x, tensorRank ?? axes.length));\n        }\n        /**\n         * Sorts a given array based on the indices in the Perm array\n         * Used in Transpose\n         * @param a Array to be sorted such as dims or strides\n         * @param perm Perm given; if null a will be reversed\n         */\n        static sortBasedOnPerm(a, perm) {\n          if (perm) {\n            return perm.map((v) => a[v]);\n          } else {\n            return a.slice().reverse();\n          }\n        }\n        /**\n         * Pads a given shape according to the padding values\n         * @param dims shape of the Tensor to be padded\n         * @param pad pad values\n         */\n        static padShape(dims, pad2) {\n          const rank = dims.length;\n          return dims.map((v, i) => v + pad2[i] + pad2[i + rank]);\n        }\n        /**\n         * Determines if the two shapes are identical\n         * @param shape1\n         * @param shape2\n         */\n        static areEqual(shape1, shape2) {\n          if (shape1.length !== shape2.length) {\n            return false;\n          }\n          return shape1.every((v, i) => v === shape2[i]);\n        }\n      };\n      PoolConvUtil = class _PoolConvUtil {\n        /**\n         * Adjust the kernel, strides, pads to correct rank. Set to default value if not present\n         * @param isGlobalOperator If true, perform global pooling.\n         * @param inputDims The input tensor dimension.\n         * @param kernelShape The size of the kernel along each axis.\n         * @param strides Stride along each axis.\n         * @param dilations Dilation along each axis.\n         * @param pads Padding for the beginning and ending along each axis.\n         */\n        static adjustPoolAttributes(isGlobalOperator, inputDims, kernelShape, strides, dilations, pads) {\n          if (!isGlobalOperator && kernelShape.length !== inputDims.length - 2) {\n            throw new Error(\"length of specified kernel shapes should be 2 less than length of input dimensions\");\n          }\n          if (isGlobalOperator) {\n            for (let dim = 0; dim < inputDims.length - 2; dim++) {\n              if (dim >= kernelShape.length) {\n                kernelShape.push(inputDims[dim + 2]);\n              } else {\n                kernelShape[dim] = inputDims[dim + 2];\n              }\n            }\n          }\n          for (let dim = 0; dim < kernelShape.length; dim++) {\n            if (dim < strides.length) {\n              if (strides[dim] < 0) {\n                throw new Error(\"strides should be greater than or equal to 1\");\n              }\n            } else {\n              strides.push(1);\n            }\n          }\n          for (let dim = 0; dim < kernelShape.length; dim++) {\n            if (dim < dilations.length) {\n              if (dilations[dim] < 0) {\n                throw new Error(\"dilations should be greater than or equal to 1\");\n              }\n            } else {\n              dilations.push(1);\n            }\n          }\n          for (let dim = 0; dim < kernelShape.length * 2; dim++) {\n            if (dim < pads.length) {\n              if (pads[dim] < 0) {\n                throw new Error(\"pad should be greater than or equal to 1\");\n              }\n            } else {\n              pads.push(0);\n            }\n          }\n          for (let dim = 0; dim < kernelShape.length; dim++) {\n            if (kernelShape[dim] <= 0) {\n              throw new Error(\"kernel shapes need to be greater than 0\");\n            }\n            if (pads[dim] >= kernelShape[dim] || pads[dim + kernelShape.length] >= kernelShape[dim]) {\n              throw new Error(\"pads should be smaller than kernel\");\n            }\n          }\n        }\n        // adjust pad values based on 'autoPad' attribute\n        static adjustPadsBasedOnAutoPad(inputDims, strides, dilations, kernelShape, pads, isChannelLast, autoPad) {\n          if (!autoPad) {\n            return;\n          }\n          if (pads.length !== 2 * (inputDims.length - 2)) {\n            throw new Error(\"length of pads should be twice the length of data dimensions\");\n          }\n          if (strides.length !== inputDims.length - 2) {\n            throw new Error(\"length of strides should be the length of data dimensions\");\n          }\n          if (kernelShape.length !== inputDims.length - 2) {\n            throw new Error(\"length of kernel shapes should be the length of data dimensions\");\n          }\n          for (let dim = 0; dim < inputDims.length - 2; dim++) {\n            _PoolConvUtil.adjustPadAndReturnShape(\n              inputDims[dim + (isChannelLast ? 1 : 2)],\n              strides[dim],\n              dilations[dim],\n              kernelShape[dim],\n              pads,\n              dim,\n              dim + inputDims.length - 2,\n              autoPad\n            );\n          }\n        }\n        /**\n         * Calculate the output shape for Pool ops based on input attributes. (Should be used only for Pool ops)\n         * @param isGlobalOperator If true, perform global pooling.\n         * @param inputDims The input tensor dimension. (inputs[0].dims)\n         * @param strides Stride along each axis.\n         * @param dilations Dilation along each axis.\n         * @param kernelShape The size of the kernel along each axis.\n         * @param pads Padding for the beginning and ending along each axis.\n         * @param autoPad DEPRECATED attribute supported for legacy models. Specifies how to implicitly calculate pads in each\n         *     dimension. Can take values NOTSET, SAME_UPPER, SAME_LOWER, or VALID.\n         */\n        static computePoolOutputShape(isGlobalOperator, inputDims, strides, dilations, kernelShape, pads, autoPad) {\n          if (inputDims.length <= 0) {\n            throw new Error(\"input shape must be of size greater than 0\");\n          }\n          const outputDims = [inputDims[0], inputDims[1]];\n          _PoolConvUtil.computeShapeHelper(\n            isGlobalOperator,\n            inputDims,\n            outputDims,\n            strides,\n            dilations,\n            kernelShape,\n            pads,\n            autoPad\n          );\n          return outputDims;\n        }\n        /**\n         * Calculate the output shape for Conv op based on input attributes. (Should be used only for Conv op)\n         * @param inputDims The input tensor dimension. (inputs[0].dims)\n         * @param filterDims The filter tensor dimension. (inputs[1].dims)\n         * @param strides Stride along each axis.\n         * @param kernelShape The size of the kernel along each axis.\n         * @param pads Padding for the beginning and ending along each axis.\n         * @param autoPad DEPRECATED attribute supported for legacy models. Specifies how to implicitly calculate pads in each\n         *     dimension. Can take values NOTSET, SAME_UPPER, SAME_LOWER, or VALID.\n         */\n        static computeConvOutputShape(inputDims, filterDims, strides, dilations, kernelShape, pads, autoPad) {\n          if (inputDims.length <= 0 || filterDims.length <= 0) {\n            throw new Error(\"invalid input tensor dims or invalid filter tensor dims\");\n          }\n          const outputDims = [inputDims[0], filterDims[0]];\n          _PoolConvUtil.computeShapeHelper(false, inputDims, outputDims, strides, dilations, kernelShape, pads, autoPad);\n          return outputDims;\n        }\n        // will compute output shapes for data dimensions ONLY (i.e.) no batch size and channels\n        // called by computePoolOutputShape() and computeConvOutputShape()\n        // adjust pads based on 'autoPad' attribute prior to shape computation\n        static computeShapeHelper(isGlobalOperator, inputDims, outputDims, strides, dilations, kernelShape, pads, autoPad) {\n          if (isGlobalOperator) {\n            for (let dim = 0; dim < inputDims.length - 2; dim++) {\n              outputDims.push(1);\n            }\n          } else {\n            for (let dim = 0; dim < inputDims.length - 2; dim++) {\n              outputDims.push(_PoolConvUtil.adjustPadAndReturnShape(\n                inputDims[dim + 2],\n                strides[dim],\n                dilations[dim],\n                kernelShape[dim],\n                pads,\n                dim,\n                dim + inputDims.length - 2,\n                autoPad\n              ));\n            }\n          }\n        }\n        // helper for computeShapeHelper() and adjustPadsBasedOnAutoPad()\n        // adjusts pad value for given 'autoPad' string and computes output shape along a particular dimension\n        static adjustPadAndReturnShape(inSize, stride, dilation, kernel, pads, padHeadIndex, padTailIndex, autoPad) {\n          const dkernel = dilation * (kernel - 1) + 1;\n          if (autoPad && autoPad !== \"NOTSET\") {\n            switch (autoPad) {\n              case \"VALID\":\n                pads[padHeadIndex] = 0;\n                pads[padTailIndex] = 0;\n                return Math.floor((inSize - dkernel) / stride + 1);\n              case \"SAME_LOWER\":\n              case \"SAME_UPPER\":\n                if (dilation !== 1) {\n                  throw new Error(\"Dilation not supported for SAME_UPPER or SAME_LOWER\");\n                } else {\n                  const legacyTargetSize = (inSize + stride - 1) / stride;\n                  const padNeeded = (legacyTargetSize - 1) * stride + kernel - inSize;\n                  pads[padHeadIndex] = autoPad === \"SAME_LOWER\" ? Math.floor((padNeeded + 1) / 2) : Math.floor(padNeeded / 2);\n                  pads[padTailIndex] = padNeeded - pads[padHeadIndex];\n                  return Math.floor((inSize + padNeeded - kernel) / stride + 1);\n                }\n              default:\n                throw new Error(\"Unsupported AutoPad type\");\n            }\n          } else {\n            return Math.floor((inSize + pads[padHeadIndex] + pads[padTailIndex] - dkernel) / stride + 1);\n          }\n        }\n      };\n      GemmUtil = class {\n        // will make sure input shapes are compatible for this op\n        // and return back the shape of the output in the form of a tuple\n        // will throw exception if the input shapes are not compatible\n        static getShapeOfGemmResult(leftShape, transLeft, rightShape, transRight, biasShape) {\n          if (leftShape.length !== 2 || rightShape.length !== 2) {\n            throw new Error(\"shape need to be of size 2\");\n          }\n          let M;\n          let K;\n          let N;\n          if (transLeft) {\n            M = leftShape[1];\n            K = leftShape[0];\n          } else {\n            M = leftShape[0];\n            K = leftShape[1];\n          }\n          let kDim = -1;\n          if (transRight) {\n            N = rightShape[0];\n            kDim = 1;\n          } else {\n            N = rightShape[1];\n            kDim = 0;\n          }\n          if (rightShape[kDim] !== K) {\n            throw new Error(\"dimension mismatch\");\n          }\n          if (M <= 0 || N <= 0 || K <= 0) {\n            throw new Error(\"invalid shape specified\");\n          }\n          if (biasShape && !BroadcastUtil.isValidBroadcast(biasShape, [M, N])) {\n            throw new Error(\"gemm: invalid bias shape for broadcast\");\n          }\n          return [M, N, K];\n        }\n      };\n      MIN_CLIP = -34028234663852886e22;\n      MAX_CLIP = 34028234663852886e22;\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/common.ts\n  var WORKGROUP_SIZE, getWgslMappedType, tensorTypeToWsglStorageType, tensorTypeToWsglValueType, createTensorShapeVariables, getMaxComponents, fillVector, castToF32, sumVector, getElementAt, createIndicesHelper, inputVariable, outputVariable, internalVariable, ShaderHelperImpl, createShaderHelper, getBroadcastDims;\n  var init_common = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/common.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      WORKGROUP_SIZE = 64;\n      getWgslMappedType = (type, components) => {\n        if (components === 3) {\n          throw new Error(\"vec3 has same alignment as vec4, use vec4 instead\");\n        }\n        switch (type) {\n          case 10 /* float16 */:\n            return components > 1 ? `vec${components}<f16>` : \"f16\";\n          case 1 /* float */:\n            return components > 1 ? `vec${components}<f32>` : \"f32\";\n          case 6 /* int32 */:\n            return components > 1 ? `vec${components}<i32>` : \"i32\";\n          case 12 /* uint32 */:\n            return components > 1 ? `vec${components}<u32>` : \"u32\";\n          case 7 /* int64 */:\n            if (components > 1) {\n              throw new Error(\"currently not supported vecX of uint64 yet\");\n            }\n            return [\"vec2<u32>\", \"i32\"];\n          case 13 /* uint64 */:\n            if (components > 1) {\n              throw new Error(\"currently not supported vecX of uint64 yet\");\n            }\n            return [\"vec2<u32>\", \"u32\"];\n          case 9 /* bool */:\n            if (components !== 4) {\n              throw new Error(\"bool must be vec4\");\n            }\n            return [\"u32\", \"vec4<bool>\"];\n          default:\n            throw new Error(`Unknown data type: ${type}`);\n        }\n      };\n      tensorTypeToWsglStorageType = (type, components = 1) => {\n        const mappedType = getWgslMappedType(type, components);\n        return typeof mappedType === \"string\" ? mappedType : mappedType[0];\n      };\n      tensorTypeToWsglValueType = (type, components = 1) => {\n        const mappedType = getWgslMappedType(type, components);\n        return typeof mappedType === \"string\" ? mappedType : mappedType[1];\n      };\n      createTensorShapeVariables = (...dims) => {\n        const programUniforms = [];\n        dims.forEach((dim) => {\n          if (dim.length !== 0) {\n            programUniforms.push(\n              { type: 12 /* uint32 */, data: dim },\n              { type: 12 /* uint32 */, data: ShapeUtil.computeStrides(dim) }\n            );\n          }\n        });\n        return programUniforms;\n      };\n      getMaxComponents = (size) => {\n        if (size % 4 === 0) {\n          return 4;\n        } else if (size % 2 === 0) {\n          return 2;\n        }\n        return 1;\n      };\n      fillVector = (dataType = \"f32\", components, value = \"0\") => {\n        if (!components || components === 1) {\n          return `${dataType}(${value})`;\n        }\n        return `vec${components}<${dataType}>(${value})`;\n      };\n      castToF32 = (dataType, components, value) => {\n        if (dataType === \"f32\") {\n          return value;\n        }\n        if (components === 1) {\n          return `f32(${value})`;\n        }\n        return `vec${components}<f32>(${value})`;\n      };\n      sumVector = (name, components) => {\n        if (components === 4) {\n          return `(${name}.x + ${name}.y + ${name}.z + ${name}.w)`;\n        } else if (components === 2) {\n          return `(${name}.x + ${name}.y)`;\n        } else if (components === 3) {\n          return `(${name}.x + ${name}.y + ${name}.z)`;\n        }\n        return name;\n      };\n      getElementAt = (name, index, length, type) => {\n        if (name.startsWith(\"uniforms.\") && length > 4) {\n          if (typeof index === \"string\") {\n            if (type === \"f16\") {\n              return `${name}[(${index}) / 8][(${index}) % 8 / 4][(${index}) % 8 % 4]`;\n            } else {\n              return `${name}[(${index}) / 4][(${index}) % 4]`;\n            }\n          } else {\n            if (type === \"f16\") {\n              return `${name}[${Math.floor(index / 8)}][${Math.floor(index % 8 / 4)}][${index % 8 % 4}]`;\n            } else {\n              return `${name}[${Math.floor(index / 4)}][${index % 4}]`;\n            }\n          }\n        } else {\n          return length > 1 ? `${name}[${index}]` : name;\n        }\n      };\n      createIndicesHelper = (name, tensorType, shapeOrRank, usage, components) => {\n        const useUniform = typeof shapeOrRank === \"number\";\n        const rank = useUniform ? shapeOrRank : shapeOrRank.length;\n        const rankIdentity = [...new Array(rank).keys()];\n        const indicesType = rank < 2 ? \"u32\" : rank <= 4 ? `vec${rank}<u32>` : `array<u32, ${rank}>`;\n        const mappedType = getWgslMappedType(tensorType, components);\n        const valueType = typeof mappedType === \"string\" ? mappedType : mappedType[1];\n        const storageType = typeof mappedType === \"string\" ? mappedType : mappedType[0];\n        const type = { indices: indicesType, value: valueType, storage: storageType, tensor: tensorType };\n        const normalizeDim = (dim) => typeof dim === \"string\" ? dim : `${dim}u`;\n        const implementationUsed = {\n          offsetToIndices: false,\n          indicesToOffset: false,\n          broadcastedIndicesToOffset: false,\n          set: false,\n          setByIndices: false,\n          get: false,\n          getByIndices: false\n        };\n        const uniformPrefix = useUniform ? \"uniforms.\" : \"\";\n        const shape = `${uniformPrefix}${name}_shape`;\n        const strides = `${uniformPrefix}${name}_strides`;\n        let o2iSnippet = \"\";\n        for (let i = 0; i < rank - 1; i++) {\n          o2iSnippet += `\n    let dim${i} = current / ${getElementAt(strides, i, rank)};\n    let rest${i} = current % ${getElementAt(strides, i, rank)};\n    indices[${i}] = dim${i};\n    current = rest${i};\n    `;\n        }\n        o2iSnippet += `indices[${rank - 1}] = current;`;\n        const offsetToIndicesImplementation = rank < 2 ? \"\" : `\n  fn o2i_${name}(offset: u32) -> ${type.indices} {\n    var indices: ${type.indices};\n    var current = offset;\n    ${o2iSnippet}\n    return indices;\n  }`;\n        const offsetToIndices = (varOffset) => {\n          implementationUsed.offsetToIndices = true;\n          return rank < 2 ? varOffset : `o2i_${name}(${varOffset})`;\n        };\n        const offsets = [];\n        if (rank >= 2) {\n          for (let i = rank - 1; i >= 0; i--) {\n            offsets.push(`${getElementAt(strides, i, rank)} * (indices[${i}])`);\n          }\n        }\n        const indicesToOffsetImplementation = rank < 2 ? \"\" : `\n  fn i2o_${name}(indices: ${type.indices}) -> u32 {\n    return ${offsets.join(\"+\")};\n  }`;\n        const indicesToOffset = (varIndices) => {\n          implementationUsed.indicesToOffset = true;\n          return rank < 2 ? varIndices : `i2o_${name}(${varIndices})`;\n        };\n        const indices = (...init2) => rank === 0 ? \"0u\" : `${type.indices}(${init2.map(normalizeDim).join(\",\")})`;\n        const indicesGet = (varIndices, idx) => {\n          if (rank < 2) {\n            return `${varIndices}`;\n          } else {\n            return `${getElementAt(varIndices, idx, rank)}`;\n          }\n        };\n        const indicesSet = (varIndices, idx, value) => {\n          if (rank < 2) {\n            return `${varIndices}=${value};`;\n          } else {\n            return `${getElementAt(varIndices, idx, rank)}=${value};`;\n          }\n        };\n        const broadcastedIndicesToOffsetImplementation = {};\n        const broadcastedIndicesToOffset = (varIndices, output) => {\n          implementationUsed.broadcastedIndicesToOffset = true;\n          const implKey = `${output.name}broadcastedIndicesTo${name}Offset`;\n          if (implKey in broadcastedIndicesToOffsetImplementation) {\n            return `${implKey}(${varIndices})`;\n          }\n          const offsets2 = [];\n          for (let i = rank - 1; i >= 0; i--) {\n            const idx = output.indicesGet(\"outputIndices\", i + output.rank - rank);\n            offsets2.push(`${indicesGet(strides, i)} * (${idx} % ${indicesGet(shape, i)})`);\n          }\n          broadcastedIndicesToOffsetImplementation[implKey] = `fn ${implKey}(outputIndices: ${output.type.indices}) -> u32 {\n             return ${offsets2.length > 0 ? offsets2.join(\"+\") : \"0u\"};\n           }`;\n          return `${implKey}(${varIndices})`;\n        };\n        const setByOffset = (offset, value) => (() => {\n          if (type.storage === type.value) {\n            return `${name}[${offset}]=${value};`;\n          } else if (type.storage === \"vec2<u32>\" && type.value === \"i32\") {\n            return `${name}[${offset}]=vec2<u32>(u32(${value}), select(0u, 0xFFFFFFFFu, ${value} < 0));`;\n          } else if (type.storage === \"vec2<u32>\" && type.value === \"u32\") {\n            return `${name}[${offset}]=vec2<u32>(u32(${value}), 0u);`;\n          } else if (type.storage === \"u32\" && type.value === \"vec4<bool>\") {\n            return `${name}[${offset}]=dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(${value}));`;\n          } else {\n            throw new Error(`not supported combination of storage type ${type.storage} and value type ${type.value} yet`);\n          }\n        })();\n        const getByOffset = (offset) => (() => {\n          if (type.storage === type.value) {\n            return `${name}[${offset}]`;\n          } else if (type.storage === \"vec2<u32>\" && type.value === \"i32\") {\n            return `i32(${name}[${offset}].x)`;\n          } else if (type.storage === \"vec2<u32>\" && type.value === \"u32\") {\n            return `u32(${name}[${offset}].x)`;\n          } else if (type.storage === \"u32\" && type.value === \"vec4<bool>\") {\n            return `vec4<bool>(bool(${name}[${offset}] & 0xFFu), bool(${name}[${offset}] & 0xFF00u), bool(${name}[${offset}] & 0xFF0000u), bool(${name}[${offset}] & 0xFF000000u))`;\n          } else {\n            throw new Error(`not supported combination of storage type ${type.storage} and value type ${type.value} yet`);\n          }\n        })();\n        const getByIndicesImplementation = rank < 2 ? \"\" : `\n  fn get_${name}ByIndices(indices: ${type.indices}) -> ${valueType} {\n    return ${getByOffset(`i2o_${name}(indices)`)};\n  }`;\n        const getImplementation = rank < 2 ? \"\" : (() => {\n          const functionParams = rankIdentity.map((i) => `d${i}: u32`).join(\", \");\n          const dimsParams = rankIdentity.map((i) => `d${i}`).join(\", \");\n          return `\n  fn get_${name}(${functionParams}) -> ${valueType} {\n    return get_${name}ByIndices(${indices(dimsParams)});\n  }`;\n        })();\n        const get = (...indices2) => {\n          if (indices2.length !== rank) {\n            throw new Error(`indices length must be ${rank}`);\n          }\n          const normalizedIndices = indices2.map(normalizeDim).join(\",\");\n          if (rank === 0) {\n            return getByOffset(\"0u\");\n          } else if (rank === 1) {\n            return getByOffset(normalizedIndices[0]);\n          } else {\n            implementationUsed.get = true;\n            implementationUsed.getByIndices = true;\n            implementationUsed.indicesToOffset = true;\n            return `get_${name}(${normalizedIndices})`;\n          }\n        };\n        const getByIndices = (varIndices) => {\n          if (rank < 2) {\n            return getByOffset(varIndices);\n          } else {\n            implementationUsed.getByIndices = true;\n            implementationUsed.indicesToOffset = true;\n            return `get_${name}ByIndices(${varIndices})`;\n          }\n        };\n        const setByIndicesImplementation = rank < 2 ? \"\" : `\n  fn set_${name}ByIndices(indices: ${type.indices}, value: ${valueType}) {\n    ${setByOffset(`i2o_${name}(indices)`, \"value\")}\n  }`;\n        const setImplementation = rank < 2 ? \"\" : (() => {\n          const functionParams = rankIdentity.map((i) => `d${i}: u32`).join(\", \");\n          const dimsParams = rankIdentity.map((i) => `d${i}`).join(\", \");\n          return `\n  fn set_${name}(${functionParams}, value: ${valueType}) {\n    set_${name}ByIndices(${indices(dimsParams)}, value);\n  }`;\n        })();\n        const set = (...indicesAndValue) => {\n          if (indicesAndValue.length !== rank + 1) {\n            throw new Error(`indices length must be ${rank}`);\n          }\n          const value = indicesAndValue[rank];\n          if (typeof value !== \"string\") {\n            throw new Error(\"value must be string\");\n          }\n          const normalizedIndices = indicesAndValue.slice(0, rank).map(normalizeDim).join(\",\");\n          if (rank === 0) {\n            return setByOffset(\"0u\", value);\n          } else if (rank === 1) {\n            return setByOffset(normalizedIndices[0], value);\n          } else {\n            implementationUsed.set = true;\n            implementationUsed.setByIndices = true;\n            implementationUsed.indicesToOffset = true;\n            return `set_${name}(${normalizedIndices}, ${value})`;\n          }\n        };\n        const setByIndices = (varIndices, value) => {\n          if (rank < 2) {\n            return setByOffset(varIndices, value);\n          } else {\n            implementationUsed.setByIndices = true;\n            implementationUsed.indicesToOffset = true;\n            return `set_${name}ByIndices(${varIndices}, ${value});`;\n          }\n        };\n        const impl = () => {\n          const impls = [];\n          let needShapeStrides = false;\n          if (implementationUsed.offsetToIndices) {\n            impls.push(offsetToIndicesImplementation);\n            needShapeStrides = true;\n          }\n          if (implementationUsed.indicesToOffset) {\n            impls.push(indicesToOffsetImplementation);\n            needShapeStrides = true;\n          }\n          if (implementationUsed.broadcastedIndicesToOffset) {\n            Object.values(broadcastedIndicesToOffsetImplementation).forEach((impl2) => impls.push(impl2));\n            needShapeStrides = true;\n          }\n          if (implementationUsed.set) {\n            impls.push(setImplementation);\n            needShapeStrides = true;\n          }\n          if (implementationUsed.setByIndices) {\n            impls.push(setByIndicesImplementation);\n            needShapeStrides = true;\n          }\n          if (implementationUsed.get) {\n            impls.push(getImplementation);\n            needShapeStrides = true;\n          }\n          if (implementationUsed.getByIndices) {\n            impls.push(getByIndicesImplementation);\n            needShapeStrides = true;\n          }\n          if (!useUniform && needShapeStrides) {\n            impls.unshift(\n              `const ${shape} = ${type.indices}(${shapeOrRank.join(\",\")});`,\n              `const ${strides} = ${type.indices}(${ShapeUtil.computeStrides(shapeOrRank).join(\",\")});`\n            );\n          }\n          return impls.join(\"\\n\");\n        };\n        return {\n          impl,\n          type,\n          offsetToIndices,\n          indicesToOffset,\n          broadcastedIndicesToOffset,\n          indices,\n          indicesGet,\n          indicesSet,\n          set,\n          setByOffset,\n          setByIndices,\n          get,\n          getByOffset,\n          getByIndices,\n          // isVec4,\n          usage,\n          name,\n          strides,\n          shape,\n          rank\n        };\n      };\n      inputVariable = (name, type, shapeOrRank, components = 1) => createIndicesHelper(name, type, shapeOrRank, \"input\", components);\n      outputVariable = (name, type, shapeOrRank, components = 1) => createIndicesHelper(name, type, shapeOrRank, \"output\", components);\n      internalVariable = (name, type, shapeOrRank, components = 1) => createIndicesHelper(name, type, shapeOrRank, \"internal\", components);\n      ShaderHelperImpl = class {\n        constructor(normalizedDispatchGroup, limits) {\n          this.normalizedDispatchGroup = normalizedDispatchGroup;\n          this.limits = limits;\n          this.internalVariables = [];\n          this.variables = [];\n          this.uniforms = [];\n          this.variableIndex = 0;\n        }\n        guardAgainstOutOfBoundsWorkgroupSizes(size) {\n          const sizeInCode = typeof size === \"number\" ? `${size}u` : size;\n          return `if (global_idx >= ${sizeInCode}) { return; }`;\n        }\n        mainStart(workgroupSize = WORKGROUP_SIZE) {\n          const workgroupSizeX = typeof workgroupSize === \"number\" ? workgroupSize : workgroupSize[0];\n          const workgroupSizeY = typeof workgroupSize === \"number\" ? 1 : workgroupSize[1];\n          const workgroupSizeZ = typeof workgroupSize === \"number\" ? 1 : workgroupSize[2];\n          if (workgroupSizeX > this.limits.maxComputeWorkgroupSizeX || workgroupSizeY > this.limits.maxComputeWorkgroupSizeY || workgroupSizeZ > this.limits.maxComputeWorkgroupSizeZ) {\n            throw new Error(`workgroup size [${workgroupSizeX}, ${workgroupSizeY}, ${workgroupSizeZ}] exceeds the maximum workgroup size [${this.limits.maxComputeWorkgroupSizeX}, ${this.limits.maxComputeWorkgroupSizeY}, ${this.limits.maxComputeWorkgroupSizeZ}].`);\n          }\n          if (workgroupSizeX * workgroupSizeY * workgroupSizeZ > this.limits.maxComputeInvocationsPerWorkgroup) {\n            throw new Error(`workgroup size [${workgroupSizeX}, ${workgroupSizeY}, ${workgroupSizeZ}] exceeds the maximum workgroup invocations ${this.limits.maxComputeInvocationsPerWorkgroup}.`);\n          }\n          const is1DimensionDispatch = this.normalizedDispatchGroup[1] === 1 && this.normalizedDispatchGroup[2] === 1;\n          const paramList = is1DimensionDispatch ? `@builtin(global_invocation_id) global_id : vec3<u32>,\n    @builtin(workgroup_id) workgroup_id : vec3<u32>,\n    @builtin(local_invocation_id) local_id : vec3<u32>` : `@builtin(global_invocation_id) global_id : vec3<u32>,\n                                             @builtin(local_invocation_id) local_id : vec3<u32>,\n    @builtin(local_invocation_index) local_idx : u32,\n    @builtin(workgroup_id) workgroup_id : vec3<u32>,\n    @builtin(num_workgroups) num_workgroups : vec3<u32>`;\n          const globalIdxDefinition = is1DimensionDispatch ? \"let global_idx = global_id.x; let local_idx = local_id.x;\" : `let global_idx = (workgroup_id.z * num_workgroups[0] * num_workgroups[1] +\n          workgroup_id.y * num_workgroups[0] + workgroup_id.x) * ${workgroupSizeX * workgroupSizeY * workgroupSizeZ}u + local_idx;`;\n          return `@compute @workgroup_size(${workgroupSizeX}, ${workgroupSizeY}, ${workgroupSizeZ})\n  fn main(${paramList}) {\n    ${globalIdxDefinition}\n  `;\n        }\n        appendVariableUniforms(variable) {\n          if (variable.rank !== 0) {\n            if (variable.shape.startsWith(\"uniforms.\")) {\n              this.uniforms.push({ name: variable.shape.replace(\"uniforms.\", \"\"), type: \"u32\", length: variable.rank });\n            }\n            if (variable.strides.startsWith(\"uniforms.\")) {\n              this.uniforms.push({ name: variable.strides.replace(\"uniforms.\", \"\"), type: \"u32\", length: variable.rank });\n            }\n          }\n        }\n        declareVariable(variable, bindingIndex) {\n          if (variable.usage === \"internal\") {\n            throw new Error(\"cannot use internal variable with declareVariable(). use registerInternalVariables() instead.\");\n          }\n          this.variables.push(variable);\n          this.appendVariableUniforms(variable);\n          const access = variable.usage === \"input\" ? \"read\" : \"read_write\";\n          const storageType = variable.type.storage;\n          return `@group(0) @binding(${bindingIndex}) var<storage, ${access}> ${variable.name}: array<${storageType}>;`;\n        }\n        declareVariables(...variables) {\n          return variables.map((v) => this.declareVariable(v, this.variableIndex++)).join(\"\\n\");\n        }\n        registerInternalVariable(variable) {\n          if (variable.usage !== \"internal\") {\n            throw new Error(\n              \"cannot use input or output variable with registerInternalVariable(). use declareVariables() instead.\"\n            );\n          }\n          this.internalVariables.push(variable);\n          this.appendVariableUniforms(variable);\n        }\n        registerInternalVariables(...variables) {\n          variables.forEach((v) => this.registerInternalVariable(v));\n          return this;\n        }\n        registerUniform(name, type, length = 1) {\n          this.uniforms.push({ name, type, length });\n          return this;\n        }\n        registerUniforms(additionalUniforms) {\n          this.uniforms = this.uniforms.concat(additionalUniforms);\n          return this;\n        }\n        uniformDeclaration() {\n          if (this.uniforms.length === 0) {\n            return \"\";\n          }\n          const uniformSnippets = [];\n          for (const { name, type, length } of this.uniforms) {\n            if (length && length > 4) {\n              if (type === \"f16\") {\n                uniformSnippets.push(`@align(16) ${name}:array<mat2x4<${type}>, ${Math.ceil(length / 8)}>`);\n              } else {\n                uniformSnippets.push(`${name}:array<vec4<${type}>, ${Math.ceil(length / 4)}>`);\n              }\n            } else {\n              const typeTemp = length == null || length === 1 ? type : `vec${length}<${type}>`;\n              uniformSnippets.push(`${name}:${typeTemp}`);\n            }\n          }\n          return `\n      struct Uniforms { ${uniformSnippets.join(\", \")} };\n      @group(0) @binding(${this.variableIndex}) var<uniform> uniforms: Uniforms;`;\n        }\n        /**\n         * Get additional implementation that needs to be added to the shader source.\n         */\n        get additionalImplementations() {\n          return this.uniformDeclaration() + this.variables.map((i) => i.impl()).join(\"\\n\") + this.internalVariables.map((i) => i.impl()).join(\"\\n\");\n        }\n        /**\n         * Get the variable info of the shader program.\n         */\n        get variablesInfo() {\n          if (this.uniforms.length === 0) {\n            return void 0;\n          }\n          const uniformWgslTypeToDataType = (type) => [\n            12 /* uint32 */,\n            10 /* float16 */,\n            1 /* float */,\n            6 /* int32 */\n          ][[\"u32\", \"f16\", \"f32\", \"i32\"].indexOf(type)];\n          return this.uniforms.map((u) => [uniformWgslTypeToDataType(u.type), u.length ?? 1]);\n        }\n      };\n      createShaderHelper = (dispatchGroup, limits) => new ShaderHelperImpl(dispatchGroup, limits);\n      getBroadcastDims = (inShape, outShape) => {\n        const inRank = inShape.length;\n        const dims = [];\n        for (let i = 0; i < inRank; i++) {\n          const dim = inRank - 1 - i;\n          const a = inShape[dim] || 1;\n          const b = outShape[outShape.length - 1 - i] || 1;\n          if (b > 1 && a === 1) {\n            dims.unshift(dim);\n          }\n        }\n        return dims;\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/transpose.ts\n  var validateInputs, getAdjustedPerm, getOutputShape, permFunctionBody, createTransposeProgramInfo, transpose, parseTransposeAttributes;\n  var init_transpose = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/transpose.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_attribute_with_cache_key();\n      init_common();\n      validateInputs = (inputs) => {\n        if (!inputs || inputs.length !== 1) {\n          throw new Error(\"Transpose requires 1 input.\");\n        }\n      };\n      getAdjustedPerm = (inputRank, perm) => perm && perm.length !== inputRank ? [...new Array(inputRank).keys()].reverse() : perm;\n      getOutputShape = (inputShape, perm) => ShapeUtil.sortBasedOnPerm(inputShape, getAdjustedPerm(inputShape.length, perm));\n      permFunctionBody = (perm, rank, input, output) => {\n        const reverseFunc = [];\n        reverseFunc.push(`fn perm(i: ${output.type.indices}) -> ${input.type.indices} {\n    var a: ${input.type.indices};`);\n        for (let i = 0; i < rank; ++i) {\n          reverseFunc.push(input.indicesSet(\"a\", perm[i], `i[${i}]`));\n        }\n        reverseFunc.push(\"return a;}\");\n        return reverseFunc.join(\"\\n\");\n      };\n      createTransposeProgramInfo = (inputTensor, permAttr) => {\n        const inputDataType = inputTensor.dataType;\n        const inputRank = inputTensor.dims.length;\n        const perm = getAdjustedPerm(inputRank, permAttr);\n        const outputShape = getOutputShape(inputTensor.dims, perm);\n        const output = outputVariable(\"output\", inputDataType, outputShape.length);\n        const input = inputVariable(\"a\", inputDataType, inputRank);\n        const getShaderSource = (shaderHelper) => `\n  ${shaderHelper.registerUniform(\"output_size\", \"u32\").declareVariables(input, output)}\n\n  ${permFunctionBody(perm, inputRank, input, output)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.output_size\")}\n\n    let indices = ${output.offsetToIndices(\"global_idx\")};\n    let aIndices = perm(indices);\n\n    ${output.setByOffset(\"global_idx\", input.getByIndices(\"aIndices\"))}\n  }`;\n        return {\n          name: \"Transpose\",\n          shaderCache: { hint: `${permAttr}`, inputDependencies: [\"rank\"] },\n          getRunData: (inputs) => {\n            const outputSize = ShapeUtil.size(outputShape);\n            return {\n              outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n              dispatchGroup: { x: Math.ceil(\n                outputSize / 64\n                /* workgroup size */\n              ) },\n              programUniforms: [{ type: 12 /* uint32 */, data: outputSize }, ...createTensorShapeVariables(inputs[0].dims, outputShape)]\n            };\n          },\n          getShaderSource\n        };\n      };\n      transpose = (context, attributes) => {\n        validateInputs(context.inputs);\n        context.compute(createTransposeProgramInfo(context.inputs[0], attributes.perm));\n      };\n      parseTransposeAttributes = (attributes) => createAttributeWithCacheKey({ perm: attributes.perm });\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/reduce-shared.ts\n  var reduceOps, reduceSharedOps, reduceInitValues, reduceOutputValues, getInnerMostAxes, computeOutAndReduceShapes, expandShapeToKeepDim, areAxesInnerMostDims, getAxesPermutation, createReduceSharedProgramInfo, reduceCommon, reduceMeanShared, reduceL1Shared, reduceL2Shared, reduceLogSumExpShared, reduceMaxShared, reduceMinShared, reduceProdShared, reduceSumShared, reduceSumSquareShared, reduceLogSumShared;\n  var init_reduce_shared = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/reduce-shared.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_common();\n      init_reduce();\n      init_transpose();\n      reduceOps = {\n        max: \"select(bestValue, candidate, candidate > bestValue)\",\n        min: \"select(bestValue, candidate, candidate < bestValue)\",\n        mean: \"bestValue + candidate\",\n        sum: \"bestValue + candidate\",\n        prod: \"bestValue * candidate\",\n        sumSquare: \"bestValue + candidate * candidate\",\n        logSumExp: \"bestValue + exp(candidate)\",\n        l1: \"bestValue + abs(candidate)\",\n        l2: \"bestValue + candidate * candidate\",\n        logSum: \"bestValue + candidate\"\n      };\n      reduceSharedOps = {\n        max: \"select(bestValue, candidate, candidate > bestValue)\",\n        min: \"select(bestValue, candidate, candidate < bestValue)\",\n        mean: \"bestValue + candidate\",\n        sum: \"bestValue + candidate\",\n        prod: \"bestValue * candidate\",\n        sumSquare: \"bestValue + candidate\",\n        logSumExp: \"bestValue + candidate\",\n        l1: \"bestValue + candidate\",\n        l2: \"bestValue + candidate\",\n        logSum: \"bestValue + candidate\"\n      };\n      reduceInitValues = {\n        max: \"_A[offset]\",\n        min: \"_A[offset]\",\n        mean: \"0\",\n        sum: \"0\",\n        prod: \"1\",\n        sumSquare: \"0\",\n        logSumExp: \"0\",\n        l1: \"0\",\n        l2: \"0\",\n        logSum: \"0\"\n      };\n      reduceOutputValues = {\n        max: \"bestValue\",\n        min: \"bestValue\",\n        sum: \"bestValue\",\n        prod: \"bestValue\",\n        sumSquare: \"bestValue\",\n        logSumExp: \"log(bestValue)\",\n        l1: \"bestValue\",\n        l2: \"sqrt(bestValue)\",\n        logSum: \"log(bestValue)\"\n      };\n      getInnerMostAxes = (numInnerAxes, rank) => {\n        const res = [];\n        for (let i = rank - numInnerAxes; i < rank; ++i) {\n          res.push(i);\n        }\n        return res;\n      };\n      computeOutAndReduceShapes = (shape, axes) => {\n        const outputShape = [];\n        const rank = shape.length;\n        for (let dim = 0; dim < rank; dim++) {\n          if (axes.indexOf(dim) === -1) {\n            outputShape.push(shape[dim]);\n          }\n        }\n        const reduceShape = axes.map((dim) => shape[dim]);\n        return [outputShape, reduceShape];\n      };\n      expandShapeToKeepDim = (shape, axes) => {\n        const rank = shape.length + axes.length;\n        const expandShape = [];\n        let shapeIdx = 0;\n        for (let dim = 0; dim < rank; dim++) {\n          if (axes.indexOf(dim) === -1) {\n            expandShape.push(shape[shapeIdx++]);\n          } else {\n            expandShape.push(1);\n          }\n        }\n        return expandShape;\n      };\n      areAxesInnerMostDims = (axes, rank) => {\n        for (let i = 0; i < axes.length; ++i) {\n          if (axes[axes.length - i - 1] !== rank - 1 - i) {\n            return false;\n          }\n        }\n        return true;\n      };\n      getAxesPermutation = (axes, rank) => {\n        const res = [];\n        if (!areAxesInnerMostDims(axes, rank)) {\n          for (let i = 0; i < rank; ++i) {\n            if (axes.indexOf(i) === -1) {\n              res.push(i);\n            }\n          }\n          axes.forEach((axis) => res.push(axis));\n        }\n        return res;\n      };\n      createReduceSharedProgramInfo = (name, shaderCache, inputs, reduceType, outputDataType, outputShape, reduceShape) => {\n        const inputShape = inputs[0].dims;\n        const outputSize = ShapeUtil.size(outputShape);\n        const reduceSize = ShapeUtil.size(reduceShape);\n        const input = inputVariable(\"_A\", inputs[0].dataType, inputShape);\n        const output = outputVariable(\"output\", outputDataType, outputShape);\n        const workgroupSize = 32;\n        const sharedMemorySnippet = `\n          var<workgroup> aBestValues : array<f32, ${workgroupSize}>;\n       `;\n        const getShaderSource = (shaderHelper) => `\n        ${shaderHelper.registerUniform(\"reduceSize\", \"u32\").declareVariables(input, output)}\n        ${sharedMemorySnippet}\n        fn DIV_CEIL(a : u32, b : u32) -> u32 {\n          return ((a - 1u) / b + 1u);\n         }\n         ${shaderHelper.mainStart(workgroupSize)}\n\n          let outputIndex = global_idx / ${workgroupSize};\n          let offset = outputIndex * uniforms.reduceSize;\n\n          var bestValue = f32(${reduceInitValues[reduceType]});\n          let Length = uniforms.reduceSize;\n          for (var k = local_idx; k < Length; k = k + ${workgroupSize}) {\n           let candidate = f32(${input.getByOffset(\"offset + k\")});\n           bestValue = ${reduceOps[reduceType]};\n          }\n          aBestValues[local_idx] = bestValue;\n          workgroupBarrier();\n\n         var reduceSize = min(Length, ${workgroupSize}u);\n         for (var currentSize = reduceSize / 2u; reduceSize > 1u;\n             currentSize = reduceSize / 2u) {\n           let interval = DIV_CEIL(reduceSize, 2u);\n           if (local_idx < currentSize) {\n            let candidate = aBestValues[local_idx + interval];\n            bestValue = ${reduceSharedOps[reduceType]};\n            aBestValues[local_idx] = bestValue;\n           }\n           reduceSize = interval;\n           workgroupBarrier();\n         }\n\n         if (local_idx == 0u) {\n          ${output.setByOffset(\n          \"outputIndex\",\n          `${reduceType === \"mean\" ? `${output.type.storage}(bestValue / f32(uniforms.reduceSize))` : `${output.type.storage}(${reduceOutputValues[reduceType]})`}`\n        )};\n         }\n        }`;\n        return {\n          name,\n          shaderCache,\n          getShaderSource,\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: outputDataType }],\n            dispatchGroup: { x: outputSize },\n            programUniforms: [{ type: 12 /* uint32 */, data: reduceSize }]\n          })\n        };\n      };\n      reduceCommon = (context, name, attributes, reduceType) => {\n        const updatedAttributes = context.inputs.length === 1 ? attributes : createReduceAttributesFromInputs(context.inputs, attributes);\n        let updatedAxes = updatedAttributes.axes;\n        if (updatedAxes.length === 0 && !updatedAttributes.noopWithEmptyAxes) {\n          updatedAxes = context.inputs[0].dims.map((_dim, i) => i);\n        }\n        const normalizeAxes = ShapeUtil.normalizeAxes(updatedAxes, context.inputs[0].dims.length);\n        let axes = normalizeAxes;\n        let input = context.inputs[0];\n        const permutedAxes = getAxesPermutation(axes, context.inputs[0].dims.length);\n        if (permutedAxes.length > 0) {\n          input = context.compute(\n            createTransposeProgramInfo(context.inputs[0], permutedAxes),\n            { inputs: [0], outputs: [-1] }\n          )[0];\n          axes = getInnerMostAxes(axes.length, input.dims.length);\n        }\n        const [outputShape, reduceShape] = computeOutAndReduceShapes(input.dims, axes);\n        let finalOutputShape = outputShape;\n        if (updatedAttributes.keepDims) {\n          finalOutputShape = expandShapeToKeepDim(outputShape, normalizeAxes);\n        }\n        context.compute(\n          createReduceSharedProgramInfo(\n            name,\n            { hint: updatedAttributes.cacheKey, inputDependencies: [\"type\"] },\n            [input],\n            reduceType,\n            context.inputs[0].dataType,\n            finalOutputShape,\n            reduceShape\n          ),\n          { inputs: [input] }\n        );\n      };\n      reduceMeanShared = (context, attributes) => {\n        reduceCommon(context, \"ReduceMeanShared\", attributes, \"mean\");\n      };\n      reduceL1Shared = (context, attributes) => {\n        reduceCommon(context, \"ReduceL1Shared\", attributes, \"l1\");\n      };\n      reduceL2Shared = (context, attributes) => {\n        reduceCommon(context, \"ReduceL2Shared\", attributes, \"l2\");\n      };\n      reduceLogSumExpShared = (context, attributes) => {\n        reduceCommon(context, \"ReduceLogSumExpShared\", attributes, \"logSumExp\");\n      };\n      reduceMaxShared = (context, attributes) => {\n        reduceCommon(context, \"ReduceMaxShared\", attributes, \"max\");\n      };\n      reduceMinShared = (context, attributes) => {\n        reduceCommon(context, \"ReduceMinShared\", attributes, \"min\");\n      };\n      reduceProdShared = (context, attributes) => {\n        reduceCommon(context, \"ReduceProdShared\", attributes, \"prod\");\n      };\n      reduceSumShared = (context, attributes) => {\n        reduceCommon(context, \"ReduceSumShared\", attributes, \"sum\");\n      };\n      reduceSumSquareShared = (context, attributes) => {\n        reduceCommon(context, \"ReduceSumSquareShared\", attributes, \"sumSquare\");\n      };\n      reduceLogSumShared = (context, attributes) => {\n        reduceCommon(context, \"ReduceLogSumShared\", attributes, \"logSum\");\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/reduce.ts\n  var validateInputs2, noOp, createReduceProgramInfo, createReduceAttributesFromInputs, runReduceProgram, reduceLogSumNaive, reduceL1Naive, reduceL2Naive, reduceLogSumExpNaive, reduceMaxNaive, reduceMeanNaive, reduceMinNaive, reduceProdNaive, reduceSumNaive, reduceSumSquareNaive, useNaiveReduceMethod, reduceMean, reduceL1, reduceL2, reduceLogSumExp, reduceMax, reduceMin, reduceProd, reduceSum, reduceSumSquare, reduceLogSum;\n  var init_reduce = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/reduce.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_attribute_with_cache_key();\n      init_common();\n      init_reduce_shared();\n      validateInputs2 = (inputs) => {\n        if (!inputs || inputs.length === 0 || inputs.length > 2) {\n          throw new Error(\"Reduce op requires 1 or 2 inputs.\");\n        }\n        if (inputs.length === 2 && inputs[1].dims.length !== 1) {\n          throw new Error(\"Invalid axes input dims.\");\n        }\n      };\n      noOp = (input) => [\"\", \"\", `var value = ${input.getByIndices(\"input_indices\")};`, \"\"];\n      createReduceProgramInfo = (name, shaderCache, inputs, reduceOp, axesInput, outputDataType, keepDims = false, noopWithEmptyAxes = false) => {\n        const outputShape = [];\n        const inputShape = inputs[0].dims;\n        const inputRank = inputShape.length;\n        const axes = ShapeUtil.normalizeAxes(axesInput, inputRank);\n        const reduceOnAllAxes = !noopWithEmptyAxes && axes.length === 0;\n        inputShape.forEach((d, i) => {\n          if (reduceOnAllAxes || axes.indexOf(i) >= 0) {\n            if (keepDims) {\n              outputShape.push(1);\n            }\n          } else {\n            outputShape.push(d);\n          }\n        });\n        const outputRank = outputShape.length;\n        const outputSize = ShapeUtil.size(outputShape);\n        const getShaderSource = (shaderHelper) => {\n          const idxCopy = [];\n          const input = inputVariable(\"_A\", inputs[0].dataType, inputRank);\n          const output = outputVariable(\"output\", outputDataType, outputRank);\n          const ops = reduceOp(input, output, axes);\n          let reduceOps2 = ops[2];\n          for (let k = 0, l = 0; k < inputRank; k++) {\n            if (reduceOnAllAxes || axes.indexOf(k) >= 0) {\n              if (keepDims) {\n                l++;\n              }\n              reduceOps2 = `for(var j${k}: u32 = 0; j${k} < ${inputShape[k]}; j${k}++) {\n                  ${ops[2].includes(\"last_index\") ? `let last_index = j${k};` : \"\"}\n                  ${input.indicesSet(\"input_indices\", k, `j${k}`)}\n                  ${reduceOps2}\n                }`;\n            } else {\n              idxCopy.push(`${input.indicesSet(\"input_indices\", k, output.indicesGet(\"output_indices\", l))};`);\n              l++;\n            }\n          }\n          return `\n\n        ${shaderHelper.registerUniform(\"output_size\", \"u32\").declareVariables(input, output)}\n\n        ${shaderHelper.mainStart()}\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.output_size\")}\n          var input_indices: ${input.type.indices};\n          let output_indices = ${output.offsetToIndices(\"global_idx\")};\n\n          ${idxCopy.join(\"\\n\")}\n          ${ops[0]}       // init ops for reduce max/min\n          ${ops[1]}\n          ${reduceOps2}\n          ${ops[3]}\n          ${ops.length === 4 ? output.setByOffset(\"global_idx\", \"value\") : ops.slice(4).join(\"\\n\")}\n        }`;\n        };\n        return {\n          name,\n          shaderCache,\n          getShaderSource,\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: outputDataType }],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64\n              /* workgroup size */\n            ) },\n            programUniforms: [{ type: 12 /* uint32 */, data: outputSize }, ...createTensorShapeVariables(inputShape, outputShape)]\n          })\n        };\n      };\n      createReduceAttributesFromInputs = (inputs, attributes) => {\n        const axes = [];\n        if (inputs[1].dims[0] > 0) {\n          inputs[1].getBigInt64Array().forEach((v) => axes.push(Number(v)));\n        }\n        return createAttributeWithCacheKey(\n          { axes, keepDims: attributes.keepDims, noopWithEmptyAxes: attributes.noopWithEmptyAxes }\n        );\n      };\n      runReduceProgram = (context, name, attributes, reduceOp) => {\n        const inputs = context.inputs;\n        const updatedAttributes = inputs.length === 1 ? attributes : createReduceAttributesFromInputs(inputs, attributes);\n        context.compute(\n          createReduceProgramInfo(\n            name,\n            { hint: updatedAttributes.cacheKey, inputDependencies: [\"rank\"] },\n            [inputs[0]],\n            updatedAttributes.noopWithEmptyAxes && updatedAttributes.axes.length === 0 ? noOp : reduceOp,\n            updatedAttributes.axes,\n            inputs[0].dataType,\n            updatedAttributes.keepDims,\n            updatedAttributes.noopWithEmptyAxes\n          ),\n          { inputs: [0] }\n        );\n      };\n      reduceLogSumNaive = (context, attributes) => {\n        validateInputs2(context.inputs);\n        const reduceOp = (input, output) => [\n          `var value = ${output.type.storage}(0);`,\n          \"\",\n          `value += ${input.getByIndices(\"input_indices\")};`,\n          \"value = log(value);\"\n        ];\n        runReduceProgram(context, \"ReduceLogSum\", attributes, reduceOp);\n      };\n      reduceL1Naive = (context, attributes) => {\n        validateInputs2(context.inputs);\n        const reduceOp = (input, output) => [\n          `var value = ${output.type.storage}(0);`,\n          \"\",\n          `value += abs(${input.getByIndices(\"input_indices\")});`,\n          \"\"\n        ];\n        runReduceProgram(context, \"ReduceL1\", attributes, reduceOp);\n      };\n      reduceL2Naive = (context, attributes) => {\n        validateInputs2(context.inputs);\n        const reduceOp = (input, output) => [\n          `var t = ${output.type.value}(0); var value = ${output.type.value}(0);`,\n          \"\",\n          `t = ${input.getByIndices(\"input_indices\")}; value += (t * t);`,\n          \"value = sqrt(value);\"\n        ];\n        runReduceProgram(context, \"ReduceL2\", attributes, reduceOp);\n      };\n      reduceLogSumExpNaive = (context, attributes) => {\n        validateInputs2(context.inputs);\n        const reduceOp = (input, output) => [\n          `var value = ${output.type.storage}(0);`,\n          \"\",\n          `value += exp(${input.getByIndices(\"input_indices\")});`,\n          \"value = log(value);\"\n        ];\n        runReduceProgram(context, \"ReduceLogSumExp\", attributes, reduceOp);\n      };\n      reduceMaxNaive = (context, attributes) => {\n        validateInputs2(context.inputs);\n        const reduceOp = (input, _output, axes) => {\n          const idxZero = [];\n          for (let k = 0; k < input.rank; k++) {\n            if (axes.indexOf(k) >= 0 || axes.length === 0) {\n              idxZero.push(input.indicesSet(\"input_indices\", k, 0));\n            }\n          }\n          return [\n            `${idxZero.join(\"\\n\")}`,\n            `var value = ${input.getByIndices(\"input_indices\")};`,\n            `value = max(value, ${input.getByIndices(\"input_indices\")});`,\n            \"\"\n          ];\n        };\n        runReduceProgram(context, \"ReduceMax\", attributes, reduceOp);\n      };\n      reduceMeanNaive = (context, attributes) => {\n        validateInputs2(context.inputs);\n        const reduceOp = (input, output, axes) => {\n          let size = 1;\n          for (let k = 0; k < input.rank; k++) {\n            if (axes.indexOf(k) >= 0 || axes.length === 0) {\n              size *= context.inputs[0].dims[k];\n            }\n          }\n          return [\n            \"var sum = f32(0);\",\n            \"\",\n            `sum += f32(${input.getByIndices(\"input_indices\")});`,\n            `let value = ${output.type.value}(sum / ${size});`\n          ];\n        };\n        runReduceProgram(context, \"ReduceMean\", attributes, reduceOp);\n      };\n      reduceMinNaive = (context, attributes) => {\n        validateInputs2(context.inputs);\n        const reduceOp = (input, _output, axes) => {\n          const idxZero = [];\n          for (let k = 0; k < input.rank; k++) {\n            if (axes.indexOf(k) >= 0 || axes.length === 0) {\n              idxZero.push(`input_indices[${k}] = 0;`);\n            }\n          }\n          return [\n            `${idxZero.join(\"\\n\")}`,\n            `var value = ${input.getByIndices(\"input_indices\")};`,\n            `value = min(value, ${input.getByIndices(\"input_indices\")});`,\n            \"\"\n          ];\n        };\n        runReduceProgram(context, \"ReduceMin\", attributes, reduceOp);\n      };\n      reduceProdNaive = (context, attributes) => {\n        validateInputs2(context.inputs);\n        const reduceOp = (input, output) => [\n          `var value = ${output.type.storage}(1);`,\n          \"\",\n          `value *= ${input.getByIndices(\"input_indices\")};`,\n          \"\"\n        ];\n        runReduceProgram(context, \"ReduceProd\", attributes, reduceOp);\n      };\n      reduceSumNaive = (context, attributes) => {\n        validateInputs2(context.inputs);\n        const reduceOp = (input, output) => [\n          `var value = ${output.type.storage}(0);`,\n          \"\",\n          `value += ${input.getByIndices(\"input_indices\")};`,\n          \"\"\n        ];\n        runReduceProgram(context, \"ReduceSum\", attributes, reduceOp);\n      };\n      reduceSumSquareNaive = (context, attributes) => {\n        validateInputs2(context.inputs);\n        const reduceOp = (input, output) => [\n          `var t = ${output.type.value}(0); var value = ${output.type.value}(0);`,\n          \"\",\n          `t = ${input.getByIndices(\"input_indices\")}; value += t * t;`,\n          \"\"\n        ];\n        runReduceProgram(context, \"ReduceSumSquare\", attributes, reduceOp);\n      };\n      useNaiveReduceMethod = (shape, axes, noopWithEmptyAxes) => {\n        if (axes.length === 0) {\n          return noopWithEmptyAxes;\n        }\n        let outputSize = 1;\n        let reduceSize = 1;\n        for (let dim = 0; dim < axes.length; dim++) {\n          if (axes.indexOf(dim) === -1) {\n            outputSize *= shape[dim];\n          } else {\n            reduceSize *= shape[dim];\n          }\n        }\n        return reduceSize < 32 && outputSize > 1024;\n      };\n      reduceMean = (context, attributes) => {\n        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n          reduceMeanNaive(context, attributes);\n        } else {\n          reduceMeanShared(context, attributes);\n        }\n      };\n      reduceL1 = (context, attributes) => {\n        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n          reduceL1Naive(context, attributes);\n        } else {\n          reduceL1Shared(context, attributes);\n        }\n      };\n      reduceL2 = (context, attributes) => {\n        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n          reduceL2Naive(context, attributes);\n        } else {\n          reduceL2Shared(context, attributes);\n        }\n      };\n      reduceLogSumExp = (context, attributes) => {\n        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n          reduceLogSumExpNaive(context, attributes);\n        } else {\n          reduceLogSumExpShared(context, attributes);\n        }\n      };\n      reduceMax = (context, attributes) => {\n        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n          reduceMaxNaive(context, attributes);\n        } else {\n          reduceMaxShared(context, attributes);\n        }\n      };\n      reduceMin = (context, attributes) => {\n        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n          reduceMinNaive(context, attributes);\n        } else {\n          reduceMinShared(context, attributes);\n        }\n      };\n      reduceProd = (context, attributes) => {\n        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n          reduceProdNaive(context, attributes);\n        } else {\n          reduceProdShared(context, attributes);\n        }\n      };\n      reduceSum = (context, attributes) => {\n        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n          reduceSumNaive(context, attributes);\n        } else {\n          reduceSumShared(context, attributes);\n        }\n      };\n      reduceSumSquare = (context, attributes) => {\n        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n          reduceSumSquareNaive(context, attributes);\n        } else {\n          reduceSumSquareShared(context, attributes);\n        }\n      };\n      reduceLogSum = (context, attributes) => {\n        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n          reduceLogSumNaive(context, attributes);\n        } else {\n          reduceLogSumShared(context, attributes);\n        }\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/argminmax.ts\n  var validateInputs3, argMin, argMax, parseArgMinMaxAttributes;\n  var init_argminmax = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/argminmax.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_attribute_with_cache_key();\n      init_reduce();\n      validateInputs3 = (inputs) => {\n        if (!inputs || inputs.length === 0 || inputs.length > 2) {\n          throw new Error(\"ArgMinMaxOp op requires 1 or 2 inputs.\");\n        }\n        if (inputs[0].dataType !== 1 /* float */) {\n          throw new Error(\"Invalid input type.\");\n        }\n      };\n      argMin = (context, attributes) => {\n        validateInputs3(context.inputs);\n        const argMinMaxOp = (input, output, axes) => {\n          const idxZero = [];\n          for (let k = 0; k < input.rank; k++) {\n            if (axes.indexOf(k) >= 0 || axes.length === 0) {\n              idxZero.push(`input_indices[${k}] = 0;`);\n            }\n          }\n          return [\n            `${idxZero.join(\"\\n\")}`,\n            `var value = ${input.getByIndices(\"input_indices\")};\nvar best_index : i32 = 0;`,\n            `if (${input.getByIndices(\"input_indices\")} ${attributes.selectLastIndex > 0 ? \"<=\" : \"<\"} value) {\n         value = ${input.getByIndices(\"input_indices\")};\n         best_index = i32(last_index);\n       }`,\n            \"\",\n            output.setByOffset(\"global_idx\", \"best_index\")\n          ];\n        };\n        context.compute(\n          createReduceProgramInfo(\n            \"ArgMin\",\n            { hint: attributes.cacheKey, inputDependencies: [\"rank\"] },\n            [context.inputs[0]],\n            argMinMaxOp,\n            [attributes.axis],\n            7 /* int64 */,\n            attributes.keepDims\n          ),\n          { inputs: [0] }\n        );\n      };\n      argMax = (context, attributes) => {\n        validateInputs3(context.inputs);\n        const argMinMaxOp = (input, output, axes) => {\n          const idxZero = [];\n          for (let k = 0; k < input.rank; k++) {\n            if (axes.indexOf(k) >= 0 || axes.length === 0) {\n              idxZero.push(`input_indices[${k}] = 0;`);\n            }\n          }\n          return [\n            `${idxZero.join(\"\\n\")}`,\n            `var value = ${input.getByIndices(\"input_indices\")};\nvar best_index : i32 = 0;`,\n            `if (${input.getByIndices(\"input_indices\")} ${attributes.selectLastIndex > 0 ? \">=\" : \">\"} value) {\n         value = ${input.getByIndices(\"input_indices\")};\n         best_index = i32(last_index);\n       }`,\n            \"\",\n            output.setByOffset(\"global_idx\", \"best_index\")\n          ];\n        };\n        context.compute(\n          createReduceProgramInfo(\n            \"argMax\",\n            { hint: attributes.cacheKey, inputDependencies: [\"rank\"] },\n            [context.inputs[0]],\n            argMinMaxOp,\n            [attributes.axis],\n            7 /* int64 */,\n            attributes.keepDims\n          ),\n          { inputs: [0] }\n        );\n      };\n      parseArgMinMaxAttributes = (attributes) => createAttributeWithCacheKey(attributes);\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/concat.ts\n  var validateInputs4, calculateInputIndexImpl, assignOutputData, createConcatProgramInfo, concat, parseConcatAttributes;\n  var init_concat = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/concat.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_attribute_with_cache_key();\n      init_common();\n      validateInputs4 = (inputs, axis) => {\n        if (!inputs || inputs.length < 1) {\n          throw new Error(\"too few inputs\");\n        }\n        const referenceIndex = 0;\n        const referenceInput = inputs[referenceIndex];\n        const inputType = referenceInput.dataType;\n        const inputRank = referenceInput.dims.length;\n        inputs.forEach((input, i) => {\n          if (i === referenceIndex) {\n            return;\n          }\n          if (input.dataType !== inputType) {\n            throw new Error(\"input tensors should be one type\");\n          }\n          if (input.dims.length !== inputRank) {\n            throw new Error(\"input tensors should have the same shape\");\n          }\n          input.dims.forEach((dim, i2) => {\n            if (i2 !== axis && dim !== referenceInput.dims[i2]) {\n              throw new Error(\"non concat dimensions must match\");\n            }\n          });\n        });\n      };\n      calculateInputIndexImpl = (numberOfTensors, sizeInConcatAxisStr) => `\n  fn calculateInputIndex(index: u32) -> u32 {\n    let sizeInConcatAxis = array<u32, ${numberOfTensors}u>(${sizeInConcatAxisStr});\n    for (var i: u32 = 0u; i < ${numberOfTensors}; i += 1u ) {\n      if (index < sizeInConcatAxis[i]) {\n        return i;\n      }\n    }\n    return ${numberOfTensors}u;\n  }`;\n      assignOutputData = (inputs, output) => {\n        const numberOfTensors = inputs.length;\n        const codeLines = [];\n        for (let i = 0; i < numberOfTensors; ++i) {\n          const returnSnippet = output.setByOffset(\"global_idx\", inputs[i].getByIndices(\"indices\"));\n          if (numberOfTensors === 1) {\n            codeLines.push(returnSnippet);\n          } else if (i === 0) {\n            codeLines.push(`if (inputIndex == ${i}u) { ${returnSnippet} }`);\n          } else if (i === numberOfTensors - 1) {\n            codeLines.push(`else { ${returnSnippet} }`);\n          } else {\n            codeLines.push(`else if (inputIndex == ${i}) { ${returnSnippet} }`);\n          }\n        }\n        return codeLines.join(\"\\n\");\n      };\n      createConcatProgramInfo = (inputs, adjustedAxis, outputShape, dataType) => {\n        const outputSize = ShapeUtil.size(outputShape);\n        const sizeInConcatAxis = new Array(inputs.length);\n        const inputVars = new Array(inputs.length);\n        let previousSum = 0;\n        const inputDependencies = [];\n        const inputRanks = [];\n        const programUniforms = [{ type: 12 /* uint32 */, data: outputSize }];\n        for (let i = 0; i < inputs.length; ++i) {\n          previousSum += inputs[i].dims[adjustedAxis];\n          sizeInConcatAxis[i] = previousSum;\n          inputRanks.push(inputs[i].dims.length);\n          inputVars[i] = inputVariable(`input${i}`, dataType, inputRanks[i]);\n          inputDependencies.push(\"rank\");\n          programUniforms.push({ type: 12 /* uint32 */, data: sizeInConcatAxis[i] });\n        }\n        for (let i = 0; i < inputs.length; ++i) {\n          programUniforms.push(...createTensorShapeVariables(inputs[i].dims));\n        }\n        programUniforms.push(...createTensorShapeVariables(outputShape));\n        const output = outputVariable(\"output\", dataType, outputShape.length);\n        const indicesAxis = output.indicesGet(\"indices\", adjustedAxis);\n        const sizeInConcatAxisStr = Array.from(Array(sizeInConcatAxis.length).keys()).map((i) => `uniforms.sizeInConcatAxis${i}`).join(\",\");\n        const getShaderSource = (shaderHelper) => `\n\n  ${(() => {\n          shaderHelper.registerUniform(\"outputSize\", \"u32\");\n          for (let i = 0; i < inputs.length; i++) {\n            shaderHelper.registerUniform(`sizeInConcatAxis${i}`, \"u32\");\n          }\n          return shaderHelper.declareVariables(...inputVars, output);\n        })()}\n\n  ${calculateInputIndexImpl(sizeInConcatAxis.length, sizeInConcatAxisStr)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.outputSize\")}\n\n    var indices = ${output.offsetToIndices(\"global_idx\")};\n\n    let inputIndex = calculateInputIndex(${indicesAxis});\n    if (inputIndex != 0u) {\n      let sizeInConcatAxis = array<u32, ${sizeInConcatAxis.length}u>(${sizeInConcatAxisStr});\n      ${indicesAxis} -= sizeInConcatAxis[inputIndex - 1u];\n    }\n\n    ${assignOutputData(inputVars, output)}\n  }`;\n        return {\n          name: \"Concat\",\n          shaderCache: { hint: `${adjustedAxis}`, inputDependencies },\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType }],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64\n              /* workgroup size */\n            ) },\n            programUniforms\n          }),\n          getShaderSource\n        };\n      };\n      concat = (context, attributes) => {\n        const inputs = context.inputs;\n        const inputShape = inputs[0].dims;\n        const adjustedAxis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);\n        validateInputs4(inputs, adjustedAxis);\n        const outputShape = inputShape.slice();\n        outputShape[adjustedAxis] = inputs.reduce((sum, input) => sum + (input.dims.length > adjustedAxis ? input.dims[adjustedAxis] : 0), 0);\n        const nonEmptyInputs = inputs.filter((input) => ShapeUtil.size(input.dims) > 0);\n        context.compute(\n          createConcatProgramInfo(nonEmptyInputs, adjustedAxis, outputShape, inputs[0].dataType),\n          { inputs: nonEmptyInputs }\n        );\n      };\n      parseConcatAttributes = (attributes) => createAttributeWithCacheKey({ axis: attributes.axis });\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/attention.ts\n  var validateAttentionInputs, createInPlaceSoftmaxProgramInfo, createAttentionProbsProgramInfo, createVxAttentionScoreProgramInfo, applyAttention, prepare, attention;\n  var init_attention = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/attention.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_types();\n      init_common();\n      init_concat();\n      validateAttentionInputs = (inputs, attributes) => {\n        const input = inputs[0];\n        const weights = inputs[1];\n        const bias = inputs[2];\n        const maskIndex = inputs[3];\n        const past = inputs[4];\n        const relativePositionBias = inputs[5];\n        if (past && relativePositionBias) {\n          throw new Error(\"Attention cannot have both past and relative_position_bias\");\n        }\n        if (input.dims.length !== 3) {\n          throw new Error('Input \"input\" must have 3 dimensions');\n        }\n        const batchSize = input.dims[0];\n        const sequenceLength = input.dims[1];\n        const inputHiddenSize = input.dims[2];\n        if (bias.dims.length !== 1) {\n          throw new Error('Input \"bias\" is expected to have 1 dimensions');\n        }\n        if (weights.dims.length !== 2) {\n          throw new Error('Input \"weights\" is expected to have 2 dimensions');\n        }\n        if (weights.dims[0] !== inputHiddenSize) {\n          throw new Error(\"Input 1 dimension 0 should have same length as dimension 2 of input 0\");\n        }\n        if (bias.dims[0] !== weights.dims[1]) {\n          throw new Error('Input \"bias\" dimension 0 should have same length as dimension 1 of input \"weights\"');\n        }\n        let qHiddenSize = bias.dims[0] / 3;\n        let kHiddenSize = qHiddenSize;\n        let vHiddenSize = kHiddenSize;\n        if (attributes.qkvHiddenSizes.length > 0) {\n          if (attributes.qkvHiddenSizes.length !== 3) {\n            throw new Error(\"qkv_hidden_sizes attribute should have 3 elements\");\n          }\n          for (const sz of attributes.qkvHiddenSizes) {\n            if (sz % attributes.numHeads !== 0) {\n              throw new Error(\"qkv_hidden_sizes should be divisible by num_heads\");\n            }\n          }\n          qHiddenSize = attributes.qkvHiddenSizes[0];\n          kHiddenSize = attributes.qkvHiddenSizes[1];\n          vHiddenSize = attributes.qkvHiddenSizes[2];\n        }\n        const kvSequenceLength = sequenceLength;\n        if (qHiddenSize !== kHiddenSize) {\n          throw new Error(\"qkv_hidden_sizes first element should be same as the second\");\n        }\n        if (bias.dims[0] !== qHiddenSize + kHiddenSize + vHiddenSize) {\n          throw new Error('Input \"bias\" dimension 0 should have same length as sum of Q/K/V hidden sizes');\n        }\n        let pastSequenceLength = 0;\n        if (past) {\n          if (kHiddenSize !== vHiddenSize) {\n            throw new Error('Input \"past\" expect k_hidden_size == v_hidden_size');\n          }\n          if (past.dims.length !== 5) {\n            throw new Error('Input \"past\" must have 5 dimensions');\n          }\n          if (past.dims[0] !== 2) {\n            throw new Error('Input \"past\" first dimension must be 2');\n          }\n          if (past.dims[1] !== batchSize) {\n            throw new Error('Input \"past\" second dimension must be batch_size');\n          }\n          if (past.dims[2] !== attributes.numHeads) {\n            throw new Error('Input \"past\" third dimension must be num_heads');\n          }\n          if (past.dims[4] !== kHiddenSize / attributes.numHeads) {\n            throw new Error('Input \"past\" fifth dimension must be k_hidden_size / num_heads');\n          }\n          if (!attributes.pastPresentShareBuffer) {\n            pastSequenceLength = past.dims[3];\n          }\n        }\n        const totalSequenceLength = kvSequenceLength + pastSequenceLength;\n        const maxSequenceLength = -1;\n        const maskType = 0 /* none */;\n        if (maskIndex) {\n          throw new Error(\"Mask not supported\");\n        }\n        if (past) {\n          throw new Error(\"past is not supported\");\n        }\n        return {\n          batchSize,\n          sequenceLength,\n          pastSequenceLength,\n          kvSequenceLength,\n          totalSequenceLength,\n          maxSequenceLength,\n          inputHiddenSize,\n          hiddenSize: qHiddenSize,\n          vHiddenSize,\n          headSize: Math.floor(qHiddenSize / attributes.numHeads),\n          vHeadSize: Math.floor(vHiddenSize / attributes.numHeads),\n          numHeads: attributes.numHeads,\n          isUnidirectional: false,\n          pastPresentShareBuffer: false,\n          maskFilterValue: attributes.maskFilterValue,\n          maskType,\n          scale: attributes.scale,\n          broadcastResPosBias: false,\n          passPastInKv: false,\n          qkvFormat: 1 /* qkvBNSH */\n        };\n      };\n      createInPlaceSoftmaxProgramInfo = (_context, input, n, d) => {\n        const components = getMaxComponents(d);\n        let WG = 64;\n        const dComp = d / components;\n        if (dComp < WG) {\n          WG = 1;\n        } else if (dComp / 8 < 64) {\n          WG = Math.ceil(dComp / 8);\n        }\n        const elementsPerThread = Math.ceil(d / components / WG);\n        const programUniforms = [\n          { type: input.dataType, data: 1 / d },\n          { type: 12 /* uint32 */, data: dComp },\n          { type: 12 /* uint32 */, data: elementsPerThread }\n        ];\n        const dataType = tensorTypeToWsglStorageType(input.dataType, components);\n        const f32Type = tensorTypeToWsglValueType(1 /* float */, components);\n        const getShaderSource = (shaderHelper) => {\n          const inputHelper = outputVariable(\"x\", input.dataType, input.dims, components);\n          const elemValueType = tensorTypeToWsglValueType(input.dataType);\n          const uniforms = [\n            { name: \"d_inv\", type: elemValueType },\n            { name: \"d_comp\", type: \"u32\" },\n            { name: \"elements_per_thread\", type: \"u32\" }\n          ];\n          return `\n  var<workgroup> thread_max: array<f32, ${WG}>;\n  var<workgroup> thread_sum: array<f32, ${WG}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(inputHelper)}\n  ${shaderHelper.mainStart([\n            WG,\n            1,\n            1\n          ])}\n    let local_offset = local_idx * uniforms.elements_per_thread;\n    let offset = workgroup_id.x * uniforms.d_comp + local_offset;\n\n    var thread_max_vector = ${f32Type}(-3.402823e+38f);\n    for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n      thread_max_vector = max(${f32Type}(x[offset + i]), thread_max_vector);\n    }\n    thread_max[local_idx] = ${(() => {\n            switch (components) {\n              case 1:\n                return \"thread_max_vector\";\n              case 2:\n                return \"max(thread_max_vector.x, thread_max_vector.y)\";\n              case 4:\n                return \"max(max(thread_max_vector.x, thread_max_vector.y), max(thread_max_vector.z, thread_max_vector.w))\";\n              default:\n                throw new Error(`Unsupported components: ${components}`);\n            }\n          })()};\n    workgroupBarrier();\n\n    var max_value =  f32(-3.402823e+38f);\n    for (var i = 0u; i < ${WG}; i++) {\n      max_value = max(thread_max[i], max_value);\n    }\n\n    var sum_vector = ${f32Type}(0);\n    for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n      sum_vector += exp(${f32Type}(x[offset + i]) - max_value);\n    }\n    thread_sum[local_idx] = ${(() => {\n            switch (components) {\n              case 1:\n                return \"sum_vector\";\n              case 2:\n                return \"sum_vector.x + sum_vector.y\";\n              case 4:\n                return \"sum_vector.x + sum_vector.y + sum_vector.z + sum_vector.w\";\n              default:\n                throw new Error(`Unsupported components: ${components}`);\n            }\n          })()};\n    workgroupBarrier();\n\n    var sum: f32 = 0;\n    for (var i = 0u; i < ${WG}; i++) {\n      sum += thread_sum[i];\n    }\n\n    if (sum == 0) {\n      for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n        x[offset + i] = ${inputHelper.type.value}(uniforms.d_inv);\n      }\n    } else {\n      for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n        var f32input = ${f32Type}(x[offset + i]);\n        x[offset + i] = ${inputHelper.type.value}(exp(f32input - max_value) / sum);\n      }\n    }\n  }`;\n        };\n        return {\n          name: \"AttentionProbsSoftmax\",\n          shaderCache: { hint: `${WG};${dataType};${components}` },\n          getShaderSource,\n          getRunData: () => ({ outputs: [], dispatchGroup: { x: n }, programUniforms })\n        };\n      };\n      createAttentionProbsProgramInfo = (_context, q, key, relativePositionBias, parameters, attributes, pastSequenceLength) => {\n        const totalSequenceLength = pastSequenceLength + parameters.kvSequenceLength;\n        const probsShape = [parameters.batchSize, parameters.numHeads, parameters.sequenceLength, totalSequenceLength];\n        const alpha = attributes.scale === 0 ? 1 / Math.sqrt(parameters.headSize) : attributes.scale;\n        const components = getMaxComponents(parameters.headSize);\n        const vectorizedHeadSize = parameters.headSize / components;\n        const TILE_SIZE = 12;\n        const dispatch = {\n          x: Math.ceil(totalSequenceLength / TILE_SIZE),\n          y: Math.ceil(parameters.sequenceLength / TILE_SIZE),\n          z: parameters.batchSize * parameters.numHeads\n        };\n        const programUniforms = [\n          { type: 12 /* uint32 */, data: parameters.sequenceLength },\n          { type: 12 /* uint32 */, data: vectorizedHeadSize },\n          { type: 12 /* uint32 */, data: totalSequenceLength },\n          { type: 12 /* uint32 */, data: parameters.numHeads },\n          { type: 1 /* float */, data: alpha }\n        ];\n        const inputDependencies = [\"type\", \"type\"];\n        if (relativePositionBias) {\n          inputDependencies.push(\"rank\");\n          programUniforms.push(...createTensorShapeVariables(relativePositionBias.dims));\n        }\n        const getShaderSource = (shaderHelper) => {\n          const qInput = inputVariable(\"q\", q.dataType, q.dims, components);\n          const kInput = inputVariable(\"key\", key.dataType, key.dims, components);\n          const inputVars = [qInput, kInput];\n          const relativePositionBiasInput = relativePositionBias ? inputVariable(\"relative_position_bias\", relativePositionBias.dataType, relativePositionBias.dims.length) : void 0;\n          if (relativePositionBiasInput) {\n            inputVars.push(relativePositionBiasInput);\n          }\n          const output = outputVariable(\"output\", q.dataType, probsShape);\n          const f32Type = tensorTypeToWsglValueType(1 /* float */, components);\n          const uniforms = [\n            { name: \"M\", type: \"u32\" },\n            { name: \"K\", type: \"u32\" },\n            { name: \"N\", type: \"u32\" },\n            { name: \"num_heads\", type: \"u32\" },\n            { name: \"alpha\", type: \"f32\" }\n          ];\n          return `\n  const TILE_SIZE = ${TILE_SIZE}u;\n\n  var<workgroup> tileQ: array<${qInput.type.storage}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileK: array<${qInput.type.storage}, ${TILE_SIZE * TILE_SIZE}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}\n  ${shaderHelper.mainStart([\n            TILE_SIZE,\n            TILE_SIZE,\n            1\n          ])}\n    // x holds the N and y holds the M\n    let headIdx = workgroup_id.z;\n    let m = workgroup_id.y * TILE_SIZE;\n    let n = workgroup_id.x * TILE_SIZE;\n    let qOffset = uniforms.M * uniforms.K * headIdx + m * uniforms.K;\n    let kOffset = uniforms.N * uniforms.K * headIdx + n * uniforms.K;\n\n    var value = ${f32Type}(0);\n    for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n      if (global_id.y < uniforms.M && w + local_id.x < uniforms.K) {\n        tileQ[TILE_SIZE * local_id.y + local_id.x] = q[qOffset + local_id.y * uniforms.K + w + local_id.x];\n      }\n      if (n + local_id.y < uniforms.N && w + local_id.x < uniforms.K) {\n        tileK[TILE_SIZE * local_id.y + local_id.x] = key[kOffset + local_id.y * uniforms.K + w + local_id.x];\n      }\n      workgroupBarrier();\n\n      for (var k: u32 = 0u; k < TILE_SIZE && w+k < uniforms.K; k++) {\n        value += ${f32Type}(tileQ[TILE_SIZE * local_id.y + k] * tileK[TILE_SIZE * local_id.x + k]);\n      }\n\n      workgroupBarrier();\n    }\n\n    let headOffset = headIdx * uniforms.M * uniforms.N;\n    if (global_id.y < uniforms.M && global_id.x < uniforms.N) {\n      let outputIdx = headOffset + global_id.y * uniforms.N + global_id.x;\n      var sum: f32 = ${(() => {\n            switch (components) {\n              case 1:\n                return \"value\";\n              case 2:\n                return \"value.x + value.y\";\n              case 4:\n                return \"value.x + value.y + value.z + value.w\";\n              default:\n                throw new Error(`Unsupported components: ${components}`);\n            }\n          })()};\n\n  ${(() => {\n            if (relativePositionBiasInput) {\n              return `\n      let batch = workgroup_id.z / uniforms.num_heads;\n      let head = workgroup_id.z % uniforms.num_heads;\n      var indices = ${relativePositionBiasInput.type.indices}(batch, head, global_id.y, global_id.x);\n      output[outputIdx] = ${output.type.value}(sum * uniforms.alpha) + ${relativePositionBiasInput.getByIndices(\"indices\")};`;\n            }\n            return `output[outputIdx] = ${output.type.value} (sum * uniforms.alpha);`;\n          })()}\n    }\n  }`;\n        };\n        return {\n          name: \"AttentionProbs\",\n          shaderCache: { hint: `${components}`, inputDependencies },\n          getRunData: () => ({\n            outputs: [{ dims: probsShape, dataType: q.dataType, gpuDataType: 0 /* default */ }],\n            dispatchGroup: dispatch,\n            programUniforms\n          }),\n          getShaderSource\n        };\n      };\n      createVxAttentionScoreProgramInfo = (_context, probs, v, params, pastSequenceLength) => {\n        const totalSequenceLength = pastSequenceLength + params.kvSequenceLength;\n        const outputShape = [params.batchSize, params.sequenceLength, params.vHiddenSize];\n        const TILE_SIZE = 12;\n        const dispatch = {\n          x: Math.ceil(params.vHeadSize / TILE_SIZE),\n          y: Math.ceil(params.sequenceLength / TILE_SIZE),\n          z: params.batchSize * params.numHeads\n        };\n        const programUniforms = [\n          { type: 12 /* uint32 */, data: params.sequenceLength },\n          { type: 12 /* uint32 */, data: totalSequenceLength },\n          { type: 12 /* uint32 */, data: params.vHeadSize },\n          { type: 12 /* uint32 */, data: params.numHeads },\n          { type: 12 /* uint32 */, data: params.vHiddenSize }\n        ];\n        const inputDependencies = [\"type\", \"type\"];\n        const getShaderSource = (shaderHelper) => {\n          const probsHelper = inputVariable(\"probs\", probs.dataType, probs.dims);\n          const vHelper = inputVariable(\"v\", v.dataType, v.dims);\n          const output = outputVariable(\"output\", probs.dataType, outputShape);\n          const uniforms = [\n            { name: \"M\", type: \"u32\" },\n            { name: \"K\", type: \"u32\" },\n            { name: \"N\", type: \"u32\" },\n            { name: \"num_heads\", type: \"u32\" },\n            { name: \"v_hidden_size\", type: \"u32\" }\n          ];\n          return `\n  const TILE_SIZE = ${TILE_SIZE}u;\n  var<workgroup> tileQ: array<${probsHelper.type.value}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileK: array<${probsHelper.type.value}, ${TILE_SIZE * TILE_SIZE}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(probsHelper, vHelper, output)}\n  ${shaderHelper.mainStart([\n            TILE_SIZE,\n            TILE_SIZE,\n            1\n          ])}\n   let headIdx = workgroup_id.z;\n   let m = global_id.y;\n   let n = global_id.x;\n\n   let offsetA = headIdx * (uniforms.M * uniforms.K) + m * uniforms.K;\n   let offsetB = headIdx * (uniforms.N * uniforms.K) + n;\n\n   var value = ${probsHelper.type.storage}(0);\n   for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n     if (m < uniforms.M && w + local_id.x < uniforms.K) {\n       tileQ[TILE_SIZE * local_id.y + local_id.x] = probs[offsetA + w + local_id.x];\n     }\n     if (n < uniforms.N && w + local_id.y < uniforms.K) {\n       tileK[TILE_SIZE * local_id.y + local_id.x] = v[offsetB + (w + local_id.y) * uniforms.N];\n     }\n     workgroupBarrier();\n     for (var k: u32 = 0u; k < TILE_SIZE && w+k < uniforms.K; k++) {\n       value += tileQ[TILE_SIZE * local_id.y + k] * tileK[TILE_SIZE * k + local_id.x];\n     }\n     workgroupBarrier();\n   }\n\n   // we need to transpose output from BNSH_v to BSND_v\n   let batchIdx = workgroup_id.z / uniforms.num_heads;\n   let currentBatchHeadNumber = workgroup_id.z % uniforms.num_heads;\n   if (m < uniforms.M && n < uniforms.N) {\n     let outputIdx = batchIdx * uniforms.M * uniforms.v_hidden_size + m * uniforms.v_hidden_size\n       + currentBatchHeadNumber * uniforms.N + n;\n     output[outputIdx] = value;\n   }\n  }`;\n        };\n        return {\n          name: \"AttentionScore\",\n          shaderCache: { inputDependencies },\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: probs.dataType, gpuDataType: 0 /* default */ }],\n            dispatchGroup: dispatch,\n            programUniforms\n          }),\n          getShaderSource\n        };\n      };\n      applyAttention = (context, q, k, v, _maskIndex, _past, pastKey, pastValue, relativePositionBias, parameters, attributes) => {\n        const outputPresentKey = context.outputCount > 1;\n        const outputPresentValue = context.outputCount > 2;\n        const pastSequenceLength = outputPresentKey && outputPresentValue ? parameters.pastSequenceLength : 0;\n        const totalSequenceLength = pastSequenceLength + parameters.kvSequenceLength;\n        const presentKeyShape = [parameters.batchSize, parameters.numHeads, totalSequenceLength, parameters.headSize];\n        const concatKeyInputs = pastKey ? [pastKey, k] : [k];\n        const key = outputPresentKey ? context.compute(\n          createConcatProgramInfo(concatKeyInputs, 2, presentKeyShape, k.dataType),\n          { inputs: concatKeyInputs, outputs: [1] }\n        )[0] : k;\n        const presentValueShape = [parameters.batchSize, parameters.numHeads, totalSequenceLength, parameters.headSize];\n        const concatValueInputs = pastValue ? [pastValue, v] : [v];\n        const value = outputPresentValue ? context.compute(\n          createConcatProgramInfo(concatValueInputs, 2, presentValueShape, v.dataType),\n          { inputs: concatValueInputs, outputs: [2] }\n        )[0] : v;\n        const inputsK = [q, key];\n        if (relativePositionBias) {\n          inputsK.push(relativePositionBias);\n        }\n        const probs = context.compute(\n          createAttentionProbsProgramInfo(\n            context,\n            q,\n            key,\n            relativePositionBias,\n            parameters,\n            attributes,\n            pastSequenceLength\n          ),\n          { inputs: inputsK, outputs: [-1] }\n        )[0];\n        context.compute(\n          createInPlaceSoftmaxProgramInfo(\n            context,\n            probs,\n            parameters.batchSize * parameters.numHeads * parameters.sequenceLength,\n            totalSequenceLength\n          ),\n          { inputs: [probs], outputs: [] }\n        );\n        const inputsV = [probs, value];\n        context.compute(\n          createVxAttentionScoreProgramInfo(context, probs, value, parameters, pastSequenceLength),\n          { inputs: inputsV, outputs: [0] }\n        );\n      };\n      prepare = (context, parameters) => {\n        const outputShape = [\n          parameters.batchSize,\n          parameters.numHeads,\n          parameters.sequenceLength,\n          parameters.headSize\n        ];\n        const M = parameters.sequenceLength;\n        const K = parameters.inputHiddenSize;\n        const N = parameters.headSize;\n        const TILE_SIZE = 12;\n        const dispatch = {\n          x: Math.ceil(parameters.headSize / TILE_SIZE),\n          y: Math.ceil(parameters.sequenceLength / TILE_SIZE),\n          z: parameters.batchSize * parameters.numHeads\n        };\n        const inputs = [context.inputs[0], context.inputs[1], context.inputs[2]];\n        const programUniforms = [\n          { type: 12 /* uint32 */, data: M },\n          { type: 12 /* uint32 */, data: K },\n          { type: 12 /* uint32 */, data: N },\n          { type: 12 /* uint32 */, data: parameters.numHeads },\n          { type: 12 /* uint32 */, data: parameters.headSize },\n          { type: 12 /* uint32 */, data: parameters.hiddenSize },\n          { type: 12 /* uint32 */, data: parameters.hiddenSize + parameters.hiddenSize + parameters.vHiddenSize }\n        ];\n        const getShaderSource = (shaderHelper) => {\n          const outputQ = outputVariable(\"output_q\", inputs[0].dataType, outputShape);\n          const outputK = outputVariable(\"output_k\", inputs[0].dataType, outputShape);\n          const outputV = outputVariable(\"output_v\", inputs[0].dataType, outputShape);\n          const input = inputVariable(\"input\", inputs[0].dataType, inputs[0].dims);\n          const weight = inputVariable(\"weight\", inputs[1].dataType, inputs[1].dims);\n          const bias = inputVariable(\"bias\", inputs[2].dataType, inputs[2].dims);\n          const dataType = input.type.storage;\n          const uniforms = [\n            { name: \"M\", type: \"u32\" },\n            { name: \"K\", type: \"u32\" },\n            { name: \"N\", type: \"u32\" },\n            { name: \"num_heads\", type: \"u32\" },\n            { name: \"head_size\", type: \"u32\" },\n            { name: \"hidden_size\", type: \"u32\" },\n            { name: \"ldb\", type: \"u32\" }\n          ];\n          return `\n  const TILE_SIZE = ${TILE_SIZE}u;\n  var<workgroup> tileInput: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileWeightQ: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileWeightK: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileWeightV: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(input, weight, bias, outputQ, outputK, outputV)}\n  ${shaderHelper.mainStart([\n            TILE_SIZE,\n            TILE_SIZE,\n            1\n          ])}\n    let batchIndex = workgroup_id.z / uniforms.num_heads;\n    let headNumber = workgroup_id.z % uniforms.num_heads;\n    let m = global_id.y;\n    let n = global_id.x;\n\n    let inputOffset = batchIndex * (uniforms.M * uniforms.K) + m * uniforms.K;\n    let biasOffsetQ = headNumber * uniforms.head_size;\n    let biasOffsetK = uniforms.hidden_size + biasOffsetQ;\n    let biasOffsetV = uniforms.hidden_size + biasOffsetK;\n\n    var valueQ = ${dataType}(0);\n    var valueK = ${dataType}(0);\n    var valueV = ${dataType}(0);\n    for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n      if (m < uniforms.M && w + local_id.x < uniforms.K) {\n        tileInput[TILE_SIZE * local_id.y + local_id.x] = input[inputOffset + w + local_id.x];\n      }\n      if (n < uniforms.N && w + local_id.y < uniforms.K) {\n        let offset = n + (w + local_id.y) * uniforms.ldb;\n        tileWeightQ[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetQ + offset];\n        tileWeightK[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetK + offset];\n        tileWeightV[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetV + offset];\n      }\n      workgroupBarrier();\n      for (var k: u32 = 0u; k<TILE_SIZE && w+k < uniforms.K; k++) {\n        let inputTileOffset = TILE_SIZE * local_id.y + k;\n        let weightTileOffset = TILE_SIZE * k + local_id.x;\n        valueQ += tileInput[inputTileOffset] * tileWeightQ[weightTileOffset];\n        valueK += tileInput[inputTileOffset] * tileWeightK[weightTileOffset];\n        valueV += tileInput[inputTileOffset] * tileWeightV[weightTileOffset];\n      }\n\n      workgroupBarrier();\n    }\n\n    let headOffset = (m * uniforms.N + n) % uniforms.head_size;\n    valueQ += bias[headOffset + biasOffsetQ];\n    valueK += bias[headOffset + biasOffsetK];\n    valueV += bias[headOffset + biasOffsetV];\n\n    let offset = workgroup_id.z * uniforms.M * uniforms.N;\n    if (m < uniforms.M && n < uniforms.N) {\n      let outputIdx = offset + m * uniforms.N + n;\n      output_q[outputIdx] = valueQ;\n      output_k[outputIdx] = valueK;\n      output_v[outputIdx] = valueV;\n    }\n  }`;\n        };\n        return context.compute(\n          {\n            name: \"AttentionPrepare\",\n            shaderCache: { inputDependencies: [\"type\", \"type\", \"type\"] },\n            getRunData: () => ({\n              outputs: [\n                { dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: 0 /* default */ },\n                { dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: 0 /* default */ },\n                { dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: 0 /* default */ }\n              ],\n              dispatchGroup: dispatch,\n              programUniforms\n            }),\n            getShaderSource\n          },\n          { inputs, outputs: [-1, -1, -1] }\n        );\n      };\n      attention = (context, attributes) => {\n        const params = validateAttentionInputs(context.inputs, attributes);\n        const [q, k, v] = prepare(context, params);\n        return applyAttention(\n          context,\n          q,\n          k,\n          v,\n          context.inputs[4],\n          void 0,\n          void 0,\n          void 0,\n          context.inputs[5],\n          params,\n          attributes\n        );\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/batch-norm.ts\n  var validateInputs5, createBatchNormInferenceProgramInfo, parseBatchNormAttributes, batchNorm;\n  var init_batch_norm = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/batch-norm.ts\"() {\n      \"use strict\";\n      init_esm();\n      init_wasm_common();\n      init_util();\n      init_attribute_with_cache_key();\n      init_common();\n      validateInputs5 = (inputs, attributes) => {\n        if (!inputs || inputs.length !== 5) {\n          throw new Error(\"BatchNormalization requires 5 inputs\");\n        }\n        const checkShapeEqual = (actual, expected, message) => {\n          const r = expected.length;\n          if (r !== actual.length) {\n            throw new Error(`${message}: num dimensions != ${r}`);\n          }\n          expected.forEach((v, i) => {\n            if (v !== actual[i]) {\n              throw new Error(`${message}: dim[${i}] do not match`);\n            }\n          });\n        };\n        if (inputs[0].dims.length > 1) {\n          const shape = attributes.format === \"NHWC\" ? attributes.spatial ? inputs[0].dims.slice(-1) : inputs[0].dims.slice(-1).concat(inputs[0].dims.slice(1, inputs[0].dims.length - 1)) : inputs[0].dims.slice(1, attributes.spatial ? 2 : void 0);\n          checkShapeEqual(inputs[1].dims, shape, \"Invalid input scale\");\n          checkShapeEqual(inputs[2].dims, shape, \"Invalid input B\");\n          checkShapeEqual(inputs[3].dims, shape, \"Invalid input mean\");\n          checkShapeEqual(inputs[4].dims, shape, \"Invalid input var\");\n        } else {\n          checkShapeEqual(inputs[1].dims, [1], \"Invalid input scale\");\n          checkShapeEqual(inputs[2].dims, [1], \"Invalid input B\");\n          checkShapeEqual(inputs[3].dims, [1], \"Invalid input mean\");\n          checkShapeEqual(inputs[4].dims, [1], \"Invalid input var\");\n        }\n      };\n      createBatchNormInferenceProgramInfo = (inputs, attributes) => {\n        const { epsilon, spatial, format } = attributes;\n        const yShape = inputs[0].dims;\n        const components = spatial ? getMaxComponents(yShape[yShape.length - 1]) : 1;\n        const cComponents = format === \"NHWC\" && yShape.length > 1 ? components : 1;\n        const outputSize = ShapeUtil.size(yShape) / components;\n        const useShapesUniforms = spatial;\n        const shapeOrRank = useShapesUniforms ? yShape.length : yShape;\n        const x = inputVariable(\"x\", inputs[0].dataType, inputs[0].dims, components);\n        const scale = inputVariable(\"scale\", inputs[1].dataType, inputs[1].dims, cComponents);\n        const bias = inputVariable(\"bias\", inputs[2].dataType, inputs[2].dims, cComponents);\n        const inputMean = inputVariable(\"inputMean\", inputs[3].dataType, inputs[3].dims, cComponents);\n        const inputVar = inputVariable(\"inputVar\", inputs[4].dataType, inputs[4].dims, cComponents);\n        const y = outputVariable(\"y\", inputs[0].dataType, shapeOrRank, components);\n        const calcCOffset = () => {\n          let cOffset = \"\";\n          if (spatial) {\n            cOffset = `let cOffset = ${yShape.length === 1 ? \"0u\" : format === \"NHWC\" ? `outputIndices[${yShape.length - 1}] / ${components}` : \"outputIndices[1]\"};`;\n          } else {\n            if (format === \"NCHW\") {\n              cOffset = `\n            ${y.indicesSet(\"outputIndices\", \"0\", \"0\")}\n            let cOffset = ${y.indicesToOffset(\"outputIndices\")};`;\n            } else {\n              cOffset = `var cIndices = ${scale.type.indices}(0);\n                       cIndices[0] = outputIndices[${yShape.length - 1}];`;\n              for (let i = 1; i < scale.rank; i++) {\n                cOffset += `cIndices[${i}] = outputIndices[${i}];`;\n              }\n              cOffset += `let cOffset = ${scale.indicesToOffset(\"cIndices\")};`;\n            }\n          }\n          return cOffset;\n        };\n        const getInferenceModeShaderSource = (helper) => `\n  const epsilon = ${epsilon};\n  ${helper.registerUniform(\"outputSize\", \"u32\").declareVariables(x, scale, bias, inputMean, inputVar, y)}\n  ${helper.mainStart()}\n  ${helper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.outputSize\")}\n    var outputIndices = ${y.offsetToIndices(`global_idx * ${components}`)};\n    ${calcCOffset()}\n    let scale = ${scale.getByOffset(\"cOffset\")};\n    let bias = ${bias.getByOffset(\"cOffset\")};\n    let inputMean = ${inputMean.getByOffset(\"cOffset\")};\n    let inputVar = ${inputVar.getByOffset(\"cOffset\")};\n    let x = ${x.getByOffset(\"global_idx\")};\n    let value = (x - inputMean) * inverseSqrt(inputVar + epsilon) * scale + bias;\n    ${y.setByOffset(\"global_idx\", \"value\")}\n  }`;\n        return {\n          name: \"BatchNormalization\",\n          shaderCache: {\n            hint: `${attributes.epsilon}_${attributes.format}_${spatial}_${components}`,\n            inputDependencies: useShapesUniforms ? [\"rank\", \"type\", \"type\", \"type\", \"type\"] : void 0\n          },\n          getShaderSource: getInferenceModeShaderSource,\n          getRunData: () => ({\n            outputs: [{ dims: inputs[0].dims, dataType: inputs[0].dataType }],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64\n              /* workgroup size */\n            ) },\n            programUniforms: useShapesUniforms ? [\n              { type: 12 /* uint32 */, data: outputSize },\n              ...createTensorShapeVariables(yShape)\n            ] : [\n              { type: 12 /* uint32 */, data: outputSize }\n            ]\n          })\n        };\n      };\n      parseBatchNormAttributes = (attributes) => createAttributeWithCacheKey(attributes);\n      batchNorm = (context, attributes) => {\n        const { inputs, outputCount } = context;\n        const updatedAttributes = parseBatchNormAttributes({ ...attributes, outputCount });\n        if (env2.webgpu.validateInputContent) {\n          validateInputs5(inputs, updatedAttributes);\n        }\n        if (attributes.trainingMode) {\n          throw new Error(\"BatchNormalization trainingMode is not supported yet.\");\n        } else {\n          context.compute(createBatchNormInferenceProgramInfo(inputs, updatedAttributes));\n        }\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/bias-add.ts\n  var validateInputs6, createBiasAddProgramInfo, biasAdd;\n  var init_bias_add = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/bias-add.ts\"() {\n      \"use strict\";\n      init_util();\n      init_common();\n      validateInputs6 = (inputs) => {\n        if (inputs[0].dims.length !== 3) {\n          throw new Error(\"input should have 3 dimensions\");\n        }\n        if (![320, 640, 1280].includes(inputs[0].dims[2])) {\n          throw new Error(\"number of channels should be 320, 640 or 1280\");\n        }\n        if (inputs[1].dims.length !== 1) {\n          throw new Error(\"bias is expected to have 1 dimensions\");\n        }\n        if (inputs[0].dims[2] !== inputs[1].dims[0]) {\n          throw new Error(\"last dimension of input and bias are not the same\");\n        }\n      };\n      createBiasAddProgramInfo = (inputs) => {\n        const outputShape = inputs[0].dims;\n        const channels = inputs[0].dims[2];\n        const outputSize = ShapeUtil.size(outputShape) / 4;\n        const dataType = inputs[0].dataType;\n        const input = inputVariable(\"input\", dataType, outputShape, 4);\n        const bias = inputVariable(\"bias\", dataType, [channels], 4);\n        const residual = inputVariable(\"residual\", dataType, outputShape, 4);\n        const output = outputVariable(\"output\", dataType, outputShape, 4);\n        const getShaderSource = (shaderHelper) => `\n  const channels = ${channels}u / 4;\n  ${shaderHelper.declareVariables(input, bias, residual, output)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}\n    let value = ${input.getByOffset(\"global_idx\")}\n      + ${bias.getByOffset(\"global_idx % channels\")} + ${residual.getByOffset(\"global_idx\")};\n    ${output.setByOffset(\"global_idx\", \"value\")}\n  }`;\n        return {\n          name: \"BiasAdd\",\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64\n              /* workgroup size */\n            ) }\n          }),\n          getShaderSource\n        };\n      };\n      biasAdd = (context) => {\n        validateInputs6(context.inputs);\n        context.compute(createBiasAddProgramInfo(context.inputs));\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/unary-op.ts\n  var createElementwiseProgramShader, createElementwiseProgramInfo, abs, acos, acosh, asin, asinh, atan, atanh, parseCastAttributes, cast, generateClipAttributesFromInputs, clip, ceil, cos, cosh, parseAlphaAttributes, elu, erfImpl, erf, exp, floor, gelu, leakyRelu, not, neg, reciprocal, relu, sigmoid, parseHardSigmoidAttributes, hardSigmoid, sin, sinh, sqrt, tan, tanhExpression, tanh, fastGeluImpl, fastGeluExpression, fastGelu, thresholdedRelu, log;\n  var init_unary_op = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/unary-op.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_attribute_with_cache_key();\n      init_common();\n      createElementwiseProgramShader = (shaderHelper, datasize, inputDataType, outputDataType, funcCall, additionalImplementation) => {\n        const vecSize = Math.ceil(datasize / 4);\n        let expression = \"\";\n        if (typeof funcCall === \"string\") {\n          expression = `${funcCall}(a)`;\n        } else {\n          expression = funcCall(\"a\");\n        }\n        const input = inputVariable(\"inputData\", inputDataType, [vecSize], 4);\n        const output = outputVariable(\"outputData\", outputDataType, [vecSize], 4);\n        return `\n      ${shaderHelper.registerUniform(\"vec_size\", \"u32\").declareVariables(input, output)}\n\n  ${additionalImplementation ?? \"\"}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.vec_size\")}\n\n    let a = ${input.getByOffset(\"global_idx\")};\n    ${output.setByOffset(\"global_idx\", expression)}\n  }`;\n      };\n      createElementwiseProgramInfo = (input, name, funcCall, additionalImplementation, cacheKey, outputDataType = input.dataType) => ({\n        name,\n        shaderCache: { hint: cacheKey, inputDependencies: [\"type\"] },\n        getShaderSource: (shaderHelper) => createElementwiseProgramShader(\n          shaderHelper,\n          ShapeUtil.size(input.dims),\n          input.dataType,\n          outputDataType,\n          funcCall,\n          additionalImplementation\n        ),\n        getRunData: (inputTensors) => ({\n          outputs: [{ dims: input.dims, dataType: outputDataType }],\n          dispatchGroup: { x: Math.ceil(\n            ShapeUtil.size(inputTensors[0].dims) / 64 / 4\n            /* vec size */\n          ) },\n          programUniforms: [\n            { type: 12 /* uint32 */, data: Math.ceil(ShapeUtil.size(input.dims) / 4) }\n          ]\n        })\n      });\n      abs = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Abs\", \"abs\"));\n      };\n      acos = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Acos\", \"acos\"));\n      };\n      acosh = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Acosh\", \"acosh\"));\n      };\n      asin = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Asin\", \"asin\"));\n      };\n      asinh = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Asinh\", \"asinh\"));\n      };\n      atan = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Atan\", \"atan\"));\n      };\n      atanh = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Atanh\", \"atanh\"));\n      };\n      parseCastAttributes = (attributes) => createAttributeWithCacheKey(attributes);\n      cast = (context, attributes) => {\n        let func;\n        switch (attributes.to) {\n          case 10 /* float16 */:\n            func = \"vec4<f16>\";\n            break;\n          case 1 /* float */:\n            func = \"vec4<f32>\";\n            break;\n          case 12 /* uint32 */:\n            func = \"vec4<u32>\";\n            break;\n          case 6 /* int32 */:\n            func = \"vec4<i32>\";\n            break;\n          case 9 /* bool */:\n            func = \"vec4<bool>\";\n            break;\n          default:\n            throw new RangeError(`not supported type (specified in attribute 'to' from 'Cast' operator): ${attributes.to}`);\n        }\n        context.compute(\n          createElementwiseProgramInfo(context.inputs[0], \"Cast\", func, void 0, attributes.cacheKey, attributes.to)\n        );\n      };\n      generateClipAttributesFromInputs = (inputs) => {\n        const min = inputs.length >= 2 && inputs[1].data !== 0 ? inputs[1].getFloat32Array()[0] : MIN_CLIP;\n        const max = inputs.length >= 3 && inputs[2].data !== 0 ? inputs[2].getFloat32Array()[0] : MAX_CLIP;\n        return createAttributeWithCacheKey({ min, max });\n      };\n      clip = (context, clipAttributes) => {\n        const attributes = context.inputs.length === 1 ? clipAttributes : generateClipAttributesFromInputs(context.inputs);\n        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n        context.compute(\n          createElementwiseProgramInfo(\n            context.inputs[0],\n            \"Clip\",\n            (a) => `clamp(${a}, clip_min_, clip_max_)`,\n            `\n    const clip_min_: vec4<${dataType}> = vec4(${dataType}(${attributes.min}));\n    const clip_max_: vec4<${dataType}> = vec4(${dataType}(${attributes.max}));\n`,\n            attributes.cacheKey\n          ),\n          { inputs: [0] }\n        );\n      };\n      ceil = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Ceil\", \"ceil\"));\n      };\n      cos = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Cos\", \"cos\"));\n      };\n      cosh = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Cosh\", \"cosh\"));\n      };\n      parseAlphaAttributes = (attributes) => createAttributeWithCacheKey(attributes);\n      elu = (context, attributes) => {\n        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n        context.compute(createElementwiseProgramInfo(\n          context.inputs[0],\n          \"Elu\",\n          (a) => `elu_vf32(${a})`,\n          `\n  const elu_alpha_ = ${dataType}(${attributes.alpha});\n\n  fn elu_f32(a: ${dataType}) -> ${dataType} {\n  return select((exp(a) - 1.0) * elu_alpha_, a, a >= 0.0);\n  }\n\n  fn elu_vf32(v: vec4<${dataType}>) -> vec4<${dataType}> {\n  return vec4(elu_f32(v.x), elu_f32(v.y), elu_f32(v.z), elu_f32(v.w));\n  }`,\n          attributes.cacheKey\n        ));\n      };\n      erfImpl = (varType = \"f32\") => `\nconst r0: ${varType} = 0.3275911;\nconst r1: ${varType} = 0.254829592;\nconst r2: ${varType} = -0.284496736;\nconst r3: ${varType} = 1.421413741;\nconst r4: ${varType} = -1.453152027;\nconst r5: ${varType} = 1.061405429;\n\nfn erf_vf32(v: vec4<${varType}>) -> vec4<${varType}> {\n  let absv = abs(v);\n  let x = 1.0 / (1.0 + r0 * absv);\n  return sign(v) * (1.0 - ((((r5 * x + r4) * x + r3) * x + r2) * x + r1) * x * exp(-absv * absv));\n}`;\n      erf = (context) => {\n        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Erf\", (a) => `erf_vf32(${a})`, erfImpl(dataType)));\n      };\n      exp = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Exp\", \"exp\"));\n      };\n      floor = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Floor\", \"floor\"));\n      };\n      gelu = (context) => {\n        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n        context.compute(createElementwiseProgramInfo(\n          context.inputs[0],\n          \"Gelu\",\n          (a) => `0.5 * ${a} * (1.0 + erf_vf32(${a} * 0.7071067811865475))`,\n          erfImpl(dataType)\n        ));\n      };\n      leakyRelu = (context, attributes) => {\n        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n        context.compute(createElementwiseProgramInfo(\n          context.inputs[0],\n          \"LeakyRelu\",\n          (a) => `select(leaky_relu_alpha_ * ${a}, ${a}, ${a} >= vec4<${dataType}>(0.0))`,\n          `const leaky_relu_alpha_ = ${dataType}(${attributes.alpha});`,\n          attributes.cacheKey\n        ));\n      };\n      not = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Not\", (a) => `!${a}`));\n      };\n      neg = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Neg\", (a) => `-${a}`));\n      };\n      reciprocal = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Reciprocal\", (a) => `1.0/${a}`));\n      };\n      relu = (context) => {\n        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n        context.compute(createElementwiseProgramInfo(\n          context.inputs[0],\n          \"Relu\",\n          (a) => `select(vec4<${dataType}>(0.0), ${a}, ${a} > vec4<${dataType}>(0.0))`\n        ));\n      };\n      sigmoid = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Sigmoid\", (a) => `(1.0 / (1.0 + exp(-${a})))`));\n      };\n      parseHardSigmoidAttributes = (attributes) => createAttributeWithCacheKey(attributes);\n      hardSigmoid = (context, attributes) => {\n        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n        context.compute(createElementwiseProgramInfo(\n          context.inputs[0],\n          \"HardSigmoid\",\n          (a) => `max(vec4<${dataType}>(0.0), min(vec4<${dataType}>(1.0), ${attributes.alpha} * ${a} + vec4<${dataType}>(${attributes.beta})))`,\n          void 0,\n          attributes.cacheKey\n        ));\n      };\n      sin = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Sin\", \"sin\"));\n      };\n      sinh = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Sinh\", \"sinh\"));\n      };\n      sqrt = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Sqrt\", \"sqrt\"));\n      };\n      tan = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Tan\", \"tan\"));\n      };\n      tanhExpression = (a) => `sign(${a}) * (1 - exp(-2 * abs(${a}))) / (1 + exp(-2 * abs(${a})))`;\n      tanh = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Tanh\", tanhExpression));\n      };\n      fastGeluImpl = (varType = \"f32\") => `\nconst fast_gelu_a: ${varType} = 0.5;\nconst fast_gelu_b: ${varType} = 0.7978845608028654;\nconst fast_gelu_c: ${varType} = 0.035677408136300125;\n\nfn tanh_v(v: vec4<${varType}>) -> vec4<${varType}> {\n  return ${tanhExpression(\"v\")};\n}\n`;\n      fastGeluExpression = (x) => `(fast_gelu_a + fast_gelu_a * tanh_v(${x} * (fast_gelu_c * ${x} * ${x} + fast_gelu_b))) * ${x}`;\n      fastGelu = (context) => {\n        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n        context.compute(createElementwiseProgramInfo(\n          context.inputs[0],\n          \"FastGelu\",\n          fastGeluExpression,\n          fastGeluImpl(dataType),\n          void 0,\n          context.inputs[0].dataType\n        ));\n      };\n      thresholdedRelu = (context, attributes) => {\n        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n        context.compute(createElementwiseProgramInfo(\n          context.inputs[0],\n          \"ThresholdedRelu\",\n          (a) => `select(vec4<${dataType}>(0.0), ${a}, ${a} > thresholded_relu_alpha_)`,\n          `const thresholded_relu_alpha_ = vec4<${dataType}>(${attributes.alpha});`,\n          attributes.cacheKey\n        ));\n        return 0;\n      };\n      log = (context) => {\n        context.compute(createElementwiseProgramInfo(context.inputs[0], \"Log\", \"log\"));\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/bias-split-gelu.ts\n  var validateInputs7, createBiasSplitGeluProgramInfo, biasSplitGelu;\n  var init_bias_split_gelu = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/bias-split-gelu.ts\"() {\n      \"use strict\";\n      init_util();\n      init_common();\n      init_unary_op();\n      validateInputs7 = (inputs) => {\n        if (inputs[0].dims.length !== 3) {\n          throw new Error(\"input should have 3 dimensions\");\n        }\n        if (![2560, 5120, 10240].includes(inputs[0].dims[2])) {\n          throw new Error(\"hidden state should be 2560, 5120 or 10240\");\n        }\n        if (inputs[1].dims.length !== 1) {\n          throw new Error(\"bias is expected to have 1 dimensions\");\n        }\n        if (inputs[0].dims[2] !== inputs[1].dims[0]) {\n          throw new Error(\"last dimension of input and bias are not the same\");\n        }\n      };\n      createBiasSplitGeluProgramInfo = (inputs) => {\n        const outputShape = inputs[0].dims.slice();\n        outputShape[2] = outputShape[2] / 2;\n        const input = inputVariable(\"input\", inputs[0].dataType, inputs[0].dims, 4);\n        const bias = inputVariable(\"bias\", inputs[0].dataType, [inputs[0].dims[2]], 4);\n        const output = outputVariable(\"output\", inputs[0].dataType, outputShape, 4);\n        const outputSize = ShapeUtil.size(outputShape) / 4;\n        const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n        const getShaderSource = (shaderHelper) => `\n  const M_SQRT2 = sqrt(2.0);\n  const halfChannels = ${inputs[0].dims[2] / 4 / 2}u;\n\n  ${shaderHelper.declareVariables(input, bias, output)}\n\n  ${erfImpl(dataType)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}\n    let biasIdx = global_idx % halfChannels;\n    let batchIndex = global_idx / halfChannels;\n    let inputOffset = biasIdx + batchIndex * halfChannels * 2;\n    let valueLeft = input[inputOffset] + bias[biasIdx];\n    let valueRight = input[inputOffset + halfChannels] + bias[biasIdx + halfChannels];\n    let geluRight = valueRight * 0.5 * (erf_vf32(valueRight / M_SQRT2) + 1);\n\n    ${output.setByOffset(\"global_idx\", \"valueLeft * geluRight\")}\n  }`;\n        return {\n          name: \"BiasSplitGelu\",\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64\n              /* workgroup size */\n            ) }\n          }),\n          getShaderSource\n        };\n      };\n      biasSplitGelu = (context) => {\n        validateInputs7(context.inputs);\n        context.compute(createBiasSplitGeluProgramInfo(context.inputs));\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/binary-op.ts\n  var createBinaryOpProgramShader, createBinaryOpProgramInfo, runBinaryOp, add, div, equal, mul, pow, sub, greater, less, greaterOrEqual, lessOrEqual;\n  var init_binary_op = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/binary-op.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_common();\n      createBinaryOpProgramShader = (shaderHelper, dimsA, dimsB, dimsOutput, vectorize, doBroadcast, sharedDimensionDivisibleBy4, funcCall, typeA, typeB, typeOutput, additionalImplementation) => {\n        let expressionScalar;\n        let expressionVector;\n        if (typeof funcCall === \"string\") {\n          expressionScalar = expressionVector = (a2, b2) => `${funcCall}((${a2}),(${b2}))`;\n        } else if (typeof funcCall === \"function\") {\n          expressionScalar = expressionVector = funcCall;\n        } else {\n          expressionScalar = funcCall.scalar;\n          expressionVector = funcCall.vector;\n        }\n        const output = outputVariable(\"outputData\", typeOutput, dimsOutput.length, 4);\n        const a = inputVariable(\"aData\", typeA, dimsA.length, 4);\n        const b = inputVariable(\"bData\", typeB, dimsB.length, 4);\n        let assignment;\n        if (vectorize) {\n          if (doBroadcast) {\n            const isAOneElement = ShapeUtil.size(dimsA) === 1;\n            const isBOneElement = ShapeUtil.size(dimsB) === 1;\n            const aLastDimDivisibleBy4 = dimsA.length > 0 && dimsA[dimsA.length - 1] % 4 === 0;\n            const bLastDimDivisibleBy4 = dimsB.length > 0 && dimsB[dimsB.length - 1] % 4 === 0;\n            if (isAOneElement || isBOneElement) {\n              assignment = output.setByOffset(\n                \"global_idx\",\n                expressionVector(\n                  isAOneElement ? `${a.type.value}(${a.getByOffset(\"0\")}.x)` : a.getByOffset(\"global_idx\"),\n                  isBOneElement ? `${b.type.value}(${b.getByOffset(\"0\")}.x)` : b.getByOffset(\"global_idx\")\n                )\n              );\n            } else {\n              assignment = `\n            let outputIndices = ${output.offsetToIndices(\"global_idx * 4u\")};\n            let offsetA = ${a.broadcastedIndicesToOffset(\"outputIndices\", output)};\n            let offsetB = ${b.broadcastedIndicesToOffset(\"outputIndices\", output)};\n            ${output.setByOffset(\n                \"global_idx\",\n                expressionVector(\n                  sharedDimensionDivisibleBy4 || aLastDimDivisibleBy4 ? a.getByOffset(\"offsetA / 4u\") : `${a.type.value}(${a.getByOffset(\"offsetA / 4u\")}[offsetA % 4u])`,\n                  sharedDimensionDivisibleBy4 || bLastDimDivisibleBy4 ? b.getByOffset(\"offsetB / 4u\") : `${b.type.value}(${b.getByOffset(\"offsetB / 4u\")}[offsetB % 4u])`\n                )\n              )}\n          `;\n            }\n          } else {\n            assignment = output.setByOffset(\n              \"global_idx\",\n              expressionVector(a.getByOffset(\"global_idx\"), b.getByOffset(\"global_idx\"))\n            );\n          }\n        } else {\n          if (!doBroadcast) {\n            throw new Error(\"no necessary to use scalar implementation for element-wise binary op implementation.\");\n          }\n          const singleAssignment = (resStr, x, typeCast = \"\") => {\n            const expressionA = `aData[indexA${x}][componentA${x}]`;\n            const expressionB = `bData[indexB${x}][componentB${x}]`;\n            return `\n            let outputIndices${x} = ${output.offsetToIndices(`global_idx * 4u + ${x}u`)};\n            let offsetA${x} = ${a.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n            let offsetB${x} = ${b.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n            let indexA${x} = offsetA${x} / 4u;\n            let indexB${x} = offsetB${x} / 4u;\n            let componentA${x} = offsetA${x} % 4u;\n            let componentB${x} = offsetB${x} % 4u;\n            ${resStr}[${x}] = ${typeCast}(${expressionScalar(expressionA, expressionB)});\n          `;\n          };\n          if (typeOutput === 9 /* bool */) {\n            assignment = `\n            var data = vec4<u32>(0);\n            ${singleAssignment(\"data\", 0, \"u32\")}\n            ${singleAssignment(\"data\", 1, \"u32\")}\n            ${singleAssignment(\"data\", 2, \"u32\")}\n            ${singleAssignment(\"data\", 3, \"u32\")}\n            outputData[global_idx] = dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(data));`;\n          } else {\n            assignment = `\n            ${singleAssignment(\"outputData[global_idx]\", 0)}\n            ${singleAssignment(\"outputData[global_idx]\", 1)}\n            ${singleAssignment(\"outputData[global_idx]\", 2)}\n            ${singleAssignment(\"outputData[global_idx]\", 3)}\n          `;\n          }\n        }\n        return `\n        ${shaderHelper.registerUniform(\"vec_size\", \"u32\").declareVariables(a, b, output)}\n\n        ${additionalImplementation ?? \"\"}\n\n        ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.vec_size\")}\n        ${assignment}\n      }`;\n      };\n      createBinaryOpProgramInfo = (name, cacheKey, a, b, funcCall, additionalImplementation, outputDataType = a.dataType) => {\n        const isBroadcast = !ShapeUtil.areEqual(a.dims, b.dims);\n        let outputShape = a.dims;\n        let outputSize = ShapeUtil.size(a.dims);\n        let vectorize = false;\n        let sharedDimensionDivisibleBy4 = false;\n        const cacheKeyAux = [isBroadcast];\n        if (isBroadcast) {\n          const calculatedShape = BroadcastUtil.calcShape(a.dims, b.dims, false);\n          if (!calculatedShape) {\n            throw new Error(\"Can't perform binary op on the given tensors\");\n          }\n          outputShape = calculatedShape;\n          outputSize = ShapeUtil.size(outputShape);\n          const isAOneElement = ShapeUtil.size(a.dims) === 1;\n          const isBOneElement = ShapeUtil.size(b.dims) === 1;\n          const aLastDimDivisibleBy4 = a.dims.length > 0 && a.dims[a.dims.length - 1] % 4 === 0;\n          const bLastDimDivisibleBy4 = b.dims.length > 0 && b.dims[b.dims.length - 1] % 4 === 0;\n          cacheKeyAux.push(isAOneElement);\n          cacheKeyAux.push(isBOneElement);\n          cacheKeyAux.push(aLastDimDivisibleBy4);\n          cacheKeyAux.push(bLastDimDivisibleBy4);\n          let sharedDimension = 1;\n          for (let i = 1; i < outputShape.length; i++) {\n            const dimA = a.dims[a.dims.length - i] ?? 1;\n            const dimB = b.dims[b.dims.length - i] ?? 1;\n            if (dimA === dimB) {\n              sharedDimension *= dimA;\n            } else {\n              break;\n            }\n          }\n          if (sharedDimension % 4 === 0) {\n            sharedDimensionDivisibleBy4 = true;\n            vectorize = true;\n          } else if (isAOneElement || isBOneElement || aLastDimDivisibleBy4 || bLastDimDivisibleBy4) {\n            vectorize = true;\n          }\n        } else {\n          vectorize = true;\n        }\n        cacheKeyAux.push(vectorize);\n        return {\n          name,\n          shaderCache: {\n            hint: cacheKey + cacheKeyAux.map((x) => x.toString()).join(\"_\"),\n            inputDependencies: [\"rank\", \"rank\"]\n          },\n          getShaderSource: (shaderHelper) => createBinaryOpProgramShader(\n            shaderHelper,\n            a.dims,\n            b.dims,\n            outputShape,\n            vectorize,\n            isBroadcast,\n            sharedDimensionDivisibleBy4,\n            funcCall,\n            a.dataType,\n            b.dataType,\n            outputDataType,\n            additionalImplementation\n          ),\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: outputDataType }],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64 / 4\n              /* component size */\n            ) },\n            programUniforms: [\n              { type: 12 /* uint32 */, data: Math.ceil(ShapeUtil.size(outputShape) / 4) },\n              ...createTensorShapeVariables(a.dims, b.dims, outputShape)\n            ]\n          })\n        };\n      };\n      runBinaryOp = (context, name, funcCall, additionalImplementation, cacheKey, outputDataType) => {\n        context.compute(createBinaryOpProgramInfo(\n          name,\n          cacheKey ?? \"\",\n          context.inputs[0],\n          context.inputs[1],\n          funcCall,\n          additionalImplementation,\n          outputDataType\n        ));\n      };\n      add = (context) => {\n        runBinaryOp(context, \"Add\", (a, b) => `${a}+${b}`);\n      };\n      div = (context) => {\n        runBinaryOp(context, \"Div\", (a, b) => `${a}/${b}`);\n      };\n      equal = (context) => {\n        runBinaryOp(\n          context,\n          \"Equal\",\n          { scalar: (a, b) => `u32(${a}==${b})`, vector: (a, b) => `vec4<u32>(${a}==${b})` },\n          void 0,\n          void 0,\n          9 /* bool */\n        );\n      };\n      mul = (context) => {\n        runBinaryOp(context, \"Mul\", (a, b) => `${a}*${b}`);\n      };\n      pow = (context) => {\n        const type = inputVariable(\"input\", context.inputs[0].dataType, context.inputs[0].dims).type.value;\n        const roundStr = type === \"i32\" ? \"round\" : \"\";\n        runBinaryOp(\n          context,\n          \"Pow\",\n          { scalar: (a, b) => `pow_custom(${a},${b})`, vector: (a, b) => `pow_vector_custom(${a},${b})` },\n          `\n    fn pow_custom(a : ${type}, b : ${type}) -> ${type} {\n      if (b == ${type}(0.0)) {\n        return ${type}(1.0);\n      } else if (a < ${type}(0.0) && f32(b) != floor(f32(b))) {\n        return ${type}(pow(f32(a), f32(b))); // NaN\n      }\n      return select(sign(a), ${type}(1.0), round(f32(abs(b) % ${type}(2.0))) != 1.0) * ${type}(${roundStr}(pow(f32(abs(a)), f32(b))));\n    }\n    fn pow_vector_custom(a : vec4<${type}>, b : vec4<${type}>) -> vec4<${type}> {\n      // TODO: implement vectorized pow\n      return vec4<${type}>(pow_custom(a.x, b.x), pow_custom(a.y, b.y), pow_custom(a.z, b.z), pow_custom(a.w, b.w));\n    }\n      `\n        );\n      };\n      sub = (context) => {\n        runBinaryOp(context, \"Sub\", (a, b) => `${a}-${b}`);\n      };\n      greater = (context) => {\n        runBinaryOp(\n          context,\n          \"Greater\",\n          { scalar: (a, b) => `u32(${a}>${b})`, vector: (a, b) => `vec4<u32>(${a}>${b})` },\n          void 0,\n          void 0,\n          9 /* bool */\n        );\n      };\n      less = (context) => {\n        runBinaryOp(\n          context,\n          \"Less\",\n          { scalar: (a, b) => `u32(${a}<${b})`, vector: (a, b) => `vec4<u32>(${a}<${b})` },\n          void 0,\n          void 0,\n          9 /* bool */\n        );\n      };\n      greaterOrEqual = (context) => {\n        runBinaryOp(\n          context,\n          \"GreaterOrEqual\",\n          { scalar: (a, b) => `u32(${a}>=${b})`, vector: (a, b) => `vec4<u32>(${a}>=${b})` },\n          void 0,\n          void 0,\n          9 /* bool */\n        );\n      };\n      lessOrEqual = (context) => {\n        runBinaryOp(\n          context,\n          \"LessOrEqual\",\n          { scalar: (a, b) => `u32(${a}<=${b})`, vector: (a, b) => `vec4<u32>(${a}<=${b})` },\n          void 0,\n          void 0,\n          9 /* bool */\n        );\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/fuse-utils.ts\n  var getActivationSnippet, appendActivationUniformsData, appendActivationUniforms, parseInternalActivationAttributes;\n  var init_fuse_utils = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/fuse-utils.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      getActivationSnippet = (attributes, valueType, baseType = \"f32\") => {\n        switch (attributes.activation) {\n          case \"Relu\":\n            return `value = max(value, ${valueType}(0.0));`;\n          case \"Sigmoid\":\n            return `value = (${valueType}(1.0) / (${valueType}(1.0) + exp(-value)));`;\n          case \"Clip\":\n            return `value = clamp(value, ${valueType}(${baseType}(uniforms.clip_min)), ${valueType}(${baseType}(uniforms.clip_max)));`;\n          case \"HardSigmoid\":\n            return `value = max(${valueType}(0.0), min(${valueType}(1.0), ${baseType}(uniforms.alpha) * value + ${baseType}(uniforms.beta)));`;\n          case \"LeakyRelu\":\n            return `value = select(${baseType}(uniforms.alpha) * value, value, value >= ${valueType}(0.0));`;\n          case \"\":\n            return \"\";\n          default:\n            throw new Error(`Unsupported activation ${attributes.activation}`);\n        }\n      };\n      appendActivationUniformsData = (attributes, programUniform) => {\n        if (attributes.activation === \"Clip\") {\n          programUniform.push(\n            { type: 1 /* float */, data: attributes.clipMax },\n            { type: 1 /* float */, data: attributes.clipMin }\n          );\n        } else if (attributes.activation === \"HardSigmoid\") {\n          programUniform.push(\n            { type: 1 /* float */, data: attributes.alpha },\n            { type: 1 /* float */, data: attributes.beta }\n          );\n        } else if (attributes.activation === \"LeakyRelu\") {\n          programUniform.push({ type: 1 /* float */, data: attributes.alpha });\n        }\n      };\n      appendActivationUniforms = (attributes, uniforms) => {\n        if (attributes.activation === \"Clip\") {\n          uniforms.push({ name: \"clip_max\", type: \"f32\" }, { name: \"clip_min\", type: \"f32\" });\n        } else if (attributes.activation === \"HardSigmoid\") {\n          uniforms.push({ name: \"alpha\", type: \"f32\" }, { name: \"beta\", type: \"f32\" });\n        } else if (attributes.activation === \"LeakyRelu\") {\n          uniforms.push({ name: \"alpha\", type: \"f32\" });\n        }\n      };\n      parseInternalActivationAttributes = (attributes) => {\n        const activation = attributes?.activation || \"\";\n        if (activation === \"HardSigmoid\") {\n          const [alpha, beta] = attributes?.activation_params || [0.2, 0.5];\n          return { activation, alpha, beta };\n        } else if (activation === \"Clip\") {\n          const [clipMin, clipMax] = attributes?.activation_params || [MIN_CLIP, MAX_CLIP];\n          return { activation, clipMax, clipMin };\n        } else if (activation === \"LeakyRelu\") {\n          const [alpha] = attributes?.activation_params || [0.01];\n          return { activation, alpha };\n        }\n        return { activation };\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/3rd-party/activation_util.ts\n  var typeSnippet, biasSnippet;\n  var init_activation_util = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/3rd-party/activation_util.ts\"() {\n      \"use strict\";\n      typeSnippet = (component, dataType) => {\n        switch (component) {\n          case 1:\n            return dataType;\n          case 2:\n            return `vec2<${dataType}>`;\n          case 3:\n            return `vec3<${dataType}>`;\n          case 4:\n            return `vec4<${dataType}>`;\n          default:\n            throw new Error(`${component}-component is not supported.`);\n        }\n      };\n      biasSnippet = (hasBias) => `\n      ${hasBias ? \"value = value + getBiasByOutputCoords(coords);\" : \"\"}\n      `;\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_util.ts\n  var utilFunctions;\n  var init_conv_util = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_util.ts\"() {\n      \"use strict\";\n      utilFunctions = (strideStr) => `\nfn getIndexFromCoords4D(coords : vec4<i32>, shape : vec4<i32>) -> i32 {\n  return dot(coords, vec4<i32>(\n      shape.y * shape.z * shape.w, shape.z * shape.w, shape.w, 1));\n}\nfn getOutputIndexFromCoords(coords : vec4<i32>) -> i32 {\n  return dot(coords, vec4<i32>(\n    i32(${strideStr}.x), i32(${strideStr}.y), i32(${strideStr}.z), 1));\n}\n`;\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/3rd-party/matmul_packed_webgpu.ts\n  var writeDataToSubAVec4Snippet, calculateResultSnippet, makeMatMulPackedVec4Source, writeDataToSubASnippet, readDataFromSubASnippet, makeMatMulPackedSource, matMulReadWriteFnSource, createMatmulProgramInfo;\n  var init_matmul_packed_webgpu = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/3rd-party/matmul_packed_webgpu.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_common();\n      init_fuse_utils();\n      init_activation_util();\n      writeDataToSubAVec4Snippet = (transpose2, batchDims) => {\n        if (transpose2) {\n          return `\n        mm_Asub[inputRow][inputCol] = mm_readA(batch,\n          kStart + inputRow,\n          globalRowStart / innerElementSize + inputCol${batchDims ? \", batchIndices\" : \"\"});\n        `;\n        } else {\n          return `\n        mm_Asub[inputRow][inputCol] = mm_readA(batch,\n          globalRow + innerRow,\n          kStart / innerElementSize + inputCol${batchDims ? \", batchIndices\" : \"\"});\n        `;\n        }\n      };\n      calculateResultSnippet = (transposeA, innerElementSize) => {\n        if (transposeA) {\n          return `\n        let ACached0 = mm_Asub[k * innerElementSize][localRow];\n        let ACached1 = mm_Asub[k * innerElementSize + 1][localRow];\n        let ACached2 = mm_Asub[k * innerElementSize + 2][localRow];\n        ${innerElementSize === 3 ? \"\" : \"let ACached3 = mm_Asub[k * innerElementSize + 3][localRow];\"}\n        for (var i = 0; i < rowPerThread; i = i + 1) {\n          acc[i] = BCached0 * ACached0[i] + acc[i];\n          acc[i] = BCached1 * ACached1[i] + acc[i];\n          acc[i] = BCached2 * ACached2[i] + acc[i];\n          ${innerElementSize === 3 ? \"\" : \"acc[i] = BCached3 * ACached3[i] + acc[i];\"}\n        }`;\n        } else {\n          return `\n        for (var i = 0; i < rowPerThread; i = i + 1) {\n          let ACached = mm_Asub[tileRow + i][k];\n          acc[i] = BCached0 * ACached.x + acc[i];\n          acc[i] = BCached1 * ACached.y + acc[i];\n          acc[i] = BCached2 * ACached.z + acc[i];\n          ${innerElementSize === 3 ? \"\" : \"acc[i] = BCached3 * ACached.w + acc[i];\"}\n        }`;\n        }\n      };\n      makeMatMulPackedVec4Source = (workPerThread, workgroupSize, type = \"f32\", batchDims, transposeA = false, tileInner = 32, splitK = false, splitedDimInner = 32) => {\n        const tileAOuter = workgroupSize[1] * workPerThread[1];\n        const tileBOuter = workgroupSize[0] * workPerThread[0];\n        const tileAWidth = transposeA ? tileAOuter : tileInner;\n        const tileAHight = transposeA ? tileInner : tileAOuter;\n        const innerElementSize = tileAWidth / workgroupSize[0];\n        const rowPerThreadB = tileInner / workgroupSize[1];\n        if (!((transposeA && innerElementSize === 4 && workPerThread[1] === 4 || !transposeA && (innerElementSize === 3 || innerElementSize === 4)) && tileAWidth % workgroupSize[0] === 0 && tileInner % workgroupSize[1] === 0 && workPerThread[0] === 4)) {\n          throw new Error(`If transposeA ${transposeA} is true, innerElementSize ${innerElementSize} and workPerThread[1] ${workPerThread[1]} must be 4.\n      Otherwise, innerElementSize ${innerElementSize} must be 3 or 4.\n  tileAWidth ${tileAWidth} must be divisible by workgroupSize[0]${workgroupSize[0]}. tileInner ${tileInner} must be divisible by workgroupSize[1] ${workgroupSize[1]}. colPerThread ${workPerThread[0]} must be 4.`);\n        }\n        return `\nvar<workgroup> mm_Asub: array<array<vec${innerElementSize}<${type}>, ${tileAWidth / innerElementSize}>, ${tileAHight}>;\nvar<workgroup> mm_Bsub: array<array<vec4<${type}>, ${tileBOuter / workPerThread[0]}>, ${tileInner}>;\n\nconst rowPerThread = ${workPerThread[1]};\nconst colPerThread = ${workPerThread[0]};\nconst innerElementSize = ${innerElementSize};\nconst tileInner = ${tileInner};\n\n@compute @workgroup_size(${workgroupSize[0]}, ${workgroupSize[1]}, ${workgroupSize[2]})\nfn main(@builtin(local_invocation_id) localId : vec3<u32>,\n        @builtin(global_invocation_id) globalId : vec3<u32>,\n        @builtin(workgroup_id) workgroupId : vec3<u32>) {\n  let localRow = i32(localId.y);\n  let tileRow = localRow * rowPerThread;\n  let tileCol = i32(localId.x);\n\n  let globalRow =i32(globalId.y) * rowPerThread;\n  let globalCol = i32(globalId.x);\n  let batch = ${splitK ? \"0\" : \"i32(globalId.z)\"};\n  ${batchDims ? `let batchIndices = ${batchDims.offsetToIndices(\"u32(batch)\")};` : \"\"}\n  let globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n\n  let num_tiles = ${splitK ? `${Math.ceil(splitedDimInner / tileInner)}` : \"(uniforms.dim_inner - 1) / tileInner + 1\"};\n  var kStart = ${splitK ? `i32(globalId.z) * ${splitedDimInner}` : \"0\"};\n\n  var acc: array<vec4<${type}>, rowPerThread>;\n\n  // Loop over shared dimension.\n  let tileRowB = localRow * ${rowPerThreadB};\n  for (var t = 0; t < num_tiles; t = t + 1) {\n      // Load one tile of A into local memory.\n      for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n          let inputRow = tileRow + innerRow;\n          let inputCol = tileCol;\n          ${writeDataToSubAVec4Snippet(transposeA, batchDims)}\n      }\n\n      // Load one tile of B into local memory.\n      for (var innerRow = 0; innerRow < ${rowPerThreadB}; innerRow = innerRow + 1) {\n          let inputRow = tileRowB + innerRow;\n          let inputCol = tileCol;\n          mm_Bsub[inputRow][inputCol] = mm_readB(batch, kStart + inputRow, globalCol${batchDims ? \", batchIndices\" : \"\"});\n      }\n      kStart = kStart + tileInner;\n      workgroupBarrier();\n\n      // Compute acc values for a single thread.\n      for (var k = 0; k < tileInner / innerElementSize; k = k + 1) {\n          let BCached0 = mm_Bsub[k * innerElementSize][tileCol];\n          let BCached1 = mm_Bsub[k * innerElementSize + 1][tileCol];\n          let BCached2 = mm_Bsub[k * innerElementSize + 2][tileCol];\n          ${innerElementSize === 3 ? \"\" : \"let BCached3 = mm_Bsub[k * innerElementSize + 3][tileCol];\"}\n\n          ${calculateResultSnippet(transposeA, innerElementSize)}\n      }\n\n      workgroupBarrier();\n  }\n\n  for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      mm_write(batch, globalRow + innerRow, globalCol, acc[innerRow]);\n  }\n}`;\n      };\n      writeDataToSubASnippet = (transpose2, batchDims) => {\n        if (transpose2) {\n          return `\n            mm_Asub[inputRow][inputCol] = mm_readA(batch,\n              kStart + inputRow,\n              globalRowStart + inputCol${batchDims ? \", batchIndices\" : \"\"});\n            `;\n        } else {\n          return `\n            mm_Asub[inputRow][inputCol] = mm_readA(batch,\n              globalRowStart + inputRow,\n              kStart + inputCol${batchDims ? \", batchIndices\" : \"\"});\n            `;\n        }\n      };\n      readDataFromSubASnippet = (transposeA) => transposeA ? \"let ACached = mm_Asub[k][tileRow + innerRow];\" : \"let ACached = mm_Asub[tileRow + innerRow][k];\";\n      makeMatMulPackedSource = (workPerThread, workgroupSize, type = \"f32\", batchDims, transposeA = false, tileInner = 32, splitK = false, splitedDimInner = 32, sequentialAccessByThreads = false) => {\n        const tileAOuter = workPerThread[1] * workgroupSize[1];\n        const tileBOuter = workPerThread[0] * workgroupSize[0];\n        const tileAWidth = transposeA ? tileAOuter : tileInner;\n        const tileAHight = transposeA ? tileInner : tileAOuter;\n        if (!(tileAHight % workgroupSize[1] === 0 && tileAWidth % workgroupSize[0] === 0 && tileInner % workgroupSize[1] === 0)) {\n          throw new Error(`tileAHight ${tileAHight} must be divisible by workgroupSize[1]${workgroupSize[1]}, tileAWidth ${tileAWidth} must be divisible by workgroupSize[0]${workgroupSize[0]}, tileInner ${tileInner} must be divisible by workgroupSize[1]${workgroupSize[1]}`);\n        }\n        const rowPerThreadA = tileAHight / workgroupSize[1];\n        const colPerThreadA = tileAWidth / workgroupSize[0];\n        const rowPerThreadB = tileInner / workgroupSize[1];\n        const matmulSnippet = sequentialAccessByThreads ? `\n    let localRow = i32(localId.y);\n    let localCol = i32(localId.x);\n    let globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n    let globalColStart = i32(workgroupId.x) * ${tileBOuter};\n\n    // Loop over shared dimension.\n    for (var t = 0; t < num_tiles; t = t + 1) {\n      // Load one tile of A into local memory.\n      for (var inputRow = localRow; inputRow < ${tileAHight}; inputRow = inputRow + ${workgroupSize[1]}) {\n        for (var inputCol = localCol; inputCol < ${tileAWidth}; inputCol = inputCol + ${workgroupSize[0]}) {\n          ${writeDataToSubASnippet(transposeA, batchDims)}\n        }\n      }\n      // Load one tile of B into local memory.\n      for (var inputRow = localRow; inputRow < ${tileInner}; inputRow = inputRow + ${workgroupSize[1]}) {\n            for (var inputCol = localCol; inputCol < ${tileBOuter}; inputCol = inputCol + ${workgroupSize[0]}) {\n          mm_Bsub[inputRow][inputCol] = mm_readB(batch,\n            kStart + inputRow,\n            globalColStart + inputCol${batchDims ? \", batchIndices\" : \"\"});\n        }\n      }\n      kStart = kStart + tileInner;\n      workgroupBarrier();\n\n      // Compute acc values for a single thread.\n      var BCached : array<${type}, colPerThread>;\n      for (var k = 0; k < tileInner; k = k + 1) {\n        for (var inner = 0; inner < colPerThread; inner = inner + 1) {\n          BCached[inner] = mm_Bsub[k][localCol + inner * ${workgroupSize[0]}];\n        }\n        for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n          let ACached = ${transposeA ? `mm_Asub[k][localRow + innerRow * ${workgroupSize[1]}];` : `mm_Asub[localRow + innerRow * ${workgroupSize[1]}][k];`}\n          for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n            acc[innerRow][innerCol] = acc[innerRow][innerCol] +\n                ACached * BCached[innerCol];\n          }\n        }\n      }\n      workgroupBarrier();\n    }\n    for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      let gRow = globalRowStart + localRow + innerRow * ${workgroupSize[1]};\n      for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n        let gCol = globalColStart + localCol + innerCol * ${workgroupSize[0]};\n        mm_write(batch, gRow, gCol, acc[innerRow][innerCol]);\n      }\n    }\n    ` : `\nlet tileRow = i32(localId.y) * rowPerThread;\nlet tileCol = i32(localId.x) * colPerThread;\n\nlet globalRow = i32(globalId.y) * rowPerThread;\nlet globalCol = i32(globalId.x) * colPerThread;\nlet globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n\nlet tileRowA = i32(localId.y) * ${rowPerThreadA};\nlet tileColA = i32(localId.x) * ${colPerThreadA};\nlet tileRowB = i32(localId.y) * ${rowPerThreadB};\n// Loop over shared dimension.\nfor (var t = 0; t < num_tiles; t = t + 1) {\n  // Load one tile of A into local memory.\n  for (var innerRow = 0; innerRow < ${rowPerThreadA}; innerRow = innerRow + 1) {\n    for (var innerCol = 0; innerCol < ${colPerThreadA}; innerCol = innerCol + 1) {\n      let inputRow = tileRowA + innerRow;\n      let inputCol = tileColA + innerCol;\n      ${writeDataToSubASnippet(transposeA, batchDims)}\n    }\n  }\n\n  // Load one tile of B into local memory.\n  for (var innerRow = 0; innerRow < ${rowPerThreadB}; innerRow = innerRow + 1) {\n    for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n      let inputRow = tileRowB + innerRow;\n      let inputCol = tileCol + innerCol;\n      mm_Bsub[inputRow][inputCol] = mm_readB(batch,\n        kStart + inputRow,\n        globalCol + innerCol${batchDims ? \", batchIndices\" : \"\"});\n    }\n  }\n  kStart = kStart + tileInner;\n  workgroupBarrier();\n\n  // Compute acc values for a single thread.\n  var BCached : array<${type}, colPerThread>;\n  for (var k = 0; k < tileInner; k = k + 1) {\n    for (var inner = 0; inner < colPerThread; inner = inner + 1) {\n      BCached[inner] = mm_Bsub[k][tileCol + inner];\n    }\n\n    for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      ${readDataFromSubASnippet(transposeA)}\n      for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n        acc[innerRow][innerCol] = acc[innerRow][innerCol] + ACached * BCached[innerCol];\n      }\n    }\n  }\n\n  workgroupBarrier();\n}\n\nfor (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n  for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n    mm_write(batch, globalRow + innerRow, globalCol + innerCol,\n        acc[innerRow][innerCol]);\n  }\n}\n`;\n        return `\n  var<workgroup> mm_Asub : array<array<${type}, ${tileAWidth}>, ${tileAHight}>;\n  var<workgroup> mm_Bsub : array<array<${type}, ${tileBOuter}>, ${tileInner}>;\n  const rowPerThread = ${workPerThread[1]};\n  const colPerThread = ${workPerThread[0]};\n  const tileInner = ${tileInner};\n\n@compute @workgroup_size(${workgroupSize[0]}, ${workgroupSize[1]}, ${workgroupSize[2]})\nfn main(@builtin(local_invocation_id) localId : vec3<u32>,\n        @builtin(global_invocation_id) globalId : vec3<u32>,\n        @builtin(workgroup_id) workgroupId : vec3<u32>) {\n    let batch = ${splitK ? \"0\" : \"i32(globalId.z)\"};\n    ${batchDims ? `let batchIndices = ${batchDims.offsetToIndices(\"u32(batch)\")};` : \"\"}\n    let num_tiles = ${splitK ? `${Math.ceil(splitedDimInner / tileInner)}` : \"(uniforms.dim_inner - 1) / tileInner + 1\"};\n    var kStart = ${splitK ? `i32(globalId.z) * ${splitedDimInner}` : \"0\"};\n\n    var acc : array<array<${type}, colPerThread>, rowPerThread>;\n\n    // Without this initialization strange values show up in acc.\n    for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n        acc[innerRow][innerCol] = 0.0;\n      }\n    }\n    ${matmulSnippet}\n  }\n`;\n      };\n      matMulReadWriteFnSource = (component, hasBias, applyActivation, variables, batchShapes, isChannelsLast = false) => {\n        const [batchAShape, batchBShape, batchShape] = batchShapes;\n        const [batchVariable, aVariable, bVariable, outputVariable2] = variables;\n        const broadCastADims = getBroadcastDims(batchAShape, batchShape);\n        const broadCastBDims = getBroadcastDims(batchBShape, batchShape);\n        const dataType = tensorTypeToWsglStorageType(variables[0].type.tensor);\n        const getAIndices = () => {\n          const aRank = aVariable.rank;\n          const batchRank = batchVariable.rank;\n          let resStr = `var aIndices: ${aVariable.type.indices};`;\n          for (let i = aRank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) {\n            resStr += `\naIndices[${i}] = ${batchRank > 1 ? `batchIndices[${j}]` : \"batchIndices\"};`;\n          }\n          broadCastADims.forEach((i) => {\n            resStr += `\naIndices[${i}] = 0;`;\n          });\n          resStr += `\naIndices[${aRank - 2}] = u32(row);\n                   aIndices[${aRank - 1}] = u32(colIn);`;\n          return resStr;\n        };\n        const getBIndices = () => {\n          const bRank = bVariable.rank;\n          const batchRank = batchVariable.rank;\n          let resStr = `var bIndices: ${bVariable.type.indices};`;\n          for (let i = bRank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) {\n            resStr += `\nbIndices[${i}] = ${batchRank > 1 ? `batchIndices[${j}]` : \"batchIndices\"};`;\n          }\n          broadCastBDims.forEach((i) => {\n            resStr += `\nbIndices[${i}] = 0;`;\n          });\n          resStr += `\nbIndices[${bRank - 2}] = u32(row);\n                   bIndices[${bRank - 1}] = u32(colIn);`;\n          return resStr;\n        };\n        const source = `\n    fn mm_readA(batch: i32, row: i32, colIn: i32, batchIndices: ${batchVariable.type.indices}) -> ${typeSnippet(component, dataType)} {\n      var value = ${typeSnippet(component, dataType)}(0.0);\n      let col = colIn * ${component};\n      if(row < uniforms.dim_a_outer && col < uniforms.dim_inner)\n      {\n        ${getAIndices()}\n        value = ${aVariable.getByIndices(\"aIndices\")};\n      }\n      return value;\n    }\n\n    fn mm_readB(batch: i32, row: i32, colIn: i32, batchIndices: ${batchVariable.type.indices}) -> ${typeSnippet(component, dataType)} {\n      var value = ${typeSnippet(component, dataType)}(0.0);\n      let col = colIn * ${component};\n      if(row < uniforms.dim_inner && col < uniforms.dim_b_outer)\n      {\n        ${getBIndices()}\n        value = ${bVariable.getByIndices(\"bIndices\")};\n      }\n      return value;\n    }\n\n    fn mm_write(batch: i32, row: i32, colIn: i32, valueIn: ${typeSnippet(component, dataType)}) {\n      let col = colIn * ${component};\n      if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer) {\n        var value = valueIn;\n        let coords = vec3<i32>(batch, row, colIn);\n        ${hasBias ? `value = value + ${isChannelsLast ? \"bias[colIn]\" : `${typeSnippet(component, dataType)}(bias[row])`};` : \"\"}\n        ${applyActivation}\n        ${outputVariable2.setByIndices(\"vec3<u32>(coords)\", \"value\")}\n      }\n    }\n    `;\n        return source;\n      };\n      createMatmulProgramInfo = (inputs, activationAttributes, outputShape, reshapedOutputShape, isChannelsLast = false) => {\n        const aShape = inputs[0].dims;\n        const bShape = inputs[1].dims;\n        const outerDimsA = aShape.slice(0, -2);\n        const outerDimsB = bShape.slice(0, -2);\n        const outerDims = reshapedOutputShape ? reshapedOutputShape.slice(0, -2) : outputShape.slice(0, -2);\n        const batchSize = ShapeUtil.size(outerDims);\n        const dimAOuter = aShape[aShape.length - 2];\n        const dimInner = aShape[aShape.length - 1];\n        const dimBOuter = bShape[bShape.length - 1];\n        const isVec4 = dimInner % 4 === 0 && dimBOuter % 4 === 0;\n        const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];\n        const workgroupSize = [8, 8, 1];\n        const dispatch = [\n          Math.ceil(dimBOuter / workgroupSize[0] / elementsPerThread[0]),\n          Math.ceil(dimAOuter / workgroupSize[1] / elementsPerThread[1]),\n          Math.ceil(batchSize / workgroupSize[2] / elementsPerThread[2])\n        ];\n        const components = isVec4 ? 4 : 1;\n        const aShapeTemp = [...outerDimsA, dimAOuter, dimInner / components];\n        const aRank = aShapeTemp.length;\n        const bShapeTemp = [...outerDimsB, dimInner, dimBOuter / components];\n        const bRank = bShapeTemp.length;\n        const outputShapeTemp = [batchSize, dimAOuter, dimBOuter / components];\n        const programUniforms = [\n          { type: 6 /* int32 */, data: dimAOuter },\n          { type: 6 /* int32 */, data: dimBOuter },\n          { type: 6 /* int32 */, data: dimInner }\n        ];\n        appendActivationUniformsData(activationAttributes, programUniforms);\n        programUniforms.push(...createTensorShapeVariables(outerDims, aShapeTemp, bShapeTemp));\n        const inputDependencies = [\"rank\", \"rank\"];\n        const hasBias = inputs.length > 2;\n        if (hasBias) {\n          programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n          inputDependencies.push(\"rank\");\n        }\n        programUniforms.push(...createTensorShapeVariables(outputShapeTemp));\n        const getShaderSource = (shaderHelper) => {\n          const batchRank = outerDims.length;\n          const batchDims = internalVariable(\"batchDims\", inputs[0].dataType, batchRank, 1);\n          const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n          const A = inputVariable(\"a\", inputs[0].dataType, aRank, components);\n          const B = inputVariable(\"b\", inputs[1].dataType, bRank, components);\n          const output = outputVariable(\"result\", inputs[0].dataType, outputShapeTemp.length, components);\n          const inputVariables = [A, B];\n          if (hasBias) {\n            const biasComponents = isChannelsLast ? components : 1;\n            inputVariables.push(inputVariable(\"bias\", inputs[2].dataType, inputs[2].dims.length, biasComponents));\n          }\n          const uniforms = [{ name: \"dim_a_outer\", type: \"i32\" }, { name: \"dim_b_outer\", type: \"i32\" }, { name: \"dim_inner\", type: \"i32\" }];\n          appendActivationUniforms(activationAttributes, uniforms);\n          const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n          const applyActivation = getActivationSnippet(activationAttributes, output.type.value, baseType);\n          const declareFunctions = matMulReadWriteFnSource(\n            components,\n            hasBias,\n            applyActivation,\n            [batchDims, A, B, output],\n            [outerDimsA, outerDimsB, outerDims],\n            isChannelsLast\n          );\n          return `\n  ${shaderHelper.registerUniforms(uniforms).registerInternalVariables(batchDims).declareVariables(\n            ...inputVariables,\n            output\n          )}\n  ${declareFunctions}\n  ${isVec4 ? makeMatMulPackedVec4Source(elementsPerThread, workgroupSize, dataType, batchDims) : makeMatMulPackedSource(elementsPerThread, workgroupSize, dataType, batchDims)}\n                   `;\n        };\n        return {\n          name: \"MatMul\",\n          shaderCache: {\n            hint: `${elementsPerThread};${activationAttributes.activation};${isVec4};${isChannelsLast}`,\n            inputDependencies\n          },\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n            dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] },\n            programUniforms\n          }),\n          getShaderSource\n        };\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/3rd-party/conv2d_mm_webgpu.ts\n  var conv2dCommonSnippet, createConv2DMatMulProgramInfo;\n  var init_conv2d_mm_webgpu = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/3rd-party/conv2d_mm_webgpu.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_log();\n      init_common();\n      init_fuse_utils();\n      init_activation_util();\n      init_conv_util();\n      init_matmul_packed_webgpu();\n      conv2dCommonSnippet = (isChannelsLast, fitAOuter, fitBOuter, fitInner, addBias = false, attributes, innerElementSizeX = 4, innerElementSizeW = 4, innerElementSize = 4, dataType = \"f32\") => {\n        const getXSnippet = (innerElementSize2) => {\n          switch (innerElementSize2) {\n            case 1:\n              return \"resData = x[xIndex];\";\n            case 3:\n              return `resData = vec3<${dataType}>(x[xIndex], x[xIndex + 1], x[xIndex + 2]);`;\n            case 4:\n              return \"resData = x[xIndex / 4];\";\n            default:\n              throw new Error(`innerElementSize ${innerElementSize2} is not supported.`);\n          }\n        };\n        const getWSnippet = (innerElementSize2) => {\n          switch (innerElementSize2) {\n            case 1:\n              return \"return w[row * i32(uniforms.w_shape[3]) + colIn];\";\n            case 4:\n              return \"return w[row * i32(uniforms.w_shape[3]) / 4 + colIn];\";\n            default:\n              throw new Error(`innerElementSize ${innerElementSize2} is not supported.`);\n          }\n        };\n        const coordASnippet = isChannelsLast ? `\n    let coord = vec4<i32>(batch, xRow, xCol, xCh);\n    ` : `\n    let coord = vec4<i32>(batch, xCh, xRow, xCol);\n    `;\n        const coordResSnippet = isChannelsLast ? `\n    let coords = vec4<i32>(\n      batch,\n      row / outWidth,\n      row % outWidth,\n      col);\n    ` : `\n    let coords = vec4<i32>(\n      batch,\n      row,\n      col / outWidth,\n      col % outWidth);\n    `;\n        const xHeight = isChannelsLast ? \"i32(uniforms.x_shape[1])\" : \"i32(uniforms.x_shape[2])\";\n        const xWidth = isChannelsLast ? \"i32(uniforms.x_shape[2])\" : \"i32(uniforms.x_shape[3])\";\n        const row = isChannelsLast ? \"row\" : \"col\";\n        const col = isChannelsLast ? \"col\" : \"row\";\n        const readXSnippet = `\n    let inChannels = i32(uniforms.w_shape[2]);\n    let outWidth = ${isChannelsLast ? \"i32(uniforms.result_shape[2])\" : \"i32(uniforms.result_shape[3])\"};\n    let outRow = ${row} / outWidth;\n    let outCol = ${row} % outWidth;\n\n    let WRow = ${col} / (i32(uniforms.w_shape[1]) * inChannels);\n    let WCol = ${col} / inChannels % i32(uniforms.w_shape[1]);\n    let xRow = outRow * uniforms.stride[0] + uniforms.dilation[0] * WRow - uniforms.pad[0];\n    let xCol = outCol * uniforms.stride[1] + uniforms.dilation[1] * WCol - uniforms.pad[1];\n    let xCh = ${col} % inChannels;\n    var resData = ${typeSnippet(innerElementSizeX, dataType)}(0.0);\n    // The bounds checking is always needed since we use it to pad zero for\n    // the 'same' padding type.\n    if (xRow >= 0 && xRow < ${xHeight} && xCol >= 0 && xCol < ${xWidth}) {\n      ${coordASnippet}\n      let xIndex = getIndexFromCoords4D(coord, vec4<i32>(uniforms.x_shape));\n      ${getXSnippet(innerElementSizeX)}\n    }\n    return resData;`;\n        const sampleX = isChannelsLast ? fitAOuter && fitInner ? `\n    let col = colIn * ${innerElementSizeX};\n    ${readXSnippet}` : `\n    let col = colIn * ${innerElementSizeX};\n    if (row < uniforms.dim_a_outer && col < uniforms.dim_inner) {\n      ${readXSnippet}\n    }\n    return ${typeSnippet(innerElementSizeX, dataType)}(0.0);` : fitInner && fitBOuter ? `\n    let col = colIn * ${innerElementSizeX};\n    ${readXSnippet}` : `\n    let col = colIn * ${innerElementSizeX};\n    if (row < uniforms.dim_inner && col < uniforms.dim_b_outer) {\n      ${readXSnippet}\n    }\n    return ${typeSnippet(innerElementSizeX, dataType)}(0.0);`;\n        const sampleW = `${getWSnippet(innerElementSizeW)}`;\n        const resType = typeSnippet(innerElementSize, dataType);\n        const aType = isChannelsLast ? typeSnippet(innerElementSizeX, dataType) : typeSnippet(innerElementSizeW, dataType);\n        const bType = isChannelsLast ? typeSnippet(innerElementSizeW, dataType) : typeSnippet(innerElementSizeX, dataType);\n        const applyActivation = getActivationSnippet(attributes, resType, dataType);\n        const userCode = `\n    fn mm_readA(batch: i32, row : i32, colIn : i32) -> ${aType} {\n      ${isChannelsLast ? sampleX : sampleW}\n    }\n\n    fn mm_readB(batch: i32, row : i32, colIn : i32) -> ${bType} {\n      ${isChannelsLast ? sampleW : sampleX}\n    }\n\n    fn mm_write(batch: i32, row : i32, colIn : i32, valueIn : ${resType}) {\n      let col = colIn * ${innerElementSize};\n      if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer)\n      {\n      var value = valueIn;\n      let outWidth = ${isChannelsLast ? \"i32(uniforms.result_shape[2])\" : \"i32(uniforms.result_shape[3])\"};\n      ${coordResSnippet}\n      ${biasSnippet(addBias)}\n      ${applyActivation}\n      setOutputAtCoords(coords[0], coords[1], coords[2], coords[3], value);\n      }\n    }`;\n        return userCode;\n      };\n      createConv2DMatMulProgramInfo = (inputs, attributes, outputShape, dimAOuter, dimBOuter, dimInner, hasBias, sequentialAccessByThreads) => {\n        const isChannelsLast = attributes.format === \"NHWC\";\n        const inChannels = isChannelsLast ? inputs[0].dims[3] : inputs[0].dims[1];\n        const batchSize = outputShape[0];\n        const outWidth = isChannelsLast ? outputShape[2] : outputShape[3];\n        const outHeight = isChannelsLast ? outputShape[1] : outputShape[2];\n        const outChannels = isChannelsLast ? outputShape[3] : outputShape[1];\n        const isVec4 = isChannelsLast && (inChannels % 4 === 0 || inChannels % 3 === 0) && outChannels % 4 === 0;\n        const dispatchX = isChannelsLast ? outChannels : outWidth * outHeight;\n        const dispatchY = isChannelsLast ? outWidth * outHeight : outChannels;\n        const workGroupSize = [8, 8, 1];\n        const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];\n        const dispatch = [\n          Math.ceil(dispatchX / workGroupSize[0] / elementsPerThread[0]),\n          Math.ceil(dispatchY / workGroupSize[1] / elementsPerThread[1]),\n          Math.ceil(batchSize / workGroupSize[2] / elementsPerThread[2])\n        ];\n        LOG_DEBUG(\"verbose\", () => `[conv2d_mm_webgpu] dispatch = ${dispatch}`);\n        const innerElementSize = isVec4 ? isChannelsLast && inChannels % 4 !== 0 ? 3 : 4 : 1;\n        const tileAOuter = workGroupSize[1] * elementsPerThread[1];\n        const tileBOuter = workGroupSize[0] * elementsPerThread[0];\n        const tileInner = Math.max(workGroupSize[0] * innerElementSize, workGroupSize[1]);\n        const fitAOuter = dimAOuter % tileAOuter === 0;\n        const fitBOuter = dimBOuter % tileBOuter === 0;\n        const fitInner = dimInner % tileInner === 0;\n        const elementsSize = isVec4 ? [innerElementSize, 4, 4] : [1, 1, 1];\n        const programUniforms = [\n          { type: 6 /* int32 */, data: dimAOuter },\n          { type: 6 /* int32 */, data: dimBOuter },\n          { type: 6 /* int32 */, data: dimInner },\n          { type: 6 /* int32 */, data: [attributes.pads[0], attributes.pads[1]] },\n          { type: 6 /* int32 */, data: attributes.strides },\n          { type: 6 /* int32 */, data: attributes.dilations }\n        ];\n        appendActivationUniformsData(attributes, programUniforms);\n        programUniforms.push(...createTensorShapeVariables(inputs[0].dims, inputs[1].dims));\n        const inputDependencies = [\"rank\", \"rank\"];\n        if (hasBias) {\n          programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n          inputDependencies.push(\"rank\");\n        }\n        programUniforms.push(...createTensorShapeVariables(outputShape));\n        const getShaderSource = (shaderHelper) => {\n          const uniforms = [\n            { name: \"dim_a_outer\", type: \"i32\" },\n            { name: \"dim_b_outer\", type: \"i32\" },\n            { name: \"dim_inner\", type: \"i32\" },\n            { name: \"pad\", type: \"i32\", length: 2 },\n            { name: \"stride\", type: \"i32\", length: 2 },\n            { name: \"dilation\", type: \"i32\", length: 2 }\n          ];\n          appendActivationUniforms(attributes, uniforms);\n          const components = isVec4 ? 4 : 1;\n          const t = tensorTypeToWsglStorageType(inputs[0].dataType);\n          let declareFunctions = `\n      fn setOutputAtIndex(flatIndex : i32, value : ${isVec4 ? `vec4<${t}>` : t}) {\n        result[flatIndex] = ${isVec4 ? `vec4<${t}>` : t}(value);\n      }\n      fn setOutputAtCoords(d0 : i32, d1 : i32, d2 : i32, d3 : i32, value : ${isVec4 ? `vec4<${t}>` : t}) {\n        let flatIndex = getOutputIndexFromCoords(vec4<i32>(d0, d1, d2, d3));\n        setOutputAtIndex(flatIndex ${isVec4 ? \"/ 4\" : \"\"}, value);\n      }`;\n          const x = inputVariable(\n            \"x\",\n            inputs[0].dataType,\n            inputs[0].dims.length,\n            innerElementSize === 3 ? 1 : innerElementSize\n          );\n          const w = inputVariable(\"w\", inputs[1].dataType, inputs[1].dims.length, components);\n          const inputVariables = [x, w];\n          const output = outputVariable(\"result\", inputs[0].dataType, outputShape.length, components);\n          if (hasBias) {\n            const bias = inputVariable(\"bias\", inputs[2].dataType, inputs[2].dims.length, components);\n            inputVariables.push(bias);\n            declareFunctions += `\n        fn getBiasByOutputCoords(coords : vec4<i32>) -> ${isVec4 ? `vec4<${t}>` : t} {\n          return bias[coords.${isChannelsLast ? \"w\" : \"y\"}${isVec4 ? \"/ 4\" : \"\"}];\n        }`;\n          }\n          return `\n        ${utilFunctions(\"uniforms.result_strides\")}\n        //struct Uniforms { xShape : vec4<i32>, wShape : vec4<i32>, outShape : vec4<i32>,\n        //  outShapeStrides: vec3<i32>, filterDims : vec2<i32>, pad : vec2<i32>, stride : vec2<i32>,\n        //  dilation : vec2<i32>, dimAOuter : i32, dimBOuter : i32, dimInner : i32 };\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n        ${declareFunctions}\n        ${conv2dCommonSnippet(\n            isChannelsLast,\n            fitAOuter,\n            fitBOuter,\n            fitInner,\n            hasBias,\n            attributes,\n            elementsSize[0],\n            elementsSize[1],\n            elementsSize[2],\n            t\n          )}\n        ${isVec4 ? makeMatMulPackedVec4Source(elementsPerThread, workGroupSize, t, void 0, !isChannelsLast, tileInner) : makeMatMulPackedSource(\n            elementsPerThread,\n            workGroupSize,\n            t,\n            void 0,\n            !isChannelsLast,\n            tileInner,\n            false,\n            void 0,\n            sequentialAccessByThreads\n          )}`;\n        };\n        return {\n          name: \"Conv2DMatMul\",\n          shaderCache: {\n            hint: `${attributes.cacheKey};${innerElementSize};${isVec4};${fitAOuter};${fitBOuter};${fitInner};${tileAOuter};${tileBOuter};${tileInner}`,\n            inputDependencies\n          },\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n            dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] },\n            programUniforms\n          }),\n          getShaderSource\n        };\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/conv-grouped.ts\n  var createGroupedConvProgramInfo, createGroupedConvVectorizeProgramInfo;\n  var init_conv_grouped = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/conv-grouped.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_common();\n      init_conv();\n      init_fuse_utils();\n      createGroupedConvProgramInfo = (inputs, attributes, squeezeOutputShapeFunction) => {\n        const hasBias = inputs.length > 2;\n        const processBias = hasBias ? \"value += b[output_channel];\" : \"\";\n        const xShape = inputs[0].dims;\n        const wShape = inputs[1].dims;\n        const outputChannelsPerGroup = wShape[0] / attributes.group;\n        const isChannelLast = attributes.format === \"NHWC\";\n        const outputShape = calculateOutputShape(\n          xShape,\n          wShape,\n          attributes.dilations,\n          attributes.pads,\n          attributes.strides,\n          isChannelLast\n        );\n        const outputSize = ShapeUtil.size(outputShape);\n        const programUniforms = [\n          { type: 12 /* uint32 */, data: outputSize },\n          { type: 12 /* uint32 */, data: attributes.dilations },\n          { type: 12 /* uint32 */, data: [attributes.strides[0], attributes.strides[1]] },\n          { type: 12 /* uint32 */, data: [attributes.pads[0], attributes.pads[1]] },\n          { type: 12 /* uint32 */, data: outputChannelsPerGroup }\n        ];\n        appendActivationUniformsData(attributes, programUniforms);\n        programUniforms.push(...createTensorShapeVariables(xShape, wShape));\n        const inputDependencies = [\"rank\", \"rank\"];\n        if (hasBias) {\n          programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n          inputDependencies.push(\"rank\");\n        }\n        programUniforms.push(...createTensorShapeVariables(outputShape));\n        const getShaderSource = (shaderHelper) => {\n          const output = outputVariable(\"output\", inputs[0].dataType, outputShape.length);\n          const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n          const applyActivation = getActivationSnippet(attributes, output.type.value, baseType);\n          const x = inputVariable(\"x\", inputs[0].dataType, xShape.length);\n          const w = inputVariable(\"w\", inputs[1].dataType, wShape.length);\n          const inputVars = [x, w];\n          if (hasBias) {\n            inputVars.push(inputVariable(\"b\", inputs[2].dataType, inputs[2].dims.length));\n          }\n          const uniforms = [\n            { name: \"output_size\", type: \"u32\" },\n            { name: \"dilations\", type: \"u32\", length: attributes.dilations.length },\n            { name: \"strides\", type: \"u32\", length: 2 },\n            { name: \"pads\", type: \"u32\", length: 2 },\n            { name: \"output_channels_per_group\", type: \"u32\" }\n          ];\n          appendActivationUniforms(attributes, uniforms);\n          return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.output_size\")}\n\n    let outputIndices = ${output.offsetToIndices(\"global_idx\")};\n    let batch: u32 = outputIndices[0];\n    let output_channel: u32 = outputIndices[${isChannelLast ? 3 : 1}];\n    let xRCCorner: vec2<u32> = vec2<u32>(outputIndices[${isChannelLast ? 1 : 2}], outputIndices[${isChannelLast ? 2 : 3}]) * uniforms.strides - uniforms.pads;\n    let group_id: u32 = output_channel / uniforms.output_channels_per_group;\n\n    var value: ${output.type.value} = ${output.type.value}(0);\n    for (var wInChannel: u32 = 0u; wInChannel < uniforms.w_shape[1]; wInChannel++) {\n      let input_channel = group_id * uniforms.w_shape[1] + wInChannel;\n      for (var wHeight: u32 = 0u; wHeight < uniforms.w_shape[2]; wHeight++) {\n        let xHeight = xRCCorner.x + wHeight * uniforms.dilations[0];\n\n        if (xHeight < 0u || xHeight >= uniforms.x_shape[${isChannelLast ? 1 : 2}]) {\n          continue;\n        }\n\n        for (var wWidth: u32 = 0u; wWidth < uniforms.w_shape[3]; wWidth++) {\n          let xWidth = xRCCorner.y + wWidth * uniforms.dilations[1];\n          if (xWidth < 0u || xWidth >= uniforms.x_shape[${isChannelLast ? 2 : 3}]) {\n            continue;\n          }\n\n          let xVal = ${isChannelLast ? x.get(\"batch\", \"xHeight\", \"xWidth\", \"input_channel\") : x.get(\"batch\", \"input_channel\", \"xHeight\", \"xWidth\")};\n          let wVal = ${w.get(\"output_channel\", \"wInChannel\", \"wHeight\", \"wWidth\")};\n          value += xVal*wVal;\n        }\n      }\n    }\n    ${processBias}\n    ${applyActivation}\n    ${output.setByOffset(\"global_idx\", \"value\")}\n  }`;\n        };\n        return {\n          name: \"GroupedConv\",\n          shaderCache: { hint: attributes.cacheKey, inputDependencies },\n          getRunData: () => ({\n            outputs: [{\n              dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,\n              dataType: inputs[0].dataType\n            }],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64\n              /* workgroup size */\n            ) },\n            programUniforms\n          }),\n          getShaderSource\n        };\n      };\n      createGroupedConvVectorizeProgramInfo = (inputs, attributes, outputShape) => {\n        const hasBias = inputs.length > 2;\n        const components = getMaxComponents(outputShape[3]);\n        const outputNumber = getMaxComponents(outputShape[2]);\n        const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;\n        const xShape = [inputs[0].dims[0], inputs[0].dims[1], inputs[0].dims[2], inputs[0].dims[3] / components];\n        const wShape = [inputs[1].dims[0], inputs[1].dims[1], inputs[1].dims[2], inputs[1].dims[3] / components];\n        const outputShapeInShader = [outputShape[0], outputShape[1], outputShape[2], outputShape[3] / components];\n        const programUniforms = [\n          { type: 12 /* uint32 */, data: outputSize },\n          { type: 6 /* int32 */, data: [attributes.strides[0], attributes.strides[1]] },\n          { type: 6 /* int32 */, data: [attributes.pads[0], attributes.pads[1]] }\n        ];\n        appendActivationUniformsData(attributes, programUniforms);\n        programUniforms.push(...createTensorShapeVariables(xShape, wShape, outputShapeInShader));\n        const xNumber = (outputNumber - 1) * attributes.strides[1] + wShape[1];\n        const getShaderSource = (shaderHelper) => {\n          const output = outputVariable(\"output\", inputs[0].dataType, outputShapeInShader.length, components);\n          const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n          const applyActivation = getActivationSnippet(attributes, output.type.value, baseType);\n          const x = inputVariable(\"x\", inputs[0].dataType, xShape.length, components);\n          const w = inputVariable(\"w\", inputs[1].dataType, wShape.length, components);\n          const inputVars = [x, w];\n          if (hasBias) {\n            inputVars.push(inputVariable(\"b\", inputs[2].dataType, inputs[2].dims, components));\n          }\n          const processBias = hasBias ? \"value += b[output_channel];\" : \"\";\n          const uniforms = [\n            { name: \"output_size\", type: \"u32\" },\n            { name: \"strides\", type: \"i32\", length: 2 },\n            { name: \"pads\", type: \"i32\", length: 2 }\n          ];\n          appendActivationUniforms(attributes, uniforms);\n          return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.output_size\")}\n    let width0 = uniforms.output_shape[3];\n    let output_channel = global_idx % width0;\n    var index1 = global_idx / width0;\n    let width1 = uniforms.output_shape[2] / ${outputNumber}u;\n    let col = (index1 % width1) * ${outputNumber}u;\n    index1 = index1 / width1;\n    let row = index1 % uniforms.output_shape[1];\n    let batch = index1 / uniforms.output_shape[1];\n\n    let x_corner = vec2<i32>(i32(row), i32(col)) * uniforms.strides - uniforms.pads;\n\n    var x_vals: array<${x.type.value}, ${xNumber}>;\n    var values: array<${output.type.value}, ${outputNumber}>;\n    let input_channel = output_channel;\n    // Use constant instead of uniform can give better performance for w's height/width.\n    for (var w_height: u32 = 0u; w_height < ${wShape[0]}; w_height++) {\n      let x_height = x_corner.x + i32(w_height);\n      if (x_height >= 0 && u32(x_height) < uniforms.x_shape[1]) {\n        for (var i = 0; i < ${xNumber}; i++) {\n          let x_width = x_corner.y + i;\n          if (x_width >= 0 && u32(x_width) < uniforms.x_shape[2]) {\n            x_vals[i] = ${x.get(\"batch\", \"u32(x_height)\", \"u32(x_width)\", \"input_channel\")};\n          } else {\n            x_vals[i] = ${x.type.value}(0);\n          }\n        }\n        for (var w_width: u32 = 0u; w_width < ${wShape[1]}; w_width++) {\n          let w_val = ${w.get(\"w_height\", \"w_width\", \"0\", \"output_channel\")};\n          for (var i = 0u; i < ${outputNumber}u; i++) {\n            values[i] = fma(x_vals[i * u32(uniforms.strides[1]) + w_width], w_val, values[i]);\n          }\n        }\n      }\n    }\n\n    for (var i = 0u; i < ${outputNumber}u; i++) {\n      var value = values[i];\n      ${processBias}\n      ${applyActivation}\n      ${output.set(\"batch\", \"row\", \"col + i\", \"output_channel\", \"value\")};\n    }\n  }`;\n        };\n        return {\n          name: \"GroupedConv-Vectorize\",\n          shaderCache: {\n            hint: `${attributes.cacheKey};${components};${outputNumber};${xNumber};${wShape[0]};${wShape[1]}`,\n            inputDependencies: hasBias ? [\"rank\", \"rank\", \"type\"] : [\"rank\", \"rank\"]\n          },\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64\n              /* workgroup size */\n            ) },\n            programUniforms\n          }),\n          getShaderSource\n        };\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/matmul.ts\n  var createNaiveMatmulProgramInfo, validateInputs8, matMul;\n  var init_matmul = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/matmul.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_matmul_packed_webgpu();\n      init_common();\n      init_fuse_utils();\n      createNaiveMatmulProgramInfo = (inputs, activationAttributes, outputShape, reshapedOutputShape, isChannelsLast = false) => {\n        const aShape = inputs[0].dims;\n        const bShape = inputs[1].dims;\n        const M = aShape[aShape.length - 2];\n        const N = bShape[bShape.length - 1];\n        const K = aShape[aShape.length - 1];\n        const components = getMaxComponents(N);\n        const aComponents = getMaxComponents(K);\n        const outputNumber = getMaxComponents(M);\n        const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;\n        const hasBias = inputs.length > 2;\n        const outerDims = reshapedOutputShape ? reshapedOutputShape.slice(0, -2) : outputShape.slice(0, -2);\n        const batchSize = ShapeUtil.size(outerDims);\n        const outputShapeInShader = [batchSize, M, N];\n        const programUniforms = [\n          { type: 12 /* uint32 */, data: outputSize },\n          { type: 12 /* uint32 */, data: M },\n          { type: 12 /* uint32 */, data: N },\n          { type: 12 /* uint32 */, data: K }\n        ];\n        appendActivationUniformsData(activationAttributes, programUniforms);\n        programUniforms.push(...createTensorShapeVariables(outerDims, aShape, bShape));\n        if (hasBias) {\n          programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n        }\n        programUniforms.push(...createTensorShapeVariables(outputShapeInShader));\n        const getShaderSource = (shaderHelper) => {\n          const batchDims = internalVariable(\"batch_dims\", inputs[0].dataType, outerDims.length);\n          const a = inputVariable(\"a\", inputs[0].dataType, aShape.length, aComponents);\n          const b = inputVariable(\"b\", inputs[1].dataType, bShape.length, components);\n          const output = outputVariable(\"output\", inputs[0].dataType, outputShapeInShader.length, components);\n          const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n          const applyActivation = getActivationSnippet(activationAttributes, output.type.value, baseType);\n          const inputVariables = [a, b];\n          let processBias = \"\";\n          if (hasBias) {\n            const biasComponents = isChannelsLast ? components : 1;\n            inputVariables.push(inputVariable(\"bias\", inputs[2].dataType, inputs[2].dims.length, biasComponents));\n            processBias = `${isChannelsLast ? `value += bias[col / ${biasComponents}];` : `value += ${output.type.value}(bias[row + i]);`}`;\n          }\n          const outerDimsA = aShape.slice(0, -2);\n          const outerDimsB = bShape.slice(0, -2);\n          const broadCastADims = getBroadcastDims(outerDimsA, outerDims);\n          const broadCastBDims = getBroadcastDims(outerDimsB, outerDims);\n          const uniforms = [\n            { name: \"output_size\", type: \"u32\" },\n            { name: \"M\", type: \"u32\" },\n            { name: \"N\", type: \"u32\" },\n            { name: \"K\", type: \"u32\" }\n          ];\n          appendActivationUniforms(activationAttributes, uniforms);\n          const getIndices = (variable, broadCastDims) => {\n            const rank = variable.rank;\n            const name = variable.name;\n            if (rank === 2) {\n              return `var ${name}_indices = ${variable.type.indices}(0u, 0u);`;\n            }\n            const batchRank = batchDims.rank;\n            let resStr = `var ${name}_indices: ${variable.type.indices};`;\n            for (let i = rank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) {\n              resStr += `\n${name}_indices[${i}] = ${batchRank > 1 ? `batch_indices[${j}]` : \"batch_indices\"};`;\n            }\n            broadCastDims.forEach((i) => {\n              resStr += `\n${name}_indices[${i}] = 0;`;\n            });\n            resStr += `${name}_indices[${rank - 2}] = 0u;\n                     ${name}_indices[${rank - 1}] = 0u;`;\n            return resStr;\n          };\n          const calcResult = () => {\n            let calcStr = `var a_data: ${a.type.value};`;\n            for (let i = 0; i < aComponents; i++) {\n              calcStr += `\n              let b_data${i} = b[(b_offset + (k + ${i}) * uniforms.N + col) / ${components}];`;\n            }\n            for (let i = 0; i < outputNumber; i++) {\n              calcStr += `a_data = a[(a_offset + (row + ${i}) * uniforms.K + k) / ${aComponents}];`;\n              for (let j = 0; j < aComponents; j++) {\n                calcStr += `\n            values[${i}] = fma(${b.type.value}(a_data${aComponents === 1 ? \"\" : `[${j}]`}), b_data${j}, values[${i}]);\n`;\n              }\n            }\n            return calcStr;\n          };\n          return `\n  ${shaderHelper.registerUniforms(uniforms).registerInternalVariables(batchDims).declareVariables(\n            ...inputVariables,\n            output\n          )}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.output_size\")}\n    let col = (global_idx % (uniforms.N / ${components})) * ${components};\n    var index1 = global_idx / (uniforms.N / ${components});\n    let stride1 = uniforms.M / ${outputNumber};\n    let row = (index1 % stride1) * ${outputNumber};\n    let batch = index1 / stride1;\n\n    ${outputShape.length === 2 ? \"\" : `let batch_indices = ${batchDims.offsetToIndices(\"batch\")};`}\n    ${getIndices(a, broadCastADims)}\n    let a_offset = ${a.indicesToOffset(\"a_indices\")};\n    ${getIndices(b, broadCastBDims)}\n    let b_offset = ${b.indicesToOffset(\"b_indices\")};\n    var values: array<${output.type.value}, ${outputNumber}>;\n    for (var k: u32 = 0u; k < uniforms.K; k = k + ${aComponents}) {\n      ${calcResult()}\n    }\n    for (var i = 0u; i < ${outputNumber}u; i++) {\n      var value = values[i];\n      ${processBias}\n      ${applyActivation}\n      let cur_indices = ${output.type.indices}(batch, row + i, col);\n      let offset = ${output.indicesToOffset(\"cur_indices\")};\n      ${output.setByOffset(`offset / ${components}`, \"value\")};\n    }\n  }\n  `;\n        };\n        return {\n          name: \"MatMulNaive\",\n          shaderCache: {\n            hint: `${activationAttributes.activation};${components};${aComponents};${outputNumber};${isChannelsLast}`,\n            inputDependencies: hasBias ? [\"rank\", \"rank\", \"rank\"] : [\"rank\", \"rank\"]\n          },\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64\n              /* workgroup size */\n            ) },\n            programUniforms\n          }),\n          getShaderSource\n        };\n      };\n      validateInputs8 = (inputs) => {\n        if (!inputs || inputs.length !== 2) {\n          throw new Error(\"MatMul requires 2 inputs.\");\n        }\n        if (inputs[0].dims[inputs[0].dims.length - 1] !== inputs[1].dims[inputs[1].dims.length - 2]) {\n          throw new Error(\"shared dimension does not match.\");\n        }\n      };\n      matMul = (context) => {\n        validateInputs8(context.inputs);\n        const outputShape = BroadcastUtil.calcShape(context.inputs[0].dims, context.inputs[1].dims, true);\n        if (!outputShape) {\n          throw new Error(\"Can't use matmul on the given tensors\");\n        }\n        const N = outputShape[outputShape.length - 1];\n        const K = context.inputs[0].dims[context.inputs[0].dims.length - 1];\n        if (N < 8 && K < 8) {\n          context.compute(createNaiveMatmulProgramInfo(context.inputs, { activation: \"\" }, outputShape));\n        } else {\n          context.compute(createMatmulProgramInfo(context.inputs, { activation: \"\" }, outputShape));\n        }\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/conv.ts\n  var calculateOutputShape, weightTransposeAttribute, validateInputs9, getAdjustedConvAttributes, parseConvAttributes, conv2d, conv1d, conv;\n  var init_conv = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/conv.ts\"() {\n      \"use strict\";\n      init_util();\n      init_conv2d_mm_webgpu();\n      init_matmul_packed_webgpu();\n      init_conv_grouped();\n      init_fuse_utils();\n      init_matmul();\n      init_transpose();\n      calculateOutputShape = (inputShape, kernelShape, dilations, adjustPads, strides, isChannelLast) => {\n        const batchSize = inputShape[0];\n        const inputSpatialShape = inputShape.slice(isChannelLast ? 1 : 2, isChannelLast ? 3 : 4);\n        const spatialRank = inputSpatialShape.length;\n        const outChannels = kernelShape[0];\n        const kernelSpatialShape = kernelShape.slice(2);\n        const dilatedKernelShape = kernelSpatialShape.map((v, i) => v + (v - 1) * (dilations[i] - 1));\n        const inputSpatialShapeWithPad = inputSpatialShape.map((v, i) => v + adjustPads[i] + adjustPads[i + spatialRank]);\n        const outputShape = inputSpatialShapeWithPad.map((v, i) => Math.floor((v - dilatedKernelShape[i] + strides[i]) / strides[i]));\n        outputShape.splice(0, 0, batchSize);\n        outputShape.splice(isChannelLast ? 3 : 1, 0, outChannels);\n        return outputShape;\n      };\n      weightTransposeAttribute = [2, 3, 1, 0];\n      validateInputs9 = (inputs, attributes) => {\n        if (!inputs || inputs.length !== 2 && inputs.length !== 3) {\n          throw new Error(\"Conv requires 2 or 3 inputs\");\n        }\n        if (inputs[0].dims.length !== 4 && inputs[0].dims.length !== 3) {\n          throw new Error(\"currently only support conv 1D and 2D\");\n        }\n        if (inputs[0].dims.length !== inputs[1].dims.length) {\n          throw new Error(\"filter does not have same dimension as input\");\n        }\n        const dataChannel = inputs[0].dims[attributes.format === \"NHWC\" ? inputs[0].dims.length - 1 : 1];\n        const filterInChannel = inputs[1].dims[1] * attributes.group;\n        if (dataChannel !== filterInChannel) {\n          throw new Error(\"FILTER_IN_CHANNEL should be equal to DATA_CHANNEL\");\n        }\n        if (inputs.length === 3 && (inputs[2].dims.length !== 1 || inputs[1].dims[0] !== inputs[2].dims[0])) {\n          throw new Error(\"invalid bias\");\n        }\n        const spatialRank = inputs[0].dims.length - 2;\n        if (attributes.dilations.length !== spatialRank) {\n          throw new Error(`dilations should be ${spatialRank}D`);\n        }\n        if (attributes.strides.length !== spatialRank) {\n          throw new Error(`strides should be ${spatialRank}D`);\n        }\n        if (attributes.pads.length !== spatialRank * 2) {\n          throw new Error(`pads should be ${spatialRank * 2}D`);\n        }\n        if (attributes.kernelShape.length !== 0 && attributes.kernelShape.length !== inputs[1].dims.length - 2) {\n          throw new Error(\"invalid kernel shape\");\n        }\n      };\n      getAdjustedConvAttributes = (attributes, inputs) => {\n        const kernelShape = attributes.kernelShape.slice();\n        for (let i = 2; i < inputs[1].dims.length; ++i) {\n          if (kernelShape[i - 2] === 0) {\n            kernelShape[i - 2] = inputs[1].dims[i];\n          }\n        }\n        const pads = attributes.pads.slice();\n        PoolConvUtil.adjustPadsBasedOnAutoPad(\n          inputs[0].dims,\n          attributes.strides,\n          attributes.dilations,\n          kernelShape,\n          pads,\n          attributes.format === \"NHWC\",\n          attributes.autoPad\n        );\n        const newAttributes = Object.assign({}, attributes);\n        Object.assign(newAttributes, { kernelShape, pads });\n        return newAttributes;\n      };\n      parseConvAttributes = (attributes) => {\n        const activationAttributes = parseInternalActivationAttributes(attributes);\n        const format = attributes.format;\n        const autoPad = [\"NOTSET\", \"VALID\", \"SAME_UPPER\", \"SAME_LOWER\"][attributes.auto_pad];\n        const dilations = attributes.dilations;\n        const group = attributes.group;\n        const kernelShape = attributes.kernel_shape;\n        const pads = attributes.pads;\n        const strides = attributes.strides;\n        const wIsConst = attributes.w_is_const();\n        return {\n          autoPad,\n          format,\n          dilations,\n          group,\n          kernelShape,\n          pads,\n          strides,\n          wIsConst,\n          ...activationAttributes,\n          cacheKey: `${attributes.format};${activationAttributes.activation};`\n        };\n      };\n      conv2d = (context, inputs, attributes) => {\n        const adjustedAttributes = getAdjustedConvAttributes(attributes, inputs);\n        const isChannelsLast = attributes.format === \"NHWC\";\n        if (attributes.group !== 1) {\n          const enableGroupedConvVectorize = !context.adapterInfo.isArchitecture(\"ampere\");\n          if (enableGroupedConvVectorize && isChannelsLast && inputs[1].dims[0] === attributes.group && inputs[1].dims[1] === 1 && attributes.dilations[0] === 1 && attributes.dilations[1] === 1) {\n            const outputShape2 = calculateOutputShape(\n              inputs[0].dims,\n              inputs[1].dims,\n              attributes.dilations,\n              adjustedAttributes.pads,\n              attributes.strides,\n              isChannelsLast\n            );\n            const transposedWeight2 = context.kernelCustomData.wT ?? context.compute(\n              createTransposeProgramInfo(inputs[1], weightTransposeAttribute),\n              { inputs: [1], outputs: [attributes.wIsConst ? -2 : -1] }\n            )[0];\n            if (attributes.wIsConst && !context.kernelCustomData.wT) {\n              context.kernelCustomData.wT = transposedWeight2;\n            }\n            const convInputs2 = [inputs[0], transposedWeight2];\n            if (inputs.length === 3) {\n              convInputs2.push(inputs[2]);\n            }\n            context.compute(\n              createGroupedConvVectorizeProgramInfo(convInputs2, adjustedAttributes, outputShape2),\n              { inputs: convInputs2 }\n            );\n          } else {\n            context.compute(createGroupedConvProgramInfo(inputs, adjustedAttributes));\n          }\n          return;\n        }\n        const hasBias = inputs.length === 3;\n        const inputHeight = inputs[0].dims[isChannelsLast ? 1 : 2];\n        const inputWidth = inputs[0].dims[isChannelsLast ? 2 : 3];\n        const inputChannels = inputs[0].dims[isChannelsLast ? 3 : 1];\n        const weightHeight = inputs[1].dims[2];\n        const weightWidth = inputs[1].dims[3];\n        const outputShape = calculateOutputShape(\n          inputs[0].dims,\n          inputs[1].dims,\n          attributes.dilations,\n          adjustedAttributes.pads,\n          attributes.strides,\n          isChannelsLast\n        );\n        const outHeight = outputShape[isChannelsLast ? 1 : 2];\n        const outWidth = outputShape[isChannelsLast ? 2 : 3];\n        const outChannels = outputShape[isChannelsLast ? 3 : 1];\n        const sameSize = isChannelsLast && weightHeight === inputHeight && weightWidth === inputWidth && attributes.pads[0] === 0 && attributes.pads[1] === 0;\n        if (sameSize || weightHeight === 1 && weightWidth === 1 && attributes.dilations[0] === 1 && attributes.dilations[1] === 1 && attributes.strides[0] === 1 && attributes.strides[1] === 1 && attributes.pads[0] === 0 && attributes.pads[1] === 0) {\n          const batch = outputShape[0];\n          let xReshaped, wReshaped, matmulOutputShape;\n          const matmulInputs = [];\n          if (isChannelsLast) {\n            const transposedWeight2 = context.kernelCustomData.wT ?? context.compute(\n              createTransposeProgramInfo(inputs[1], weightTransposeAttribute),\n              { inputs: [1], outputs: [attributes.wIsConst ? -2 : -1] }\n            )[0];\n            if (attributes.wIsConst && !context.kernelCustomData.wT) {\n              context.kernelCustomData.wT = transposedWeight2;\n            }\n            if (sameSize) {\n              const sharedDim = inputHeight * inputWidth * inputChannels;\n              xReshaped = inputs[0].reshape([1, batch, sharedDim]);\n              wReshaped = transposedWeight2.reshape([1, sharedDim, outChannels]);\n              matmulOutputShape = [1, batch, outChannels];\n            } else {\n              xReshaped = inputs[0].reshape([batch, inputHeight * inputWidth, inputChannels]);\n              wReshaped = transposedWeight2.reshape([1, inputChannels, outChannels]);\n              matmulOutputShape = [batch, outHeight * outWidth, outChannels];\n            }\n            matmulInputs.push(xReshaped);\n            matmulInputs.push(wReshaped);\n          } else {\n            xReshaped = inputs[0].reshape([batch, inputChannels, inputHeight * inputWidth]);\n            wReshaped = inputs[1].reshape([1, outChannels, inputChannels]);\n            matmulOutputShape = [batch, outChannels, outHeight * outWidth];\n            matmulInputs.push(wReshaped);\n            matmulInputs.push(xReshaped);\n          }\n          if (hasBias) {\n            matmulInputs.push(inputs[2]);\n          }\n          const N = matmulOutputShape[2];\n          const K = matmulInputs[0].dims[matmulInputs[0].dims.length - 1];\n          if (N < 8 && K < 8) {\n            context.compute(\n              createNaiveMatmulProgramInfo(\n                matmulInputs,\n                adjustedAttributes,\n                outputShape,\n                matmulOutputShape,\n                isChannelsLast\n              ),\n              { inputs: matmulInputs }\n            );\n          } else {\n            context.compute(\n              createMatmulProgramInfo(matmulInputs, adjustedAttributes, outputShape, matmulOutputShape, isChannelsLast),\n              { inputs: matmulInputs }\n            );\n          }\n          return;\n        }\n        const sequentialAccessByThreads = (\n          /* backend.adapterInfo.isIntel() */\n          true\n        );\n        const transposedWeight = context.kernelCustomData.wT ?? context.compute(\n          createTransposeProgramInfo(inputs[1], weightTransposeAttribute),\n          { inputs: [1], outputs: [attributes.wIsConst ? -2 : -1] }\n        )[0];\n        if (attributes.wIsConst && !context.kernelCustomData.wT) {\n          context.kernelCustomData.wT = transposedWeight;\n        }\n        const convInputs = [inputs[0], transposedWeight];\n        if (hasBias) {\n          convInputs.push(inputs[2]);\n        }\n        const dimAOuter = isChannelsLast ? outHeight * outWidth : outChannels;\n        const dimBOuter = isChannelsLast ? outChannels : outHeight * outWidth;\n        const dimInner = weightHeight * weightWidth * inputChannels;\n        context.compute(\n          createConv2DMatMulProgramInfo(\n            convInputs,\n            adjustedAttributes,\n            outputShape,\n            dimAOuter,\n            dimBOuter,\n            dimInner,\n            hasBias,\n            sequentialAccessByThreads\n          ),\n          { inputs: convInputs }\n        );\n      };\n      conv1d = (context, attributes) => {\n        const isChannelLast = attributes.format === \"NHWC\";\n        const inputs = [\n          context.inputs[0].reshape(\n            isChannelLast ? (\n              // [N, W, C] -> [N, H=1, W, C]\n              [context.inputs[0].dims[0], 1, context.inputs[0].dims[1], context.inputs[0].dims[2]]\n            ) : (\n              // [N, C, W] -> [N, C, H=1, W]\n              [context.inputs[0].dims[0], context.inputs[0].dims[1], 1, context.inputs[0].dims[2]]\n            )\n          ),\n          //[FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kW] -> [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kH=1, kW]\n          context.inputs[1].reshape([context.inputs[1].dims[0], context.inputs[1].dims[1], 1, context.inputs[1].dims[2]])\n        ];\n        if (context.inputs.length === 3) {\n          inputs.push(context.inputs[2]);\n        }\n        const pads = [0, attributes.pads[0], 0, attributes.pads[1]];\n        const strides = [1].concat(attributes.strides);\n        const dilations = [1].concat(attributes.dilations);\n        const kernelShape = [1].concat(attributes.kernelShape);\n        const adjustedAttributes = getAdjustedConvAttributes({ ...attributes, pads, strides, dilations, kernelShape }, inputs);\n        context.compute(createGroupedConvProgramInfo(\n          inputs,\n          adjustedAttributes,\n          (outputShape) => isChannelLast ? [outputShape[0], outputShape[2], outputShape[3]] : []\n        ));\n      };\n      conv = (context, attributes) => {\n        validateInputs9(context.inputs, attributes);\n        if (context.inputs[0].dims.length === 3) {\n          conv1d(context, attributes);\n        } else {\n          conv2d(context, context.inputs, attributes);\n        }\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_mm_webgpu.ts\n  var conv2dTransposeCommonSnippet, createConv2DTransposeMatMulProgramInfo;\n  var init_conv_backprop_mm_webgpu = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_mm_webgpu.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_log();\n      init_common();\n      init_fuse_utils();\n      init_activation_util();\n      init_conv_util();\n      init_matmul_packed_webgpu();\n      conv2dTransposeCommonSnippet = (isChannelsLast, addBias = false, attributes, type, innerElementSize = 4) => {\n        const getWSnippet = (innerElementSize2) => {\n          switch (innerElementSize2) {\n            case 1:\n              return \"return w[getIndexFromCoords4D(coord, vec4<i32>(uniforms.w_shape))];\";\n            case 4:\n              return `\n            let coord1 = vec4<i32>(coordX, coordY, col + 1, rowInner);\n            let coord2 = vec4<i32>(coordX, coordY, col + 2, rowInner);\n            let coord3 = vec4<i32>(coordX, coordY, col + 3, rowInner);\n            let v0 = w[getIndexFromCoords4D(coord, vec4<i32>(uniforms.w_shape))];\n            let v1 = w[getIndexFromCoords4D(coord1, vec4<i32>(uniforms.w_shape))];\n            let v2 = w[getIndexFromCoords4D(coord2, vec4<i32>(uniforms.w_shape))];\n            let v3 = w[getIndexFromCoords4D(coord3, vec4<i32>(uniforms.w_shape))];\n            return ${type}(v0, v1, v2, v3);\n            `;\n            default:\n              throw new Error(`innerElementSize ${innerElementSize2} is not supported.`);\n          }\n        };\n        const coordASnippet = isChannelsLast ? `\n      let coord = vec4<i32>(batch, iXR, iXC, xCh);\n      ` : `\n      let coord = vec4<i32>(batch, xCh, iXR, iXC);\n      `;\n        const coordResSnippet = isChannelsLast ? `\n    let coords = vec4<i32>(\n      batch,\n      row / outWidth,\n      row % outWidth,\n      col);\n    ` : `\n    let coords = vec4<i32>(\n      batch,\n      row,\n      col / outWidth,\n      col % outWidth);\n    `;\n        const xHeight = isChannelsLast ? \"i32(uniforms.x_shape[1])\" : \"i32(uniforms.x_shape[2])\";\n        const xWidth = isChannelsLast ? \"i32(uniforms.x_shape[2])\" : \"i32(uniforms.x_shape[3])\";\n        const row = isChannelsLast ? \"row\" : \"col\";\n        const col = isChannelsLast ? \"col\" : \"row\";\n        const readASnippet = `\n      let inChannels = ${isChannelsLast ? \"i32(uniforms.x_shape[3])\" : \"i32(uniforms.x_shape[1])\"};\n      let outWidth = ${isChannelsLast ? \"i32(uniforms.result_shape[2])\" : \"i32(uniforms.result_shape[3])\"};\n      let outRow = ${row} / outWidth;\n      let outCol = ${row} % outWidth;\n\n      let WRow = ${col} / (uniforms.filter_dims[1] * inChannels);\n      let WCol = ${col} / inChannels % uniforms.filter_dims[1];\n      let xR = f32(outRow - uniforms.pads[0] + uniforms.dilations[0] * WRow) / f32(uniforms.strides[0]);\n      let xC = f32(outCol - uniforms.pads[1] + uniforms.dilations[1] * WCol) / f32(uniforms.strides[1]);\n      if (xR < 0.0 || xR >= f32(${xHeight}) || fract(xR) > 0.0) {\n        return ${type}(0.0);\n      }\n      if (xC < 0.0 || xC >= f32(${xWidth}) || fract(xC) > 0.0) {\n        return ${type}(0.0);\n      }\n      let iXR = i32(xR);\n      let iXC = i32(xC);\n      let xCh = ${col} % inChannels;\n      ${coordASnippet}\n      return x[getIndexFromCoords4D(coord, vec4<i32>(uniforms.x_shape))/${innerElementSize}];`;\n        const sampleA = isChannelsLast ? `\n      let col = colIn * ${innerElementSize};\n      if (row < uniforms.dim_a_outer && col < uniforms.dim_inner) {\n        ${readASnippet}\n      }\n      return ${type}(0.0);` : `\n      let col = colIn * ${innerElementSize};\n      if (row < uniforms.dim_inner && col < uniforms.dim_b_outer) {\n        ${readASnippet}\n      }\n      return ${type}(0.0);`;\n        const sampleW = `\n      let col = colIn * ${innerElementSize};\n      let inChannels = ${isChannelsLast ? \"i32(uniforms.x_shape[3])\" : \"i32(uniforms.x_shape[1])\"};\n      let coordX = uniforms.filter_dims[0] - 1 - row / (uniforms.filter_dims[1] * inChannels);\n      let coordY = uniforms.filter_dims[1] - 1 - (row / inChannels) % uniforms.filter_dims[1];\n      if (${isChannelsLast ? \"row < uniforms.dim_inner && col < uniforms.dim_b_outer\" : \"row < uniforms.dim_inner && col < uniforms.dim_a_outer\"}  && coordX >= 0 && coordY >= 0) {\n        let rowInner = row % inChannels;\n        let coord = vec4<i32>(coordX, coordY, col, rowInner);\n        ${getWSnippet(innerElementSize)}\n      }\n      return ${type}(0.0);\n      `;\n        const applyActivation = getActivationSnippet(attributes, type);\n        const userCode = `\n  fn mm_readA(batch: i32, row : i32, colIn : i32) -> ${type} {\n    ${isChannelsLast ? sampleA : sampleW}\n  }\n\n  fn mm_readB(batch: i32, row : i32, colIn : i32) -> ${type} {\n    ${isChannelsLast ? sampleW : sampleA}\n  }\n\n  fn mm_write(batch: i32, row : i32, colIn : i32, valueInput : ${type}) {\n    let col = colIn * ${innerElementSize};\n    if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer) {\n      var value = valueInput;\n      let outWidth = ${isChannelsLast ? \"i32(uniforms.result_shape[2])\" : \"i32(uniforms.result_shape[3])\"};\n      ${coordResSnippet}\n      ${biasSnippet(addBias)}\n      ${applyActivation}\n      result[getIndexFromCoords4D(coords, vec4<i32>(uniforms.result_shape))/${innerElementSize}] = value;\n    }\n  }`;\n        return userCode;\n      };\n      createConv2DTransposeMatMulProgramInfo = (inputs, attributes, outputShape, dimAOuter, dimBOuter, dimInner, hasBias, sequentialAccessByThreads) => {\n        const isChannelsLast = attributes.format === \"NHWC\";\n        const inChannels = isChannelsLast ? inputs[0].dims[3] : inputs[0].dims[1];\n        const batchSize = outputShape[0];\n        const outWidth = isChannelsLast ? outputShape[2] : outputShape[3];\n        const outHeight = isChannelsLast ? outputShape[1] : outputShape[2];\n        const outChannels = isChannelsLast ? outputShape[3] : outputShape[1];\n        const isVec4 = isChannelsLast && (inChannels % 4 === 0 && inChannels % 3) && outChannels % 4 === 0;\n        const dispatchX = isChannelsLast ? outChannels : outWidth * outHeight;\n        const dispatchY = isChannelsLast ? outWidth * outHeight : outChannels;\n        const workGroupSize = [8, 8, 1];\n        const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];\n        const dispatch = [\n          Math.ceil(dispatchX / workGroupSize[0] / elementsPerThread[0]),\n          Math.ceil(dispatchY / workGroupSize[1] / elementsPerThread[1]),\n          Math.ceil(batchSize / workGroupSize[2] / elementsPerThread[2])\n        ];\n        LOG_DEBUG(\"verbose\", () => `[conv_backprop_mm_webgpu] dispatch = ${dispatch}`);\n        const innerElementSize = isVec4 ? 4 : 1;\n        const tileInner = Math.max(workGroupSize[0] * innerElementSize, workGroupSize[1]);\n        const components = isVec4 ? 4 : 1;\n        const filterDims = [attributes.kernelShape[isChannelsLast ? 1 : 2], attributes.kernelShape[isChannelsLast ? 2 : 3]];\n        const effectiveFilterDims = [\n          filterDims[0] + (attributes.dilations[0] <= 1 ? 0 : (filterDims[0] - 1) * (attributes.dilations[0] - 1)),\n          filterDims[1] + (attributes.dilations[1] <= 1 ? 0 : (filterDims[1] - 1) * (attributes.dilations[1] - 1))\n        ];\n        const pads = [\n          effectiveFilterDims[0] - 1 - Math.floor((attributes.pads[0] + attributes.pads[2]) / 2),\n          effectiveFilterDims[1] - 1 - Math.floor((attributes.pads[1] + attributes.pads[3]) / 2)\n        ];\n        const programUniforms = [\n          { type: 6 /* int32 */, data: dimAOuter },\n          { type: 6 /* int32 */, data: dimBOuter },\n          { type: 6 /* int32 */, data: dimInner },\n          { type: 6 /* int32 */, data: attributes.strides },\n          { type: 6 /* int32 */, data: attributes.dilations },\n          { type: 6 /* int32 */, data: filterDims },\n          { type: 6 /* int32 */, data: pads }\n        ];\n        appendActivationUniformsData(attributes, programUniforms);\n        programUniforms.push(...createTensorShapeVariables(inputs[0].dims, inputs[1].dims));\n        const inputDependencies = [\"rank\", \"rank\"];\n        if (hasBias) {\n          programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n          inputDependencies.push(\"rank\");\n        }\n        programUniforms.push(...createTensorShapeVariables(outputShape));\n        const getShaderSource = (shaderHelper) => {\n          const x = inputVariable(\"x\", inputs[0].dataType, inputs[0].dims.length, components);\n          const w = inputVariable(\"w\", inputs[1].dataType, inputs[1].dims.length, 1);\n          const output = outputVariable(\"result\", inputs[0].dataType, outputShape.length, components);\n          const inputVariables = [x, w];\n          let declareFunctions = \"\";\n          if (hasBias) {\n            const bias = inputVariable(\"bias\", inputs[2].dataType, inputs[2].dims.length, components);\n            inputVariables.push(bias);\n            declareFunctions += `\n          fn getBiasByOutputCoords(coords : vec4<i32>) -> ${bias.type.value} {\n            return bias[coords.${isChannelsLast ? \"w\" : \"y\"}${isVec4 ? \"/ 4\" : \"\"}];\n          }`;\n          }\n          const uniforms = [\n            { name: \"dim_a_outer\", type: \"i32\" },\n            { name: \"dim_b_outer\", type: \"i32\" },\n            { name: \"dim_inner\", type: \"i32\" },\n            { name: \"strides\", type: \"i32\", length: 2 },\n            { name: \"dilations\", type: \"i32\", length: 2 },\n            { name: \"filter_dims\", type: \"i32\", length: filterDims.length },\n            { name: \"pads\", type: \"i32\", length: pads.length }\n          ];\n          appendActivationUniforms(attributes, uniforms);\n          const elemType = tensorTypeToWsglStorageType(inputs[0].dataType, 1);\n          if (elemType !== \"f16\" && elemType !== \"f32\") {\n            throw new Error(`elemType ${elemType} is not supported.`);\n          }\n          return `\n        ${utilFunctions(\"uniforms.result_strides\")}\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)};\n        ${declareFunctions}\n        ${conv2dTransposeCommonSnippet(isChannelsLast, hasBias, attributes, x.type.value, innerElementSize)}\n        ${isVec4 ? makeMatMulPackedVec4Source(\n            elementsPerThread,\n            workGroupSize,\n            elemType,\n            void 0,\n            !isChannelsLast,\n            tileInner\n          ) : makeMatMulPackedSource(\n            elementsPerThread,\n            workGroupSize,\n            elemType,\n            void 0,\n            !isChannelsLast,\n            tileInner,\n            false,\n            void 0,\n            sequentialAccessByThreads\n          )}`;\n        };\n        return {\n          name: \"Conv2DTransposeMatMul\",\n          shaderCache: { hint: `${attributes.cacheKey};${elementsPerThread};${workGroupSize};${isVec4}`, inputDependencies },\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n            dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] },\n            programUniforms\n          }),\n          getShaderSource\n        };\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_webgpu.ts\n  var createConvTranspose2DOpProgramShaderSource, createConvTranspose2DProgramInfo;\n  var init_conv_backprop_webgpu = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_webgpu.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_log();\n      init_util();\n      init_common();\n      createConvTranspose2DOpProgramShaderSource = (shaderHelper, inputs, outputShape, hasBias, is1DimensionDispatch, isVec4 = false, dataType, uniforms, isChannelsLast = false) => {\n        const rowDim = isChannelsLast ? 1 : 2;\n        const colDim = isChannelsLast ? 2 : 3;\n        const channelDim = isChannelsLast ? 3 : 1;\n        const workPerThread = isVec4 ? 2 : 1;\n        let declareFunctions = `\n  fn setOutputAtIndex(flatIndex : u32, value : ${isVec4 ? `vec4<${dataType}>` : dataType}) {\n    result[flatIndex] = ${isVec4 ? `vec4<${dataType}>` : dataType}(value);\n  }`;\n        if (hasBias) {\n          declareFunctions += `\n    fn getBiasByOutputCoords(coords : vec4<u32>) -> ${isVec4 ? `vec4<${dataType}>` : dataType} {\n      return bias[coords.${isChannelsLast ? \"w\" : \"y\"}${isVec4 ? \"/ 4\" : \"\"}];\n    }`;\n        }\n        const components = isVec4 ? 4 : 1;\n        const w = inputVariable(\"W\", inputs[1].dataType, inputs[1].dims.length, components);\n        const dy = inputVariable(\"Dy\", inputs[0].dataType, inputs[0].dims.length, components);\n        const inputVariables = [dy, w];\n        if (hasBias) {\n          inputVariables.push(inputVariable(\"bias\", inputs[2].dataType, [outputShape[channelDim]].length, components));\n        }\n        const output = outputVariable(\"result\", inputs[0].dataType, outputShape.length, components);\n        const codeSnippet4 = `{\n        let batch: u32 = ${is1DimensionDispatch ? \"global_id.z\" : \"workgroup_id.z\"} / uniforms.result_shape[1];\n        let r = ${is1DimensionDispatch ? \"global_id.z\" : \"workgroup_id.z\"} % uniforms.result_shape[1];\n        let c = ${is1DimensionDispatch ? \"global_id.y\" : \"workgroup_id.y\"} * ${workPerThread};\n        let d1: u32 = ${is1DimensionDispatch ? \"global_id.x\" : \"workgroup_id.x\"} * 4;\n\n        let dyCorner = vec2<i32>(i32(r), i32(c)) - vec2<i32>(uniforms.pads);\n\n        // Convolve dy(?, ?, d2) with w(:, :, d1, d2) to compute dx(xR, xC, d1).\n        // ? = to be determined. : = across all values in that axis.\n        var dotProd: array<vec4<${dataType}>, ${workPerThread}>;\n        for (var i = 0; i < ${workPerThread}; i++) {\n          dotProd[i] = vec4<${dataType}>(0.0);\n        }\n        for (var wR: u32 = 0; wR < uniforms.filter_dims[0]; wR = wR + 1) {\n          var dyR = (${dataType}(dyCorner.x) + ${dataType}(wR)) / ${dataType}(uniforms.strides.x);\n          let wRPerm = uniforms.filter_dims[0] - 1 - wR;\n          if (dyR < 0.0 || dyR >= ${dataType}(uniforms.Dy_shape[1]) ||\n              fract(dyR) > 0.0 || wRPerm < 0) {\n            continue;\n          }\n          let idyR: u32 = u32(dyR);\n\n          for (var wC: u32 = 0; wC < uniforms.filter_dims[1]; wC = wC + 1) {\n            let dyC = (${dataType}(dyCorner.y) + ${dataType}(wC)) / ${dataType}(uniforms.strides.y);\n            let dyC2 = (${dataType}(dyCorner.y) + 1.0 + ${dataType}(wC)) / ${dataType}(uniforms.strides.y);\n            let wCPerm = uniforms.filter_dims[1] - 1 - wC;\n            if (wCPerm < 0) {\n              continue;\n            }\n            var bDyCVal = true;\n            var bDyCVal2 = true;\n            if (dyC < 0.0 || dyC >= ${dataType}(uniforms.Dy_shape[2]) ||\n                fract(dyC) > 0.0) {\n              bDyCVal = false;\n            }\n            if (dyC2 < 0.0 || dyC2 >= ${dataType}(uniforms.Dy_shape[2]) ||\n                fract(dyC2) > 0.0) {\n              bDyCVal2 = false;\n            }\n\n            let idyC: u32 = u32(dyC);\n            let idyC2: u32 = u32(dyC2);\n            if (bDyCVal && bDyCVal2) {\n              let d2Length = uniforms.Dy_shape[3];\n              for (var d2 :u32 = 0; d2 < d2Length; d2 = d2 + 4) {\n                let wValue0 = ${w.get(\"u32(wRPerm)\", \"u32(wCPerm)\", \"d1\", \"d2\")};\n                let wValue1 = ${w.get(\"u32(wRPerm)\", \"u32(wCPerm)\", \"d1 + 1\", \"d2\")};\n                let wValue2 = ${w.get(\"u32(wRPerm)\", \"u32(wCPerm)\", \"d1 + 2\", \"d2\")};\n                let wValue3 = ${w.get(\"u32(wRPerm)\", \"u32(wCPerm)\", \"d1 + 3\", \"d2\")};\n\n                var xValue = ${dy.get(\"batch\", \"idyR\", \"idyC\", \"d2\")};\n                let tmpval = vec4<${dataType}>(dot(xValue, wValue0),\n                                      dot(xValue, wValue1),\n                                      dot(xValue, wValue2),\n                                      dot(xValue, wValue3));\n                dotProd[0] = dotProd[0] + tmpval;\n\n                xValue =  ${dy.get(\"batch\", \"idyR\", \"idyC2\", \"d2\")};\n\n                dotProd[1] = dotProd[1] + vec4<${dataType}>(dot(xValue, wValue0),\n                                                    dot(xValue, wValue1),\n                                                    dot(xValue, wValue2),\n                                                    dot(xValue, wValue3));\n              }\n            } else if (bDyCVal) {\n              let d2Length = uniforms.Dy_shape[${channelDim}];\n              for (var d2: u32 = 0; d2 < d2Length; d2 = d2 + 4) {\n                let wValue0 = ${w.get(\"u32(wRPerm)\", \"u32(wCPerm)\", \"d1\", \"d2\")};\n                let wValue1 = ${w.get(\"u32(wRPerm)\", \"u32(wCPerm)\", \"d1 + 1\", \"d2\")};\n                let wValue2 = ${w.get(\"u32(wRPerm)\", \"u32(wCPerm)\", \"d1 + 2\", \"d2\")};\n                let wValue3 = ${w.get(\"u32(wRPerm)\", \"u32(wCPerm)\", \"d1 + 3\", \"d2\")};\n\n                var xValue = ${dy.get(\"batch\", \"idyR\", \"idyC\", \"d2\")};\n                let tmpval = vec4<${dataType}>(dot(xValue, wValue0),\n                                      dot(xValue, wValue1),\n                                      dot(xValue, wValue2),\n                                      dot(xValue, wValue3));\n                dotProd[0] = dotProd[0] + tmpval;\n              }\n            } else if (bDyCVal2) {\n              let d2Length = uniforms.Dy_shape[3];\n              for (var d2: u32 = 0; d2 < d2Length; d2 = d2 + 4) {\n                let wValue0 = ${w.get(\"u32(wRPerm)\", \"u32(wCPerm)\", \"d1\", \"d2\")};\n                let wValue1 = ${w.get(\"u32(wRPerm)\", \"u32(wCPerm)\", \"d1 + 1\", \"d2\")};\n                let wValue2 = ${w.get(\"u32(wRPerm)\", \"u32(wCPerm)\", \"d1 + 2\", \"d2\")};\n                let wValue3 = ${w.get(\"u32(wRPerm)\", \"u32(wCPerm)\", \"d1 + 3\", \"d2\")};\n\n                var xValue = ${dy.get(\"batch\", \"idyR\", \"idyC2\", \"d2\")};\n                let tmpval = vec4<${dataType}>(dot(xValue, wValue0),\n                                      dot(xValue, wValue1),\n                                      dot(xValue, wValue2),\n                                      dot(xValue, wValue3));\n                dotProd[1] = dotProd[1] + tmpval;\n              }\n            }\n          }\n        }\n\n        for (var i: u32 = 0; i < ${workPerThread}; i = i + 1) {\n          let value = dotProd[i] + ${hasBias ? \"bias[c+i]\" : `vec4<${dataType}>(0.0)`};\n          ${output.set(\"batch\", \"r\", \"c + i\", \"d1\", \"value\")};\n        }\n      }`;\n        const codeSnippet = `\n          let outputIndices = ${output.offsetToIndices(\"global_idx\")};\n          let batch = ${output.indicesGet(\"outputIndices\", 0)};\n          let d1 = ${output.indicesGet(\"outputIndices\", channelDim)};\n          let r = ${output.indicesGet(\"outputIndices\", rowDim)};\n          let c = ${output.indicesGet(\"outputIndices\", colDim)};\n          let dyCorner = vec2<i32>(i32(r), i32(c)) - uniforms.pads;\n          let dyRCorner = dyCorner.x;\n          let dyCCorner = dyCorner.y;\n          let groupId = d1 / uniforms.output_channels_per_group;\n          let wOutChannel = d1 - groupId * uniforms.output_channels_per_group;\n          // Convolve dy(?, ?, d2) with w(:, :, d1, d2) to compute dx(xR, xC, d1).\n          // ? = to be determined. : = across all values in that axis.\n          var dotProd = ${dataType}(0.0);\n          for (var wR: u32 = 0; wR < uniforms.effective_filter_dims.x; wR = wR + 1) {\n            if (wR % uniforms.dilations.x != 0) {\n              continue;\n            }\n            let dyR = (${dataType}(dyRCorner) + ${dataType}(wR)) / ${dataType}(uniforms.strides[0]);\n            let wRPerm = uniforms.filter_dims.x - 1 - wR / uniforms.dilations.x;\n            if (dyR < 0.0 || dyR >= ${dataType}(uniforms.Dy_shape[${rowDim}]) || fract(dyR) > 0.0 ||\n                wRPerm < 0) {\n              continue;\n            }\n            let idyR: u32 = u32(dyR);\n\n            for (var wC: u32 = 0; wC < uniforms.effective_filter_dims.y; wC = wC + 1) {\n              if (wC % uniforms.dilations.y != 0) {\n                continue;\n              }\n              let dyC = (${dataType}(dyCCorner) + ${dataType}(wC)) / ${dataType}(uniforms.strides.y);\n              let wCPerm = uniforms.filter_dims.y - 1 - wC / uniforms.dilations.y;\n              if (dyC < 0.0 || dyC >= ${dataType}(uniforms.Dy_shape[${colDim}]) ||\n                  fract(dyC) > 0.0 || wCPerm < 0) {\n                continue;\n              }\n              let idyC: u32 = u32(dyC);\n              var inputChannel = groupId * uniforms.input_channels_per_group;\n              for (var d2: u32 = 0; d2 < uniforms.input_channels_per_group; d2 = d2 + 1) {\n                let xValue = ${isChannelsLast ? dy.get(\"batch\", \"idyR\", \"idyC\", \"inputChannel\") : dy.get(\"batch\", \"inputChannel\", \"idyR\", \"idyC\")};\n                let wValue = ${w.get(\"inputChannel\", \"wOutChannel\", \"u32(wRPerm)\", \"u32(wCPerm)\")};\n                dotProd = dotProd + xValue * wValue;\n                inputChannel = inputChannel + 1;\n              }\n            }\n          }\n          let value = dotProd + ${hasBias ? \"bias[d1]\" : `${dataType}(0.0)`};\n          ${output.setByOffset(\"global_idx\", \"value\")};\n        `;\n        return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n  ${declareFunctions}\n\n    ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.output_size\")};\n  ${isVec4 ? codeSnippet4 : codeSnippet}}`;\n      };\n      createConvTranspose2DProgramInfo = (inputs, attributes, squeezeOutputShapeFunction) => {\n        const hasBias = inputs.length > 2;\n        const outputShape = attributes.outputShape;\n        const outputSize = ShapeUtil.size(outputShape);\n        const dispatch = [\n          Math.ceil(outputSize / 64),\n          1,\n          1\n        ];\n        LOG_DEBUG(\"verbose\", () => `[conv2d_backprop_webgpu] dispatch = ${dispatch}`);\n        const isChannelsLast = attributes.format === \"NHWC\";\n        const inputDependencies = [\"rank\", \"rank\"];\n        const strides = [attributes.strides[0], attributes.strides[1]];\n        const filterDims = [attributes.kernelShape[isChannelsLast ? 1 : 2], attributes.kernelShape[isChannelsLast ? 2 : 3]];\n        const dilations = [attributes.dilations[0], attributes.dilations[1]];\n        const effectiveFilterDims = [\n          filterDims[0] + (attributes.dilations[0] <= 1 ? 0 : (attributes.kernelShape[isChannelsLast ? 1 : 2] - 1) * (attributes.dilations[0] - 1)),\n          filterDims[1] + (attributes.dilations[1] <= 1 ? 0 : (attributes.kernelShape[isChannelsLast ? 2 : 3] - 1) * (attributes.dilations[1] - 1))\n        ];\n        const pads = [\n          effectiveFilterDims[0] - 1 - Math.floor((attributes.pads[0] + attributes.pads[2]) / 2),\n          effectiveFilterDims[1] - 1 - Math.floor(attributes.pads[1] + attributes.pads[3]) / 2\n        ];\n        const isVec4 = false;\n        const group = attributes.group;\n        const wShape = inputs[1].dims;\n        const inputChannelsPerGroup = wShape[0] / group;\n        const outputChannelsPerGroup = wShape[1];\n        const programUniforms = [\n          { type: 12 /* uint32 */, data: outputSize },\n          { type: 12 /* uint32 */, data: strides },\n          { type: 12 /* uint32 */, data: filterDims },\n          { type: 12 /* uint32 */, data: dilations },\n          { type: 12 /* uint32 */, data: effectiveFilterDims },\n          { type: 6 /* int32 */, data: pads },\n          { type: 12 /* uint32 */, data: inputChannelsPerGroup },\n          { type: 12 /* uint32 */, data: outputChannelsPerGroup },\n          ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims)\n        ];\n        if (hasBias) {\n          programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n          inputDependencies.push(\"rank\");\n        }\n        programUniforms.push(...createTensorShapeVariables(outputShape));\n        const is1DimensionDispatch = dispatch[1] === 1 && dispatch[2] === 1;\n        const getShaderSource = (shaderHelper) => {\n          const uniforms = [\n            { name: \"output_size\", type: \"u32\" },\n            { name: \"strides\", type: \"u32\", length: strides.length },\n            { name: \"filter_dims\", type: \"u32\", length: filterDims.length },\n            { name: \"dilations\", type: \"u32\", length: filterDims.length },\n            { name: \"effective_filter_dims\", type: \"u32\", length: effectiveFilterDims.length },\n            { name: \"pads\", type: \"i32\", length: pads.length },\n            { name: \"input_channels_per_group\", type: \"u32\" },\n            { name: \"output_channels_per_group\", type: \"u32\" }\n          ];\n          const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n          return `${createConvTranspose2DOpProgramShaderSource(\n            shaderHelper,\n            inputs,\n            outputShape,\n            hasBias,\n            is1DimensionDispatch,\n            isVec4,\n            dataType,\n            uniforms,\n            isChannelsLast\n          )}`;\n        };\n        return {\n          name: \"ConvTranspose2D\",\n          shaderCache: { hint: `${attributes.cacheKey};`, inputDependencies },\n          getRunData: () => ({\n            dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] },\n            outputs: [{\n              dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,\n              dataType: inputs[0].dataType\n            }],\n            programUniforms\n          }),\n          getShaderSource\n        };\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/conv-transpose.ts\n  var computeTotalPad, distributePadding, calculateOutputShapeAndPads, getAdjustedConvTransposeAttributes, parseConvTransposeAttributes, validateInputs10, weightTransposePerm, convTranspose2d, convTranspose1d, convTranspose;\n  var init_conv_transpose = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/conv-transpose.ts\"() {\n      \"use strict\";\n      init_conv_backprop_mm_webgpu();\n      init_conv_backprop_webgpu();\n      init_fuse_utils();\n      init_transpose();\n      computeTotalPad = (inDim, stride, adj, kernel, dilation, outSize) => (inDim - 1) * stride + adj + (kernel - 1) * dilation + 1 - outSize;\n      distributePadding = (totalPad, autoPad, pads, head, tail) => {\n        const smallPad = Math.floor(totalPad / 2);\n        if (autoPad === \"SAME_UPPER\") {\n          pads[head] = smallPad;\n          pads[tail] = totalPad - smallPad;\n        } else if (autoPad === \"SAME_LOWER\") {\n          pads[head] = totalPad - smallPad;\n          pads[tail] = smallPad;\n        }\n      };\n      calculateOutputShapeAndPads = (inputShape, kernelShape, dilations, autoPad, group, pads, strides, isChannelLast, outputPadding, outputShape) => {\n        const spatialRank = inputShape.length - 2;\n        const updateOutputShape = outputShape.length === 0;\n        if (outputPadding.length === 0) {\n          for (let i = 0; i < spatialRank; ++i) {\n            outputPadding.push(0);\n          }\n        }\n        const batchSize = inputShape[0];\n        const outChannels = kernelShape[isChannelLast ? 3 : 1] * group;\n        for (let i = 0, j = inputShape.length - spatialRank - (isChannelLast ? 1 : 0); i < spatialRank; ++i, ++j) {\n          const inSize = inputShape[j];\n          const outSize = updateOutputShape ? inSize * strides[i] : outputShape[i];\n          const totalPad = computeTotalPad(inSize, strides[i], pads[i], kernelShape[j], dilations[i], outSize);\n          distributePadding(totalPad, autoPad, pads, i, i + spatialRank);\n          if (updateOutputShape) {\n            outputShape.push(\n              strides[i] * (inSize - 1) + outputPadding[i] + (kernelShape[j] - 1) * dilations[i] + 1 - pads[i] - pads[i + spatialRank]\n            );\n          }\n        }\n        outputShape.splice(0, 0, batchSize);\n        outputShape.splice(isChannelLast ? 3 : 1, 0, outChannels);\n      };\n      getAdjustedConvTransposeAttributes = (attributes, inputs) => {\n        const kernelShape = attributes.kernelShape.slice();\n        if (attributes.kernelShape.length === 0 || attributes.kernelShape.reduce((a, b) => a * b, 1) === 0) {\n          kernelShape.length = 0;\n          for (let i = 2; i < inputs[1].dims.length; ++i) {\n            kernelShape.push(inputs[1].dims[i]);\n          }\n        }\n        const isChannelsLast = attributes.format === \"NHWC\";\n        kernelShape.splice(0, 0, inputs[1].dims[0]);\n        kernelShape.splice(isChannelsLast ? 3 : 1, 0, inputs[1].dims[1]);\n        const pads = attributes.pads.slice();\n        const outputShape = attributes.outputShape.slice();\n        const outputPadding = attributes.outputPadding.slice();\n        const inputShape = inputs[0].dims;\n        let dilations = attributes.dilations.slice();\n        if (dilations.reduce((a, b) => a + b, 0) === 0) {\n          const spatialRank = inputs[0].dims.length - 2;\n          dilations = new Array(spatialRank).fill(1);\n        }\n        let strides = attributes.strides.slice();\n        if (strides.reduce((a, b) => a + b, 0) === 0) {\n          const spatialRank = inputs[0].dims.length - 2;\n          strides = new Array(spatialRank).fill(1);\n        }\n        calculateOutputShapeAndPads(\n          inputShape,\n          kernelShape,\n          dilations,\n          attributes.autoPad,\n          attributes.group,\n          pads,\n          strides,\n          isChannelsLast,\n          outputPadding,\n          outputShape\n        );\n        const newAttributes = Object.assign({}, attributes);\n        Object.assign(newAttributes, { kernelShape, pads, outputPadding, outputShape, dilations, strides });\n        return newAttributes;\n      };\n      parseConvTransposeAttributes = (attributes) => {\n        const activationAttributes = parseInternalActivationAttributes(attributes);\n        const format = attributes.format;\n        const autoPad = [\n          \"NOTSET\",\n          \"VALID\",\n          \"SAME_UPPER\",\n          \"SAME_LOWER\"\n        ][typeof attributes.autoPad == \"undefined\" ? 0 : attributes.autoPad];\n        const dilations = attributes.dilations;\n        const group = attributes.group;\n        const kernelShape = attributes.kernelShape;\n        const pads = attributes.pads;\n        const strides = attributes.strides;\n        const wIsConst = attributes.wIsConst();\n        const outputPadding = attributes.outputPadding;\n        const outputShape = attributes.outputShape;\n        return {\n          autoPad,\n          format,\n          dilations,\n          group,\n          kernelShape,\n          outputPadding,\n          outputShape,\n          pads,\n          strides,\n          wIsConst,\n          ...activationAttributes,\n          cacheKey: `${attributes.format};${activationAttributes.activation};`\n        };\n      };\n      validateInputs10 = (inputs, attributes) => {\n        if (!inputs || inputs.length !== 2 && inputs.length !== 3) {\n          throw new Error(\"Conv requires 2 or 3 inputs\");\n        }\n        if (inputs[0].dims.length !== 4 && inputs[0].dims.length !== 3) {\n          throw new Error(\"currently only support 2-dimensional conv\");\n        }\n        if (inputs[0].dims.length !== inputs[1].dims.length) {\n          throw new Error(\"filter does not have same dimension as input\");\n        }\n        const dataChannel = inputs[0].dims[attributes.format === \"NHWC\" ? inputs[0].dims.length - 1 : 1];\n        const filterInChannel = inputs[1].dims[0];\n        if (dataChannel !== filterInChannel) {\n          throw new Error(\"FILTER_IN_CHANNEL should be equal to DATA_CHANNEL\");\n        }\n        const featureMaps = inputs[1].dims[1] * attributes.group;\n        if (inputs.length === 3 && (inputs[2].dims.length !== 1 || inputs[2].dims[0] !== featureMaps)) {\n          throw new Error(\"invalid bias\");\n        }\n        const spatialRank = inputs[0].dims.length - 2;\n        const dilationsSet = attributes.dilations.reduce((a, b) => a + b, 0) > 0;\n        if (dilationsSet && attributes.dilations.length !== spatialRank) {\n          throw new Error(`dilations should be ${spatialRank}D`);\n        }\n        const stridesSet = attributes.strides.reduce((a, b) => a + b, 0) > 0;\n        if (stridesSet && attributes.strides.length !== spatialRank) {\n          throw new Error(`strides should be ${spatialRank}D`);\n        }\n        const padsSet = attributes.pads.reduce((a, b) => a + b, 0) > 0;\n        if (padsSet && attributes.pads.length !== spatialRank * 2) {\n          throw new Error(`pads should be ${spatialRank * 2}D`);\n        }\n        if (attributes.outputPadding.length !== spatialRank && attributes.outputPadding.length !== 0) {\n          throw new Error(`output_padding should be ${spatialRank}D`);\n        }\n        const kernelShapeSet = attributes.kernelShape.reduce((a, b) => a + b, 0) > 0;\n        if (kernelShapeSet && attributes.kernelShape.length !== 0 && attributes.kernelShape.length !== inputs[1].dims.length - 2) {\n          throw new Error(\"invalid kernel shape\");\n        }\n        if (attributes.outputShape.length !== 0 && attributes.outputShape.length !== inputs[0].dims.length - 2) {\n          throw new Error(\"invalid output shape\");\n        }\n      };\n      weightTransposePerm = [2, 3, 1, 0];\n      convTranspose2d = (context, inputs, attributes) => {\n        const adjustedAttributes = getAdjustedConvTransposeAttributes(attributes, inputs);\n        const isChannelsLast = attributes.format === \"NHWC\";\n        const outputShape = adjustedAttributes.outputShape;\n        const outChannels = outputShape[isChannelsLast ? 3 : 1];\n        const inputChannels = inputs[0].dims[isChannelsLast ? 3 : 1];\n        if (adjustedAttributes.group !== 1 || outChannels === 1 && inputChannels === 1) {\n          context.compute(createConvTranspose2DProgramInfo(inputs, adjustedAttributes));\n          return;\n        }\n        const outHeight = outputShape[isChannelsLast ? 1 : 2];\n        const outWidth = outputShape[isChannelsLast ? 2 : 3];\n        const weightHeight = inputs[1].dims[2];\n        const weightWidth = inputs[1].dims[3];\n        const dimAOuter = isChannelsLast ? outHeight * outWidth : outChannels;\n        const dimBOuter = isChannelsLast ? outChannels : outHeight * outWidth;\n        const dimInner = weightHeight * weightWidth * inputChannels;\n        const sequentialAccessByThreads = (\n          /* backend.adapterInfo.isIntel() */\n          true\n        );\n        const transposedWeight = context.kernelCustomData.wT ?? context.compute(\n          createTransposeProgramInfo(inputs[1], weightTransposePerm),\n          { inputs: [1], outputs: [attributes.wIsConst ? -2 : -1] }\n        )[0];\n        if (attributes.wIsConst && !context.kernelCustomData.wT) {\n          context.kernelCustomData.wT = transposedWeight;\n        }\n        const convTransposeInputs = [inputs[0], transposedWeight];\n        const hasBias = inputs.length === 3;\n        if (hasBias) {\n          if (!isChannelsLast && inputs[2].dims.length === 1) {\n            convTransposeInputs.push(inputs[2].reshape([inputs[2].dims[0], 1, 1]));\n          } else {\n            convTransposeInputs.push(inputs[2]);\n          }\n        }\n        context.compute(\n          createConv2DTransposeMatMulProgramInfo(\n            convTransposeInputs,\n            adjustedAttributes,\n            outputShape,\n            dimAOuter,\n            dimBOuter,\n            dimInner,\n            hasBias,\n            sequentialAccessByThreads\n          ),\n          { inputs: convTransposeInputs }\n        );\n      };\n      convTranspose1d = (context, attributes) => {\n        const isChannelLast = attributes.format === \"NHWC\";\n        const inputs = [\n          context.inputs[0].reshape(\n            isChannelLast ? (\n              // [N, W, C] -> [N, H=1, W, C]\n              [context.inputs[0].dims[0], 1, context.inputs[0].dims[1], context.inputs[0].dims[2]]\n            ) : (\n              // [N, C, W] -> [N, C, H=1, W]\n              [context.inputs[0].dims[0], context.inputs[0].dims[1], 1, context.inputs[0].dims[2]]\n            )\n          ),\n          //[FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kW] -> [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kH=1, kW]\n          context.inputs[1].reshape([context.inputs[1].dims[0], context.inputs[1].dims[1], 1, context.inputs[1].dims[2]])\n        ];\n        if (context.inputs.length === 3) {\n          inputs.push(context.inputs[2]);\n        }\n        let kernelShape = attributes.kernelShape;\n        if (kernelShape.length === 0 || kernelShape[0] === 0) {\n          kernelShape = [context.inputs[1].dims[2]];\n        }\n        let dilations = attributes.dilations;\n        if (dilations.length === 0 || dilations[0] === 0) {\n          dilations = [1];\n        }\n        let strides = attributes.strides;\n        if (strides.length === 0 || strides[0] === 0) {\n          strides = [1];\n        }\n        let pads = attributes.pads;\n        if (pads.length === 0) {\n          pads = [0, 0];\n        }\n        pads = [0, pads[0], 0, pads[1]];\n        strides = [1].concat(strides);\n        dilations = [1].concat(dilations);\n        kernelShape = [1].concat(kernelShape);\n        const adjustedAttributes = getAdjustedConvTransposeAttributes({ ...attributes, pads, strides, dilations, kernelShape }, inputs);\n        context.compute(createConvTranspose2DProgramInfo(\n          inputs,\n          adjustedAttributes,\n          (outputShape) => isChannelLast ? [outputShape[0], outputShape[2], outputShape[3]] : [outputShape[0], outputShape[1], outputShape[3]]\n        ));\n      };\n      convTranspose = (context, attributes) => {\n        validateInputs10(context.inputs, attributes);\n        if (context.inputs[0].dims.length === 3) {\n          convTranspose1d(context, attributes);\n        } else {\n          convTranspose2d(context, context.inputs, attributes);\n        }\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/cumsum.ts\n  var createCumsumProgramInfo, cumsum, parseCumSumAttributes;\n  var init_cumsum = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/cumsum.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_attribute_with_cache_key();\n      init_common();\n      createCumsumProgramInfo = (inputType, inputShape, axisInput, attributes) => {\n        const outputSize = ShapeUtil.size(inputShape);\n        const rank = inputShape.length;\n        const input = inputVariable(\"input\", inputType, rank);\n        const output = outputVariable(\"output\", inputType, rank);\n        const axisValue = axisInput.dataType === 6 /* int32 */ ? axisInput.getInt32Array()[0] : Number(axisInput.getBigInt64Array()[0]);\n        const axis = ShapeUtil.normalizeAxis(axisValue, rank);\n        const getShaderSource = (shaderHelper) => {\n          const index = ` i32(${input.indicesGet(\"inputIndices\", \"uniforms.axis\")}) `;\n          const max = getElementAt(\"uniforms.input_shape\", \"uniforms.axis\", rank);\n          const lowerLimit = attributes.reverse ? index + (attributes.exclusive ? \" + 1\" : \"\") : \"0\";\n          const upperLimit = attributes.reverse ? max : index + (attributes.exclusive ? \"\" : \" + 1\");\n          return `\n                ${shaderHelper.registerUniform(\"outputSize\", \"u32\").registerUniform(\"axis\", \"u32\").declareVariables(input, output)}\n                ${shaderHelper.mainStart()}\n                  ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.outputSize\")}\n                  var inputIndices = ${output.offsetToIndices(\"global_idx\")};\n                  var sum = ${output.type.value}(0);\n                  let first : i32 = ${lowerLimit};\n                  let last : i32 = ${upperLimit};\n                  for (var i : i32 = first; i < last; i++) {\n                    ${input.indicesSet(\"inputIndices\", \"uniforms.axis\", \"u32(i)\")};\n                    sum = sum + ${input.getByIndices(\"inputIndices\")};\n                  }\n                  ${output.setByOffset(\"global_idx\", \"sum\")};\n                }`;\n        };\n        return {\n          name: \"CumSum\",\n          shaderCache: { hint: attributes.cacheKey, inputDependencies: [\"rank\"] },\n          getRunData: () => ({\n            outputs: [{ dims: inputShape, dataType: inputType }],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64\n              /* workgroup size */\n            ) },\n            programUniforms: [\n              { type: 12 /* uint32 */, data: outputSize },\n              { type: 12 /* uint32 */, data: axis },\n              ...createTensorShapeVariables(inputShape, inputShape)\n            ]\n          }),\n          getShaderSource\n        };\n      };\n      cumsum = (context, attributes) => {\n        const inputShape = context.inputs[0].dims;\n        const inputType = context.inputs[0].dataType;\n        const axis = context.inputs[1];\n        context.compute(createCumsumProgramInfo(inputType, inputShape, axis, attributes), { inputs: [0] });\n      };\n      parseCumSumAttributes = (attributes) => {\n        const exclusive = attributes.exclusive === 1;\n        const reverse = attributes.reverse === 1;\n        return createAttributeWithCacheKey({ exclusive, reverse });\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/depth-to-space.ts\n  var validateInputs11, permFunctionBody2, createDepthToSpaceProgramInfo, depthToSpace, parseDepthToSpaceAttributes;\n  var init_depth_to_space = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/depth-to-space.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_attribute_with_cache_key();\n      init_common();\n      validateInputs11 = (inputs) => {\n        if (!inputs || inputs.length !== 1) {\n          throw new Error(\"DepthToSpace requires 1 input.\");\n        }\n        if (inputs[0].dims.length !== 4) {\n          throw new Error(\"DepthToSpace requires 4D input.\");\n        }\n      };\n      permFunctionBody2 = (perm, rank, input, output) => {\n        const reverseFunc = [];\n        reverseFunc.push(`fn perm(i: ${output.type.indices}) -> ${input.type.indices} {\n    var a: ${input.type.indices};`);\n        for (let i = 0; i < rank; ++i) {\n          reverseFunc.push(input.indicesSet(\"a\", perm[i], `i[${i}]`));\n        }\n        reverseFunc.push(\"return a;}\");\n        return reverseFunc.join(\"\\n\");\n      };\n      createDepthToSpaceProgramInfo = (inputTensor, attributes) => {\n        let n, h, w, c;\n        let shape;\n        let perm;\n        const isChannelLast = attributes.format === \"NHWC\";\n        const blocksize = attributes.blocksize;\n        const isDCRmode = attributes.mode === \"DCR\";\n        if (isChannelLast) {\n          [n, h, w, c] = inputTensor.dims;\n          shape = isDCRmode ? [n, h, w, blocksize, blocksize, c / blocksize ** 2] : [n, h, w, c / blocksize ** 2, blocksize, blocksize];\n          perm = isDCRmode ? [0, 1, 3, 2, 4, 5] : [0, 1, 4, 2, 5, 3];\n        } else {\n          [n, h, w, c] = [inputTensor.dims[0], inputTensor.dims[2], inputTensor.dims[3], inputTensor.dims[1]];\n          shape = isDCRmode ? [n, blocksize, blocksize, c / blocksize ** 2, h, w] : [n, c / blocksize ** 2, blocksize, blocksize, h, w];\n          perm = isDCRmode ? [0, 3, 4, 1, 5, 2] : [0, 1, 4, 2, 5, 3];\n        }\n        const reshapedInputTensor = inputTensor.reshape(shape);\n        const reshapedInputRank = reshapedInputTensor.dims.length;\n        const inputDataType = inputTensor.dataType;\n        const reshapedInput = inputVariable(\"a\", inputDataType, reshapedInputRank);\n        const permedOutput = outputVariable(\"output\", inputDataType, reshapedInputRank);\n        const getShaderSource = (shaderHelper) => `\n  ${shaderHelper.registerUniform(\"output_size\", \"u32\").declareVariables(reshapedInput, permedOutput)}\n\n  ${permFunctionBody2(perm, reshapedInputRank, reshapedInput, permedOutput)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.output_size\")}\n\n    let indices = ${permedOutput.offsetToIndices(\"global_idx\")};\n    let aIndices = perm(indices);\n\n    ${permedOutput.setByOffset(\"global_idx\", reshapedInput.getByIndices(\"aIndices\"))}\n  }`;\n        return {\n          name: \"DepthToSpace\",\n          shaderCache: { hint: `${inputTensor.dims};${attributes.blocksize};${attributes.mode}`, inputDependencies: [\"rank\"] },\n          getRunData: (inputs) => {\n            const outputShape = isChannelLast ? [n, h * blocksize, w * blocksize, c / blocksize ** 2] : [n, c / blocksize ** 2, h * blocksize, w * blocksize];\n            const outputSize = ShapeUtil.size(outputShape);\n            const shapeBeforePerm = reshapedInputTensor.dims;\n            const shapeAfterPerm = ShapeUtil.sortBasedOnPerm(shapeBeforePerm, perm);\n            return {\n              outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n              dispatchGroup: { x: Math.ceil(\n                outputSize / 64\n                /* workgroup size */\n              ) },\n              programUniforms: [{ type: 12 /* uint32 */, data: outputSize }, ...createTensorShapeVariables(shapeBeforePerm, shapeAfterPerm)]\n            };\n          },\n          getShaderSource\n        };\n      };\n      depthToSpace = (context, attributes) => {\n        validateInputs11(context.inputs);\n        context.compute(createDepthToSpaceProgramInfo(context.inputs[0], attributes));\n      };\n      parseDepthToSpaceAttributes = (attributes) => createAttributeWithCacheKey({\n        blocksize: attributes.blocksize,\n        mode: attributes.mode,\n        format: attributes.format\n      });\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/einsum.ts\n  var symbolPattern, termPattern, termPatternOnly, lhsPattern, lhsPatternOnly, EinsumTerm, EinsumEquation, appendMax, createEinsumProgramInfo, einsum, parseEinsumAttributes;\n  var init_einsum = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/einsum.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_attribute_with_cache_key();\n      init_common();\n      symbolPattern = \"[a-zA-Z]|\\\\.\\\\.\\\\.\";\n      termPattern = \"(\" + symbolPattern + \")+\";\n      termPatternOnly = \"^\" + termPattern + \"$\";\n      lhsPattern = \"(\" + termPattern + \",)*\" + termPattern;\n      lhsPatternOnly = \"^\" + lhsPattern + \"$\";\n      EinsumTerm = class {\n        constructor(inputIndex = -1) {\n          this.symbolToIndices = /* @__PURE__ */ new Map();\n          this.inputIndex = inputIndex;\n        }\n        // Add a symbol to the term\n        addSymbol(symbol, index) {\n          let value = this.symbolToIndices.get(symbol);\n          if (value === void 0) {\n            value = [index];\n          } else {\n            value.push(index);\n          }\n          this.symbolToIndices.set(symbol, value);\n        }\n        // -1 for output and 0, 1, 2, ... for inputs\n      };\n      EinsumEquation = class {\n        constructor(inputs, equation) {\n          this.equation = equation;\n          this.hasEllipsis = false;\n          this.symbolToInfo = /* @__PURE__ */ new Map();\n          this.lhs = new Array();\n          this.outputDims = [];\n          let [lhs, rhs] = equation.includes(\"->\") ? equation.split(\"->\", 2) : [equation, \"\"];\n          if (!lhs.match(RegExp(lhsPatternOnly))) {\n            throw new Error(\"Invalid LHS term\");\n          }\n          const inputTerms = lhs.split(\",\");\n          inputTerms.forEach((inputTerm, index) => {\n            const dims = inputs[index].dims.slice();\n            if (!inputTerm.match(RegExp(termPatternOnly))) {\n              throw new Error(\"Invalid LHS term\");\n            }\n            const einsumTerm = this.processTerm(inputTerm, true, dims, index);\n            this.lhs.push(einsumTerm);\n          });\n          if (rhs === \"\") {\n            rhs += [...this.symbolToInfo.entries()].filter(([sym, info]) => info.count === 1 || sym === \"...\").map(([sym]) => sym).join(\"\");\n          } else {\n            if (!rhs.match(RegExp(termPattern))) {\n              throw new Error(\"Invalid RHS\");\n            }\n          }\n          const rhsSymbols = rhs.match(RegExp(symbolPattern, \"g\"));\n          rhsSymbols?.forEach((symbol) => {\n            if (symbol === \"...\") {\n              this.outputDims = this.outputDims.concat(this.ellipsisDims);\n            } else {\n              const info = this.symbolToInfo.get(symbol);\n              if (info === void 0) {\n                throw new Error(\"Invalid RHS symbol\");\n              }\n              this.outputDims.push(info.dimValue);\n            }\n          });\n          this.rhs = this.processTerm(rhs, false, this.outputDims);\n        }\n        // End of EinsumEqation constructor\n        // Add a symbol to the equation\n        addSymbol(symbol, dimValue, inputIndex) {\n          let info = this.symbolToInfo.get(symbol);\n          if (info !== void 0) {\n            if (info.dimValue !== dimValue && info.count !== 1) {\n              throw new Error(\"Dimension mismatch\");\n            } else {\n              info.count++;\n              info.inputIndices.push(inputIndex);\n            }\n          } else {\n            info = { count: 1, dimValue, inputIndices: [inputIndex] };\n          }\n          this.symbolToInfo.set(symbol, info);\n        }\n        // Process one input/output term\n        processTerm(term, isInput, dims, index = -1) {\n          const rank = dims.length;\n          let ellipsis = false;\n          let ellipsisDims = [];\n          let nextDim = 0;\n          if (!term.match(RegExp(termPatternOnly)) && (!isInput && term !== \"\")) {\n            throw new Error(\"Invalid LHS term\");\n          }\n          const indexSymbols = term.match(RegExp(symbolPattern, \"g\"));\n          const einsumTerm = new EinsumTerm(index);\n          indexSymbols?.forEach((symbol, i) => {\n            if (symbol === \"...\") {\n              if (ellipsis) {\n                throw new Error(\"Only one ellipsis is allowed per input term\");\n              }\n              ellipsis = true;\n              const ellipsisDimLength = rank - indexSymbols.length + 1;\n              if (ellipsisDimLength < 0) {\n                throw new Error(\"Ellipsis out of bounds\");\n              }\n              ellipsisDims = dims.slice(nextDim, nextDim + ellipsisDimLength);\n              if (this.hasEllipsis) {\n                if (this.ellipsisDims.length !== ellipsisDims.length || this.ellipsisDims.toString() !== ellipsisDims.toString()) {\n                  throw new Error(\"Ellipsis dimensions mismatch\");\n                }\n              } else if (isInput) {\n                this.hasEllipsis = true;\n                this.ellipsisDims = ellipsisDims;\n              } else {\n                throw new Error(\"Ellipsis must be specified in the LHS\");\n              }\n              for (let j = 0; j < ellipsisDims.length; j++) {\n                const symbol2 = String.fromCharCode(\"0\".charCodeAt(0) + j);\n                einsumTerm.addSymbol(symbol2, i + j);\n                this.addSymbol(symbol2, dims[nextDim++], index);\n              }\n            } else {\n              einsumTerm.addSymbol(symbol, i + (this.hasEllipsis ? this.ellipsisDims.length - 1 : 0));\n              this.addSymbol(symbol, dims[nextDim++], index);\n            }\n          });\n          return einsumTerm;\n        }\n        // Output dimensions of the equation\n      };\n      appendMax = (name) => name + \"_max\";\n      createEinsumProgramInfo = (inputShapes, dataType, einsumEquation, outputShape) => {\n        const ranks = inputShapes.map((dims) => dims.length);\n        const inputVars = ranks.map((rank, index) => inputVariable(`input${index}`, dataType, rank));\n        const outputSize = ShapeUtil.size(outputShape);\n        const output = outputVariable(\"output\", dataType, outputShape.length);\n        const uniformsSymbols = [...einsumEquation.symbolToInfo.keys()].filter((symbol) => !einsumEquation.rhs.symbolToIndices.has(symbol));\n        const getShaderSource = (shaderHelper) => {\n          const idxCopy = [];\n          const initProd = \"var prod = 1.0;\";\n          const initSum = \"var sum = 0.0;\";\n          const updateSum = \"sum += prod;\";\n          const reduceOpsSetIndices = [];\n          const reduceOpsLoopHeaders = [];\n          const reduceOpsLoopFooters = [];\n          const reduceOpCompute = [];\n          const isReduceOpsWithoutLoop = einsumEquation.symbolToInfo.size === einsumEquation.rhs.symbolToIndices.size;\n          einsumEquation.symbolToInfo.forEach((info, symbol) => {\n            if (einsumEquation.rhs.symbolToIndices.has(symbol)) {\n              const outputIndex = einsumEquation.rhs.symbolToIndices.get(symbol)?.[0];\n              if (outputIndex !== void 0) {\n                einsumEquation.lhs.forEach((term, i) => {\n                  if (info.inputIndices.includes(i)) {\n                    const indices = term.symbolToIndices.get(symbol);\n                    if (indices === void 0) {\n                      throw new Error(\"Invalid symbol error\");\n                    }\n                    indices.forEach((index) => {\n                      idxCopy.push(`${inputVars[i].indicesSet(\n                        `input${i}Indices`,\n                        index,\n                        output.indicesGet(\"outputIndices\", outputIndex)\n                      )}`);\n                    });\n                  }\n                });\n              }\n            } else {\n              einsumEquation.lhs.forEach((term, i) => {\n                if (info.inputIndices.includes(i)) {\n                  const indices = term.symbolToIndices.get(symbol);\n                  if (indices === void 0) {\n                    throw new Error(\"Invalid symbol error\");\n                  }\n                  indices.forEach((index) => {\n                    reduceOpsSetIndices.push(`${inputVars[i].indicesSet(`input${i}Indices`, index, `${symbol}`)}`);\n                  });\n                  reduceOpCompute.push(`prod *= ${inputVars[i].getByIndices(`input${i}Indices`)};`);\n                }\n              });\n              reduceOpsLoopHeaders.push(\n                `for(var ${symbol}: u32 = 0; ${symbol} < uniforms.${appendMax(symbol)}; ${symbol}++) {`\n              );\n              reduceOpsLoopFooters.push(\"}\");\n            }\n          });\n          const reduceOps2 = isReduceOpsWithoutLoop ? [\n            ...idxCopy,\n            `let sum = ${inputVars.map((inputVar, i) => inputVar.getByIndices(`input${i}Indices`)).join(\" * \")};`\n          ] : [\n            ...idxCopy,\n            initSum,\n            ...reduceOpsLoopHeaders,\n            ...reduceOpsSetIndices,\n            initProd,\n            ...reduceOpCompute,\n            updateSum,\n            ...reduceOpsLoopFooters\n          ];\n          return `\n            ${shaderHelper.registerUniforms(uniformsSymbols.map((symbol) => ({ name: `${appendMax(symbol)}`, type: \"u32\" }))).registerUniform(\"outputSize\", \"u32\").declareVariables(...inputVars, output)}\n\n            ${shaderHelper.mainStart()}\n            ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.outputSize\")}\n            var outputIndices = ${output.offsetToIndices(\"global_idx\")};\n            ${inputVars.map((_var, i) => `var input${i}Indices: ${inputVars[i].type.indices};`).join(\"\\n\")}\n            ${reduceOps2.join(\"\\n\")};\n            ${output.setByOffset(\"global_idx\", \"sum\")};\n          }`;\n        };\n        return {\n          name: \"Einsum\",\n          shaderCache: { hint: einsumEquation.equation, inputDependencies: inputShapes.map(() => \"rank\") },\n          getRunData: () => {\n            const programUniformsInit = uniformsSymbols.filter((symbol) => einsumEquation.symbolToInfo.has(symbol)).map(\n              (symbol) => ({ type: 12 /* uint32 */, data: einsumEquation.symbolToInfo.get(symbol)?.dimValue || 0 })\n            );\n            programUniformsInit.push({ type: 12 /* uint32 */, data: outputSize });\n            const programUniforms = inputShapes.map((dims, _) => [...createTensorShapeVariables(dims)]).reduce((acc, inputProgramUniforms) => acc.concat(inputProgramUniforms), programUniformsInit);\n            programUniforms.push(...createTensorShapeVariables(outputShape));\n            return {\n              outputs: [{ dims: outputShape, dataType }],\n              dispatchGroup: { x: Math.ceil(\n                outputSize / 64\n                /* workgroup size */\n              ) },\n              programUniforms\n            };\n          },\n          getShaderSource\n        };\n      };\n      einsum = (context, attributes) => {\n        const einsumEquation = new EinsumEquation(context.inputs, attributes.equation);\n        const outputShape = einsumEquation.outputDims;\n        const inputShapes = context.inputs.map((input, _) => input.dims);\n        context.compute(createEinsumProgramInfo(inputShapes, context.inputs[0].dataType, einsumEquation, outputShape));\n      };\n      parseEinsumAttributes = (attributes) => {\n        const equation = attributes.equation.replace(/\\s+/g, \"\");\n        return createAttributeWithCacheKey({ equation });\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/expand.ts\n  var validateInputs12, getAdjustedShape, calculateOutputShape2, createExpandProgramInfo, expand;\n  var init_expand = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/expand.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_common();\n      validateInputs12 = (inputs) => {\n        if (!inputs || inputs.length !== 2) {\n          throw new Error(\"Expand requires 2 input.\");\n        }\n        const inputShape = inputs[0].dims;\n        const shape = Array.from(inputs[1].getBigInt64Array(), Number);\n        let shapeIndex = shape.length < inputShape.length ? 0 : shape.length - inputShape.length;\n        let inputShapeIndex = inputShape.length < shape.length ? 0 : inputShape.length - shape.length;\n        for (; shapeIndex < shape.length && inputShapeIndex < inputShape.length; ++shapeIndex, ++inputShapeIndex) {\n          if (shape[shapeIndex] !== inputShape[inputShapeIndex] && shape[shapeIndex] !== 1 && inputShape[inputShapeIndex] !== 1) {\n            throw new Error(\"Expand requires shape to be broadcastable to input\");\n          }\n        }\n      };\n      getAdjustedShape = (shape1, shape2) => {\n        const diff = shape1.length - shape2.length;\n        const shape = [];\n        for (let i = 0; i < diff; ++i) {\n          shape.push(shape1[i]);\n        }\n        for (let i = 0; i < shape2.length; ++i) {\n          shape.push(shape2[i] === 1 ? shape1[i + diff] : shape2[i]);\n        }\n        return shape;\n      };\n      calculateOutputShape2 = (inputShape, shape) => inputShape.length > shape.length ? getAdjustedShape(inputShape, shape) : getAdjustedShape(shape, inputShape);\n      createExpandProgramInfo = (inputs) => {\n        const inputShape = inputs[0].dims;\n        const shape = Array.from(inputs[1].getBigInt64Array(), Number);\n        const outputShape = calculateOutputShape2(inputShape, shape);\n        const dataType = inputs[0].dataType;\n        const components = dataType === 9 /* bool */ ? 4 : 1;\n        const outputSize = Math.ceil(ShapeUtil.size(outputShape) / components);\n        const getShaderSource = (shaderHelper) => {\n          const input = inputVariable(\"input\", dataType, inputShape.length, components);\n          const output = outputVariable(\"output\", dataType, outputShape.length, components);\n          let assignment;\n          if (dataType === 9 /* bool */) {\n            const singleAssignment = (resStr, x, typeCast = \"\") => `\n          let outputIndices${x} = ${output.offsetToIndices(`outputOffset + ${x}u`)};\n          let offset${x} = ${input.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n          let index${x} = offset${x} / 4u;\n          let component${x} = offset${x} % 4u;\n          ${resStr}[${x}] = ${typeCast}(${input.getByOffset(`index${x}`)}[component${x}]);\n        `;\n            assignment = `\n        let outputOffset = global_idx * ${components};\n        var data = vec4<u32>(0);\n        ${singleAssignment(\"data\", 0, \"u32\")}\n        ${singleAssignment(\"data\", 1, \"u32\")}\n        ${singleAssignment(\"data\", 2, \"u32\")}\n        ${singleAssignment(\"data\", 3, \"u32\")}\n        ${output.setByOffset(\"global_idx\", \"data\")}\n      }`;\n          } else {\n            assignment = `\n        let outputIndices = ${output.offsetToIndices(\"global_idx\")};\n        let inputOffset = ${input.broadcastedIndicesToOffset(\"outputIndices\", output)};\n        ${output.setByOffset(\"global_idx\", input.getByOffset(\"inputOffset\"))}\n      }`;\n          }\n          return `\n    ${shaderHelper.registerUniform(\"vec_size\", \"u32\").declareVariables(input, output)}\n    ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.vec_size\")}\n    ${assignment}`;\n        };\n        const programUniforms = [{ type: 12 /* uint32 */, data: outputSize }, ...createTensorShapeVariables(inputShape, outputShape)];\n        return {\n          name: \"Expand\",\n          shaderCache: { hint: `${outputShape.length}`, inputDependencies: [\"rank\"] },\n          getShaderSource,\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64\n              /* workgroup size */\n            ) },\n            programUniforms\n          })\n        };\n      };\n      expand = (context) => {\n        validateInputs12(context.inputs);\n        context.compute(createExpandProgramInfo(context.inputs), { inputs: [0] });\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/fast-gelu.ts\n  var createFastGeluProgramInfo, fastGelu2;\n  var init_fast_gelu = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/fast-gelu.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_common();\n      init_unary_op();\n      createFastGeluProgramInfo = (inputTensors) => {\n        const dataType = inputTensors[0].dataType;\n        const outputSize = ShapeUtil.size(inputTensors[0].dims);\n        const biasLength = ShapeUtil.size(inputTensors[1].dims);\n        const useVec4 = biasLength % 4 === 0;\n        const getShaderSource = (shaderHelper) => {\n          const x = inputVariable(\"x\", dataType, [1], 4);\n          const bias = inputVariable(\"bias\", dataType, [1], 4);\n          const y = outputVariable(\"y\", dataType, [1], 4);\n          const uniforms = [{ name: \"output_vec_size\", type: \"u32\" }, { name: \"bias_size\", type: \"u32\" }];\n          const singleElementBias = (i) => `\n      let bias${i}_offset: u32 = (global_idx * 4 + ${i}) % uniforms.bias_size;\n      let bias${i} = ${bias.getByOffset(`bias${i}_offset / 4`)}[bias${i}_offset % 4];`;\n          const biasGetExpression = useVec4 ? `\n      let bias = ${bias.getByOffset(\"global_idx % (uniforms.bias_size / 4)\")};` : `${singleElementBias(0)}${singleElementBias(1)}${singleElementBias(2)}${singleElementBias(3)}\n      let bias = ${x.type.value}(bias0, bias1, bias2, bias3);`;\n          return `${shaderHelper.registerUniforms(uniforms).declareVariables(x, bias, y)}\n\n    ${fastGeluImpl(tensorTypeToWsglValueType(dataType))}\n\n    ${shaderHelper.mainStart(WORKGROUP_SIZE)}\n      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.output_vec_size\")}\n\n      let x = ${x.getByOffset(\"global_idx\")};\n      ${biasGetExpression}\n      let x_in = x + bias;\n      ${y.setByOffset(\"global_idx\", fastGeluExpression(\"x_in\"))}\n    }`;\n        };\n        return {\n          name: \"FastGeluWithBias\",\n          shaderCache: { hint: `${useVec4}`, inputDependencies: [\"type\", \"type\"] },\n          getShaderSource,\n          getRunData: (inputs) => ({\n            outputs: [{ dims: inputs[0].dims, dataType: inputs[0].dataType }],\n            programUniforms: [{ type: 12 /* uint32 */, data: Math.ceil(outputSize / 4) }, { type: 12 /* uint32 */, data: biasLength }],\n            dispatchGroup: { x: Math.ceil(outputSize / WORKGROUP_SIZE / 4) }\n          })\n        };\n      };\n      fastGelu2 = (context) => {\n        if (context.inputs.length < 2 || ShapeUtil.size(context.inputs[1].dims) === 0) {\n          fastGelu(context);\n        } else {\n          context.compute(createFastGeluProgramInfo(context.inputs));\n        }\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/gather.ts\n  var validateInputs13, createGatherProgramInfo, parseGatherAttributes, gather;\n  var init_gather = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/gather.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_attribute_with_cache_key();\n      init_common();\n      validateInputs13 = (inputs) => {\n        if (!inputs || inputs.length !== 2) {\n          throw new Error(\"Gather requires 2 inputs.\");\n        }\n      };\n      createGatherProgramInfo = (inputs, attributes) => {\n        const inputShape = inputs[0].dims;\n        const indicesShape = inputs[1].dims;\n        const inputRank = inputShape.length;\n        const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank);\n        const outputShape = inputShape.slice(0);\n        outputShape.splice(axis, 1, ...indicesShape);\n        const axisDimLimit = inputShape[axis];\n        const components = inputs[0].dataType === 9 /* bool */ ? 4 : 1;\n        const outputSize = Math.ceil(ShapeUtil.size(outputShape) / components);\n        const programUniforms = [\n          { type: 12 /* uint32 */, data: outputSize },\n          { type: 6 /* int32 */, data: axisDimLimit },\n          { type: 12 /* uint32 */, data: axis },\n          ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims, outputShape)\n        ];\n        const getShaderSource = (shaderHelper) => {\n          const data = inputVariable(\"data\", inputs[0].dataType, inputs[0].dims.length, components);\n          const indices = inputVariable(\"inputIndices\", inputs[1].dataType, inputs[1].dims.length);\n          const output = outputVariable(\"output\", inputs[0].dataType, outputShape.length, components);\n          const calcDataIndices = (x) => {\n            const indicesRank = indicesShape.length;\n            let calcStr = `var indicesIndices${x}  = ${indices.type.indices}(0);`;\n            for (let i = 0; i < indicesRank; i++) {\n              calcStr += `${indicesRank > 1 ? `indicesIndices${x}[${i}]` : `indicesIndices${x}`} = ${outputShape.length > 1 ? `outputIndices${x}[uniforms.axis + ${i}]` : `outputIndices${x}`};`;\n            }\n            calcStr += `\n          var idx${x} = ${indices.getByIndices(`indicesIndices${x}`)};\n          if (idx${x} < 0) {\n            idx${x} = idx${x} + uniforms.axisDimLimit;\n          }\n          var dataIndices${x} : ${data.type.indices};\n        `;\n            for (let i = 0, j = 0; i < inputRank; i++) {\n              if (i === axis) {\n                calcStr += `${inputRank > 1 ? `dataIndices${x}[${i}]` : `dataIndices${x}`} = u32(idx${x});`;\n                j += indicesRank;\n              } else {\n                calcStr += `${inputRank > 1 ? `dataIndices${x}[${i}]` : `dataIndices${x}`} = ${outputShape.length > 1 ? `outputIndices${x}[${j}]` : `outputIndices${x}`};`;\n                j++;\n              }\n            }\n            return calcStr;\n          };\n          let assignment;\n          if (inputs[0].dataType === 9 /* bool */) {\n            const singleAssignment = (resStr, x, typeCast = \"\") => `\n          let outputIndices${x} = ${output.offsetToIndices(`outputOffset + ${x}u`)};\n          ${calcDataIndices(x)};\n          let offset${x} = ${data.indicesToOffset(`dataIndices${x}`)};\n          let index${x} = offset${x} / 4u;\n          let component${x} = offset${x} % 4u;\n          ${resStr}[${x}] = ${typeCast}(${data.getByOffset(`index${x}`)}[component${x}]);\n        `;\n            assignment = `\n        let outputOffset = global_idx * ${components};\n        var value = vec4<u32>(0);\n        ${singleAssignment(\"value\", 0, \"u32\")}\n        ${singleAssignment(\"value\", 1, \"u32\")}\n        ${singleAssignment(\"value\", 2, \"u32\")}\n        ${singleAssignment(\"value\", 3, \"u32\")}\n        ${output.setByOffset(\"global_idx\", \"value\")}\n      `;\n          } else {\n            assignment = `\n      let outputIndices = ${output.offsetToIndices(\"global_idx\")};\n      ${calcDataIndices(\"\")};\n      let value = ${data.getByIndices(\"dataIndices\")};\n      ${output.setByOffset(\"global_idx\", \"value\")};\n      `;\n          }\n          return `\n      ${shaderHelper.registerUniform(\"outputSize\", \"u32\").registerUniform(\"axisDimLimit\", \"i32\").registerUniform(\"axis\", \"u32\").declareVariables(data, indices, output)}\n      ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.outputSize\")}\n        ${assignment}\n      }`;\n        };\n        return {\n          name: \"Gather\",\n          shaderCache: { hint: attributes.cacheKey, inputDependencies: [\"rank\", \"rank\"] },\n          getRunData: () => ({\n            outputs: [\n              { dims: outputShape, dataType: inputs[0].dataType }\n            ],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64\n              /* workgroup size */\n            ) },\n            programUniforms\n          }),\n          getShaderSource\n        };\n      };\n      parseGatherAttributes = (attributes) => createAttributeWithCacheKey({ axis: attributes.axis });\n      gather = (context, attributes) => {\n        const inputs = context.inputs;\n        validateInputs13(inputs);\n        context.compute(createGatherProgramInfo(context.inputs, attributes));\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/gather-elements.ts\n  var validateInputs14, createGatherElementsProgramInfo, parseGatherElementsAttributes, gatherElements;\n  var init_gather_elements = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/gather-elements.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_attribute_with_cache_key();\n      init_common();\n      validateInputs14 = (inputs) => {\n        if (!inputs || inputs.length !== 2) {\n          throw new Error(\"GatherElements requires 2 inputs.\");\n        }\n        if (inputs[0].dims.length < 1) {\n          throw new Error(\"GatherElements requires that the data input be rank >= 1.\");\n        }\n        if (inputs[0].dims.length !== inputs[1].dims.length) {\n          throw new Error(`GatherElements requires that the data input and\n                     indices input tensors be of same rank.`);\n        }\n      };\n      createGatherElementsProgramInfo = (inputs, attributes) => {\n        const inputShape = inputs[0].dims;\n        const inputOutputDataType = inputs[0].dataType;\n        const inputRank = inputShape.length;\n        const indicesShape = inputs[1].dims;\n        const indicesDataType = inputs[1].dataType;\n        const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank);\n        const axisDimLimit = inputShape[axis];\n        const outputShape = indicesShape.slice(0);\n        const outputSize = ShapeUtil.size(outputShape);\n        const input = inputVariable(\"input\", inputOutputDataType, inputRank);\n        const indices = inputVariable(\"indicesInput\", indicesDataType, indicesShape.length);\n        const output = outputVariable(\"output\", inputOutputDataType, outputShape.length);\n        const programUniforms = [\n          { type: 12 /* uint32 */, data: outputSize },\n          { type: 6 /* int32 */, data: axisDimLimit },\n          { type: 12 /* uint32 */, data: axis }\n        ];\n        programUniforms.push(...createTensorShapeVariables(inputShape, indicesShape, outputShape));\n        const inputDependencies = [\"rank\", \"rank\"];\n        const getShaderSource = (shaderHelper) => `\n      ${shaderHelper.registerUniform(\"outputSize\", \"u32\").registerUniform(\"axisDimLimit\", \"i32\").registerUniform(\"axis\", \"u32\").declareVariables(input, indices, output)}\n      ${shaderHelper.mainStart()}\n      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.outputSize\")}\n\n      let outputIndices = ${output.offsetToIndices(\"global_idx\")};\n\n      var idx = ${indices.getByOffset(\"global_idx\")};\n      if (idx < 0) {\n        idx = idx + uniforms.axisDimLimit;\n      }\n      var inputIndices = ${input.type.indices}(outputIndices);\n      ${input.indicesSet(\"inputIndices\", \"uniforms.axis\", \"u32(idx)\")};\n      let value = ${input.getByIndices(\"inputIndices\")};\n\n      ${output.setByOffset(\"global_idx\", \"value\")};\n  }`;\n        return {\n          name: \"GatherElements\",\n          shaderCache: { inputDependencies },\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64\n              /* workgroup size */\n            ) },\n            programUniforms\n          }),\n          getShaderSource\n        };\n      };\n      parseGatherElementsAttributes = (attributes) => createAttributeWithCacheKey({ axis: attributes.axis });\n      gatherElements = (context, attributes) => {\n        const inputs = context.inputs;\n        validateInputs14(inputs);\n        context.compute(createGatherElementsProgramInfo(context.inputs, attributes));\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/gemm.ts\n  var validateInputs15, createGemmProgramInfo, parseGemmAttributes, gemm;\n  var init_gemm = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/gemm.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_common();\n      validateInputs15 = (inputs) => {\n        if (!inputs) {\n          throw new Error(\"Input is missing\");\n        }\n        if (inputs.length < 2 || inputs.length > 3) {\n          throw new Error(\"Invaid input number.\");\n        }\n        if (inputs.length === 3 && inputs[2].dims.length > 2) {\n          throw new Error(\"Invalid input shape of C\");\n        }\n        if (inputs[0].dataType !== inputs[1].dataType || inputs.length === 3 && inputs[0].dataType !== inputs[2].dataType) {\n          throw new Error(\"Input types are mismatched\");\n        }\n      };\n      createGemmProgramInfo = (inputs, attributes) => {\n        const aShape = inputs[0].dims.slice();\n        const bShape = inputs[1].dims.slice();\n        const [M, N, K] = GemmUtil.getShapeOfGemmResult(\n          aShape,\n          attributes.transA,\n          bShape,\n          attributes.transB,\n          inputs.length === 3 ? inputs[2].dims : void 0\n        );\n        const outputShape = [M, N];\n        if (!outputShape) {\n          throw new Error(\"Can't use gemm on the given tensors\");\n        }\n        const outputSize = ShapeUtil.size(outputShape);\n        const programUniforms = [\n          { type: 12 /* uint32 */, data: outputSize },\n          { type: 12 /* uint32 */, data: M },\n          { type: 12 /* uint32 */, data: N },\n          { type: 12 /* uint32 */, data: K },\n          { type: 1 /* float */, data: attributes.alpha },\n          { type: 1 /* float */, data: attributes.beta }\n        ];\n        const inputDependencies = [\"type\", \"type\"];\n        if (inputs.length === 3) {\n          programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n          inputDependencies.push(\"rank\");\n        }\n        programUniforms.push(...createTensorShapeVariables(outputShape));\n        const getShaderSource = (shaderHelper) => {\n          let line = \"\";\n          if (attributes.transA && attributes.transB) {\n            line = \"value += a[k * uniforms.M + m] * b[n * uniforms.K + k];\";\n          } else if (attributes.transA && !attributes.transB) {\n            line = \"value += a[k * uniforms.M + m] * b[k * uniforms.N + n];\";\n          } else if (!attributes.transA && attributes.transB) {\n            line = \"value += a[m * uniforms.K + k] * b[n * uniforms.K + k];\";\n          } else if (!attributes.transA && !attributes.transB) {\n            line = \"value += a[m * uniforms.K + k] * b[k * uniforms.N + n];\";\n          }\n          const calculateAlpha = attributes.alpha === 1 ? \"\" : \"value *= uniforms.alpha;\";\n          const a = inputVariable(\"a\", inputs[0].dataType, inputs[0].dims);\n          const b = inputVariable(\"b\", inputs[1].dataType, inputs[1].dims);\n          const dataType = a.type.value;\n          let c = null;\n          const variables = [a, b];\n          if (inputs.length === 3) {\n            c = inputVariable(\"c\", inputs[2].dataType, inputs[2].dims.length);\n            variables.push(c);\n          }\n          const output = outputVariable(\"output\", inputs[0].dataType, outputShape.length);\n          variables.push(output);\n          const uniforms = [\n            { name: \"output_size\", type: \"u32\" },\n            { name: \"M\", type: \"u32\" },\n            { name: \"N\", type: \"u32\" },\n            { name: \"K\", type: \"u32\" },\n            { name: \"alpha\", type: \"f32\" },\n            { name: \"beta\", type: \"f32\" }\n          ];\n          return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.output_size\")}\n\n    let m = global_idx / uniforms.N;\n    let n = global_idx % uniforms.N;\n\n    var value = ${dataType}(0);\n    for (var k: u32 = 0u; k < uniforms.K; k++) {\n      ${line}\n    }\n\n    ${calculateAlpha}\n    ${(() => {\n            if (c != null) {\n              return `let cOffset = ${c.broadcastedIndicesToOffset(\"vec2(m, n)\", output)}; value += ${dataType}(uniforms.beta) * ${c.getByOffset(\"cOffset\")};`;\n            }\n            return \"\";\n          })()}\n    output[global_idx] = value;\n  }`;\n        };\n        return {\n          name: \"Gemm\",\n          shaderCache: { hint: `${attributes.cacheKey}`, inputDependencies },\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64\n              /* workgroup size */\n            ) },\n            programUniforms\n          }),\n          getShaderSource\n        };\n      };\n      parseGemmAttributes = (attributes) => {\n        const transA = attributes.transA;\n        const transB = attributes.transB;\n        const alpha = attributes.alpha;\n        const beta = attributes.beta;\n        return { transA, transB, alpha, beta, cacheKey: `${attributes.transA};${attributes.transB};${attributes.alpha === 1}` };\n      };\n      gemm = (context, attributes) => {\n        validateInputs15(context.inputs);\n        context.compute(createGemmProgramInfo(context.inputs, attributes));\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/instance-norm.ts\n  var createInstanceNormProgramInfo, computeMean, createInstanceNormNHWCProgramInfo, instanceNorm;\n  var init_instance_norm = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/instance-norm.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_common();\n      createInstanceNormProgramInfo = (inputs, attributes) => {\n        const xShape = inputs[0].dims;\n        const outputShape = xShape;\n        const axis = 2;\n        const normCount = ShapeUtil.sizeToDimension(xShape, axis);\n        const normSize = ShapeUtil.sizeFromDimension(xShape, axis);\n        const components = getMaxComponents(normSize);\n        const normPackedSize = normSize / components;\n        const inputShape = [xShape[0], xShape[1], normPackedSize];\n        const inputDependencies = [\"rank\", \"type\", \"type\"];\n        const programUniforms = [{ type: 12 /* uint32 */, data: normSize }, { type: 12 /* uint32 */, data: normPackedSize }];\n        programUniforms.push(...createTensorShapeVariables(inputShape, inputShape));\n        const getShaderSource = (shaderHelper) => {\n          const x = inputVariable(\"x\", inputs[0].dataType, inputShape.length, components);\n          const scale = inputVariable(\"scale\", inputs[1].dataType, inputs[1].dims);\n          const bias = inputVariable(\"bias\", inputs[2].dataType, inputs[2].dims);\n          const output = outputVariable(\"output\", inputs[0].dataType, inputShape.length, components);\n          const variables = [x, scale, bias, output];\n          const dataType = x.type.value;\n          const f32Type = components === 1 ? \"f32\" : `vec${components}<f32>`;\n          const workgroupSize = 64;\n          const uniforms = [{ name: \"normSize\", type: \"u32\" }, { name: \"normPackedSize\", type: \"u32\" }];\n          return `\n  var<workgroup> meanShared : f32;\n  var<workgroup> squaredNormShared : f32;\n  var<workgroup> workgroupShared : array<${f32Type}, ${workgroupSize}>;\n  const workgroupSize = ${workgroupSize}u;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n  ${shaderHelper.mainStart(workgroupSize)}\n    let norm = global_idx / workgroupSize;\n    let batch = norm / uniforms.x_shape[1];\n    let channel = norm % uniforms.x_shape[1];\n    let localIndex = local_id.x;\n\n    // initialize workgroup memory\n    var initial = ${f32Type}(0);\n    for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) {\n      initial = initial + ${f32Type}(${x.get(\"batch\", \"channel\", \"h\")});\n    }\n    workgroupShared[localIndex] = initial;\n    workgroupBarrier();\n\n    // Calculate the mean of current channel data.\n    for (var currSize = workgroupSize >> 1;  currSize > 0; currSize = currSize >> 1) {\n      if (localIndex < currSize) {\n        workgroupShared[localIndex] = workgroupShared[localIndex] + workgroupShared[localIndex + currSize];\n      }\n      workgroupBarrier();\n    }\n    if (localIndex == 0) {\n      meanShared = ${sumVector(\"workgroupShared[0]\", components)} / f32(uniforms.normSize);\n    }\n    workgroupBarrier();\n\n    // reinitialize workgroup memory.\n    initial = ${f32Type}(0);\n    for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) {\n      let deviation =  ${f32Type}(${x.get(\"batch\", \"channel\", \"h\")}) - ${f32Type}(meanShared);\n      initial = initial + deviation * deviation;\n    }\n    workgroupShared[localIndex] = initial;\n    workgroupBarrier();\n\n    // Calculate the sum of square of deviation of current channel data.\n    for (var currSize = workgroupSize >> 1;  currSize > 0; currSize = currSize >> 1) {\n      if (localIndex < currSize) {\n        workgroupShared[localIndex] = workgroupShared[localIndex] + workgroupShared[localIndex + currSize];\n      }\n      workgroupBarrier();\n    }\n    if (localIndex == 0) {\n      squaredNormShared = ${sumVector(\"workgroupShared[0]\", components)};\n    }\n    workgroupBarrier();\n\n    let invStdDev = inverseSqrt(squaredNormShared / f32(uniforms.normSize) + f32(${attributes.epsilon}));\n    let channelScale = invStdDev * f32(${scale.getByOffset(\"channel\")});\n    let channelShift = f32(${bias.getByOffset(\"channel\")}) - meanShared * channelScale;\n    for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) {\n      let value = ${x.get(\"batch\", \"channel\", \"h\")} * ${dataType}(${f32Type}(channelScale)) + ${dataType}(${f32Type}(channelShift));\n      ${output.set(\"batch\", \"channel\", \"h\", \"value\")};\n    }\n  }`;\n        };\n        return {\n          ...{ name: \"InstanceNormalization\" },\n          // TODO: use epsilon as uniform. Currently epsilon as uniform fails test_instancenorm_epsilon.\n          shaderCache: { hint: `${attributes.epsilon};${components}`, inputDependencies },\n          getRunData: () => ({\n            outputs: [\n              { dims: outputShape, dataType: inputs[0].dataType }\n            ],\n            dispatchGroup: { x: normCount },\n            programUniforms\n          }),\n          getShaderSource\n        };\n      };\n      computeMean = (context, input, scale, bias, n, h, c, epsilon) => {\n        const components = getMaxComponents(c);\n        const WG = 64;\n        const outputType = components === 1 ? \"vec2f\" : `mat2x${components}f`;\n        const sumCastType = components === 1 ? \"f32\" : `vec${components}f`;\n        const setOutputValue = (var1, var2) => `${outputType}(${var1}, ${var2})`;\n        const unitsOfWork = n * c / components;\n        const wgSize = Math.ceil(h / WG);\n        const meanInputDependencies = [\"type\"];\n        const meanProgramUniforms = [\n          { type: 12 /* uint32 */, data: wgSize },\n          { type: 12 /* uint32 */, data: h },\n          { type: 12 /* uint32 */, data: Math.floor(c / components) },\n          { type: 12 /* uint32 */, data: Math.floor(h * c / components) }\n        ];\n        const getMeanShaderSource = (shaderHelper) => {\n          const inputHelper = inputVariable(\"input\", input.dataType, input.dims, components);\n          return `\n  ${shaderHelper.declareVariables(inputHelper)}\n  @group(0) @binding(1) var<storage, read_write> output : array<${outputType}>;\n  struct Uniforms {wg_size:u32, H:u32, C:u32, image_size:u32};\n  @group(0) @binding(2) var<uniform> uniforms: Uniforms;\n\n  ${shaderHelper.mainStart(WG)}\n    let currentImageNumber = global_idx / ${WG} / uniforms.C;\n    let currentChannelNumber = (global_idx / ${WG}) % uniforms.C;\n    let wgOffset = local_id.x * uniforms.wg_size;\n    if (wgOffset >= uniforms.H) {\n        return;\n    }\n    let wgMax = min(wgOffset + uniforms.wg_size, uniforms.H);\n\n    let offset = currentImageNumber * uniforms.image_size + currentChannelNumber;\n    var sum = ${fillVector(\"f32\", components)};\n    var squaredSum = ${fillVector(\"f32\", components)};\n    for (var i: u32 = wgOffset; i < wgMax; i++) {\n        let value = ${sumCastType}(input[offset + i * uniforms.C]);\n        sum += value;\n        squaredSum += value * value;\n    }\n    output[global_idx] = ${setOutputValue(\"sum\", \"squaredSum\")};\n  }`;\n        };\n        const meanValues = context.compute(\n          {\n            name: \"InstanceNormComputeMean\",\n            shaderCache: { hint: `${components}`, inputDependencies: meanInputDependencies },\n            getRunData: () => ({\n              outputs: [\n                { dims: [n, c, WG, 2], dataType: 1 /* float */ }\n              ],\n              dispatchGroup: { x: n * c / components },\n              programUniforms: meanProgramUniforms\n            }),\n            getShaderSource: getMeanShaderSource\n          },\n          { inputs: [input], outputs: [-1] }\n        )[0];\n        const programUniforms = [\n          { type: 12 /* uint32 */, data: unitsOfWork },\n          { type: 12 /* uint32 */, data: h },\n          { type: 12 /* uint32 */, data: Math.floor(c / components) },\n          { type: 12 /* uint32 */, data: Math.floor(WG * c / components) }\n        ];\n        const inputDependencies = [\"type\", \"type\", \"type\"];\n        const getShaderSource = (shaderHelper) => {\n          const scaleHelper = inputVariable(\"scale\", scale.dataType, scale.dims, components);\n          const biasHelper = inputVariable(\"bias\", bias.dataType, bias.dims, components);\n          return `\n  @group(0) @binding(0) var<storage, read> input : array<${outputType}>;\n  @group(0) @binding(1) var<storage, read> scale : array<${scaleHelper.type.storage}>;\n  @group(0) @binding(2) var<storage, read> bias : array<${biasHelper.type.storage}>;\n  @group(0) @binding(3) var<storage, read_write> output : array<${outputType}>;\n  struct Uniforms {units_of_work : u32, H: u32, C : u32, image_size : u32};\n  @group(0) @binding(4) var<uniform> uniforms: Uniforms;\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.units_of_work\")}\n    let currentImageNumber = global_idx / uniforms.C;\n    let currentChannelNumber = global_idx % uniforms.C;\n\n    let offset = currentImageNumber * uniforms.image_size;\n    var sum = ${fillVector(\"f32\", components)};\n    var squaredSum = ${fillVector(\"f32\", components)};\n    for (var i: u32 = 0; i < min(${WG}, uniforms.H); i++) {\n        let value = input[offset + i + currentChannelNumber * ${WG}];\n        sum += value[0];\n        squaredSum += value[1];\n    }\n    sum = sum / f32(uniforms.H);\n    squaredSum = squaredSum / f32(uniforms.H);\n    let invStdDev = inverseSqrt(squaredSum - sum * sum + f32(${epsilon}));\n    let channelScale = invStdDev * ${sumCastType}(scale[currentChannelNumber]);\n    let channelShift = ${sumCastType}(bias[currentChannelNumber]) - sum * channelScale;\n\n    output[global_idx] = ${setOutputValue(\"channelScale\", \"channelShift\")};\n  }`;\n        };\n        return context.compute(\n          {\n            name: \"InstanceNormComputeChannelScaleShift\",\n            // TODO: use epsilon as uniform. Currently epsilon as uniform fails test_instancenorm_epsilon.\n            shaderCache: { hint: `${components};${epsilon}`, inputDependencies },\n            getRunData: () => ({\n              outputs: [\n                { dims: [n, c, 2], dataType: 1 /* float */ }\n              ],\n              dispatchGroup: { x: Math.ceil(\n                unitsOfWork / 64\n                /* workgroup size */\n              ) },\n              programUniforms\n            }),\n            getShaderSource\n          },\n          { inputs: [meanValues, scale, bias], outputs: [-1] }\n        )[0];\n      };\n      createInstanceNormNHWCProgramInfo = (context, inputs, attributes) => {\n        const xShape = inputs[0].dims;\n        const outputShape = xShape;\n        const N = xShape[0];\n        const C = xShape[xShape.length - 1];\n        const H = ShapeUtil.sizeFromDimension(xShape, 1) / C;\n        const components = getMaxComponents(C);\n        const outputSize = ShapeUtil.size(outputShape) / components;\n        const programUniforms = [{ type: 12 /* uint32 */, data: H }, { type: 12 /* uint32 */, data: Math.floor(C / components) }];\n        const inputDependencies = [\"type\", \"type\"];\n        const channelScaleShift = computeMean(context, inputs[0], inputs[1], inputs[2], N, H, C, attributes.epsilon);\n        const getShaderSource = (shaderHelper) => {\n          const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n          const scaleType = components === 1 ? \"vec2f\" : `mat2x${components}f`;\n          const scaleCastType = components === 1 ? dataType : `vec${components}<${dataType}>`;\n          const inputHelper = inputVariable(\"input\", inputs[0].dataType, inputs[0].dims, components);\n          const outputHelper = outputVariable(\"output\", inputs[0].dataType, outputShape, components);\n          return `\n  @group(0) @binding(0) var<storage, read> input : array<${inputHelper.type.storage}>;\n  @group(0) @binding(1) var<storage, read> scaleInput : array<${scaleType}>;\n  @group(0) @binding(2) var<storage, read_write> output : array<${outputHelper.type.storage}>;\n  struct Uniforms {H: u32, C : u32};\n  @group(0) @binding(3) var<uniform> uniforms: Uniforms;\n\n  ${shaderHelper.mainStart()}\n    let currentImageNumber = global_idx / (uniforms.C * uniforms.H);\n    let currentChannelNumber = global_idx % uniforms.C;\n\n    let scaleOffset = currentImageNumber * uniforms.C + currentChannelNumber;\n    let scale = scaleInput[scaleOffset];\n    output[global_idx] = fma(input[global_idx], ${scaleCastType}(scale[0]), ${scaleCastType}(scale[1]));\n  }`;\n        };\n        context.compute(\n          {\n            name: \"InstanceNormalizationNHWC\",\n            shaderCache: { hint: `${components}`, inputDependencies },\n            getRunData: () => ({\n              outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n              dispatchGroup: { x: Math.ceil(\n                outputSize / 64\n                /* workgroup size */\n              ) },\n              programUniforms\n            }),\n            getShaderSource\n          },\n          { inputs: [inputs[0], channelScaleShift] }\n        );\n      };\n      instanceNorm = (context, attributes) => {\n        if (attributes.format === \"NHWC\") {\n          createInstanceNormNHWCProgramInfo(context, context.inputs, attributes);\n        } else {\n          context.compute(createInstanceNormProgramInfo(context.inputs, attributes));\n        }\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/layer-norm.ts\n  var validateInputs16, createLayerNormProgramInfo, layerNorm;\n  var init_layer_norm = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/layer-norm.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_common();\n      validateInputs16 = (inputs) => {\n        if (!inputs || inputs.length < 2) {\n          throw new Error(\"layerNorm requires at least 2 inputs.\");\n        }\n      };\n      createLayerNormProgramInfo = (inputs, attributes, outputCount) => {\n        const simplified = attributes.simplified;\n        const xShape = inputs[0].dims;\n        const scale = inputs[1];\n        const bias = !simplified && inputs[2];\n        const outputShape = xShape;\n        const axis = ShapeUtil.normalizeAxis(attributes.axis, xShape.length);\n        const normCount = ShapeUtil.sizeToDimension(xShape, axis);\n        const normSize = ShapeUtil.sizeFromDimension(xShape, axis);\n        const scaleSize = ShapeUtil.size(scale.dims);\n        const biasSize = bias ? ShapeUtil.size(bias.dims) : 0;\n        if (scaleSize !== normSize || bias && biasSize !== normSize) {\n          throw new Error(`Size of X.shape()[axis:] == ${normSize}.\n       Size of scale and bias (if provided) must match this.\n       Got scale size of ${scaleSize} and bias size of ${biasSize}`);\n        }\n        const meanInvStdDevDim = [];\n        for (let i = 0; i < xShape.length; ++i) {\n          if (i < axis) {\n            meanInvStdDevDim.push(xShape[i]);\n          } else {\n            meanInvStdDevDim.push(1);\n          }\n        }\n        const components = getMaxComponents(normSize);\n        const inputDependencies = [\"type\", \"type\"];\n        const programUniforms = [\n          { type: 12 /* uint32 */, data: normCount },\n          { type: 1 /* float */, data: normSize },\n          { type: 12 /* uint32 */, data: Math.floor(normSize / components) },\n          { type: 1 /* float */, data: attributes.epsilon }\n        ];\n        if (bias) {\n          inputDependencies.push(\"type\");\n        }\n        const hasMeanDataOutput = outputCount > 1;\n        const hasInvStdOutput = outputCount > 2;\n        const getShaderSource = (shaderHelper) => {\n          const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n          const variables = [\n            inputVariable(\"x\", inputs[0].dataType, inputs[0].dims, components),\n            inputVariable(\"scale\", scale.dataType, scale.dims, components)\n          ];\n          if (bias) {\n            variables.push(inputVariable(\"bias\", bias.dataType, bias.dims, components));\n          }\n          variables.push(outputVariable(\"output\", inputs[0].dataType, outputShape, components));\n          if (hasMeanDataOutput) {\n            variables.push(outputVariable(\"mean_data_output\", 1 /* float */, meanInvStdDevDim));\n          }\n          if (hasInvStdOutput) {\n            variables.push(outputVariable(\"inv_std_output\", 1 /* float */, meanInvStdDevDim));\n          }\n          const uniforms = [\n            { name: \"norm_count\", type: \"u32\" },\n            { name: \"norm_size\", type: \"f32\" },\n            { name: \"norm_size_vectorized\", type: \"u32\" },\n            { name: \"epsilon\", type: \"f32\" }\n          ];\n          return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.norm_count\")}\n    let offset = global_idx * uniforms.norm_size_vectorized;\n    var mean_vector = ${fillVector(\"f32\", components)};\n    var mean_square_vector = ${fillVector(\"f32\", components)};\n\n    for (var h: u32 = 0u; h < uniforms.norm_size_vectorized; h++) {\n      let value = ${castToF32(dataType, components, \"x[h + offset]\")};\n      mean_vector += value;\n      mean_square_vector += value * value;\n    }\n    let mean = ${sumVector(\"mean_vector\", components)} / uniforms.norm_size;\n    let inv_std_dev = inverseSqrt(${sumVector(\"mean_square_vector\", components)} / uniforms.norm_size ${simplified ? \"\" : \"- mean * mean\"} + uniforms.epsilon);\n\n    for (var j: u32 = 0; j < uniforms.norm_size_vectorized; j++) {\n      let f32input = ${castToF32(dataType, components, \"x[j + offset]\")};\n      let f32scale = ${castToF32(dataType, components, \"scale[j]\")};\n      output[j + offset] = ${variables[0].type.value}((f32input ${simplified ? \"\" : \"- mean\"}) * inv_std_dev * f32scale\n        ${bias ? `+ ${castToF32(dataType, components, \"bias[j]\")}` : \"\"}\n      );\n    }\n\n    ${hasMeanDataOutput ? \"mean_data_output[global_idx] = mean\" : \"\"};\n    ${hasInvStdOutput ? \"inv_std_output[global_idx] = inv_std_dev\" : \"\"};\n  }`;\n        };\n        const outputs = [{ dims: outputShape, dataType: inputs[0].dataType }];\n        if (hasMeanDataOutput) {\n          outputs.push({ dims: meanInvStdDevDim, dataType: 1 /* float */ });\n        }\n        if (hasInvStdOutput) {\n          outputs.push({ dims: meanInvStdDevDim, dataType: 1 /* float */ });\n        }\n        return {\n          name: \"LayerNormalization\",\n          shaderCache: { hint: `${components};${outputCount};${simplified}`, inputDependencies },\n          getRunData: () => ({ outputs, dispatchGroup: { x: Math.ceil(\n            normCount / 64\n            /* workgroup size */\n          ) }, programUniforms }),\n          getShaderSource\n        };\n      };\n      layerNorm = (context, attributes) => {\n        validateInputs16(context.inputs);\n        context.compute(createLayerNormProgramInfo(context.inputs, attributes, context.outputCount));\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/matmulnbits.ts\n  var validateInputs17, createMatMulNBitsProgramInfo, matMulNBits, parseMatMulNBitsAttributes;\n  var init_matmulnbits = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/matmulnbits.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_attribute_with_cache_key();\n      init_common();\n      validateInputs17 = (inputs, attributes) => {\n        if (inputs.length < 3 || inputs.length > 4) {\n          throw new Error(\"MatMulNBits requires 3 or 4 inputs\");\n        }\n        const a = inputs[0];\n        const aRank = a.dims.length;\n        if (a.dims[aRank - 1] !== attributes.k) {\n          throw new Error(\"The last dim of input shape does not match the k value\");\n        }\n        const nBlocksPerCol = Math.floor((attributes.k + attributes.blockSize - 1) / attributes.blockSize);\n        const blobSize = attributes.blockSize / 8 * attributes.bits;\n        const b = inputs[1];\n        if (!ShapeUtil.areEqual(b.dims, [attributes.n, nBlocksPerCol, blobSize])) {\n          throw new Error(\"The second inputs must be 3D tensor with shape N X nBlocksPerCol X blobSize\");\n        }\n        const scales = inputs[2];\n        const scalesShape = scales.dims;\n        if (ShapeUtil.size(scalesShape) !== attributes.n * nBlocksPerCol) {\n          throw new Error(\"scales input size error.\");\n        }\n        if (inputs.length === 4) {\n          const zeroPoints = inputs[3];\n          const zeroPointsShape = zeroPoints.dims;\n          const expectedZeroPointsSize = attributes.bits > 4 ? attributes.n * nBlocksPerCol : attributes.n * Math.floor((nBlocksPerCol + 1) / 2);\n          if (ShapeUtil.size(zeroPointsShape) !== expectedZeroPointsSize) {\n            throw new Error(\"zeroPoints input size error.\");\n          }\n        }\n      };\n      createMatMulNBitsProgramInfo = (inputs, attributes, maxComputeWorkgroupSizes, maxComputeWorkgroupStorageSize) => {\n        const inputShape = inputs[0].dims;\n        const aRank = inputShape.length;\n        const nBlocksPerCol = Math.floor((attributes.k + attributes.blockSize - 1) / attributes.blockSize);\n        const dimAOuter = inputShape[aRank - 2];\n        const dimInner = attributes.k;\n        const dimBOuter = attributes.n;\n        const batchDims = inputShape.slice(0, aRank - 2);\n        const batchSize = ShapeUtil.size(batchDims);\n        const blobSize = attributes.blockSize / 8 * attributes.bits;\n        const blobSizeInWords = blobSize / 4;\n        const dataType = inputs[0].dataType;\n        const outputNumber = getMaxComponents(dimAOuter);\n        const aComponents = getMaxComponents(attributes.k);\n        const bComponents = getMaxComponents(blobSizeInWords);\n        const elementSize = getTensorElementSize(dataType);\n        const workgroupOutputSize = dimAOuter * nBlocksPerCol * elementSize;\n        const maxNumberOfComponents = Math.floor(maxComputeWorkgroupStorageSize / workgroupOutputSize);\n        const useBlockwiseMatMulNBits = nBlocksPerCol <= maxComputeWorkgroupSizes[0] && maxNumberOfComponents > 0;\n        const components = !useBlockwiseMatMulNBits || maxNumberOfComponents >= 4 ? getMaxComponents(dimBOuter) : maxNumberOfComponents >= 2 && getMaxComponents(dimBOuter) >= 2 ? 2 : 1;\n        const outputShape = batchDims.concat([dimAOuter, dimBOuter]);\n        const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;\n        const programUniforms = useBlockwiseMatMulNBits ? [] : [{ type: 12 /* uint32 */, data: outputSize }, { type: 12 /* uint32 */, data: attributes.blockSize }];\n        const inputShapeTemp = [batchSize, dimAOuter, dimInner / aComponents];\n        const bShape = ShapeUtil.convertShape(inputs[1].dims).slice();\n        bShape.splice(-1, 1, blobSizeInWords / bComponents);\n        programUniforms.push(...createTensorShapeVariables(inputShapeTemp));\n        programUniforms.push(...createTensorShapeVariables(bShape));\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n        if (inputs.length === 4) {\n          programUniforms.push(...createTensorShapeVariables(ShapeUtil.convertShape(inputs[3].dims)));\n        }\n        const outputShapeTemp = [batchSize, dimAOuter, dimBOuter / components];\n        programUniforms.push(...createTensorShapeVariables(outputShapeTemp));\n        const getShaderSource = (shaderHelper) => {\n          const inputRank = inputShapeTemp.length;\n          const a = inputVariable(\"a\", inputs[0].dataType, inputRank, aComponents);\n          const b = inputVariable(\"b\", 12 /* uint32 */, bShape.length, bComponents);\n          const scales = inputVariable(\"scales\", inputs[2].dataType, inputs[2].dims.length);\n          const inputVariables = [a, b, scales];\n          const zeroPoints = inputs.length === 4 ? inputVariable(\"zero_points\", 12 /* uint32 */, inputs[3].dims.length) : void 0;\n          if (zeroPoints) {\n            inputVariables.push(zeroPoints);\n          }\n          const outputRank = outputShapeTemp.length;\n          const output = outputVariable(\"output\", inputs[0].dataType, outputRank, components);\n          const uniforms = [{ name: \"output_size\", type: \"u32\" }, { name: \"block_size\", type: \"u32\" }];\n          const dataType2 = tensorTypeToWsglStorageType(inputs[0].dataType);\n          const qDqDataType = (() => {\n            switch (aComponents) {\n              case 1:\n                return `array<${dataType2}, 8>`;\n              case 2:\n                return `mat4x2<${dataType2}>`;\n              case 4:\n                return `mat2x4<${dataType2}>`;\n              default:\n                throw new Error(`${aComponents}-component is not supported.`);\n            }\n          })();\n          const processOneBlock = `\n        for (var word: u32 = 0; word < ${blobSizeInWords}; word += ${bComponents}) {\n          ${b.indicesSet(\"b_indices\", \"2\", \"word\")};\n          let b_data = ${b.getByIndices(\"b_indices\")};\n          for (var i: u32 = 0; i < ${bComponents}; i++) {\n            let b_value: u32 = ${bComponents === 1 ? \"b_data\" : \"b_data[word + i]\"};\n            let b_mask: u32 = 0x0F0F0F0Fu;\n            let b_value_lower: vec4<u32> = unpack4xU8(b_value & b_mask);\n            let b_value_upper: vec4<u32> = unpack4xU8((b_value >> 4) & b_mask);\n            let b_quantized_values = ${qDqDataType}(${Array.from({ length: 4 }, (_, i) => `${dataType2}(b_value_lower[${i}]), ${dataType2}(b_value_upper[${i}])`).join(\", \")});\n            let b_dequantized_values = ${(() => {\n            if (aComponents === 1) {\n              return `${qDqDataType}(${Array.from({ length: 8 }, (_, i) => `(b_quantized_values[${i}] - zero_point) * scale`).join(\", \")});`;\n            } else {\n              return `(b_quantized_values - ${qDqDataType}(${Array(8).fill(\"zero_point\").join(\",\")})) * scale;`;\n            }\n          })()};\n            // Number of B elements per 32-bit word is 32/bits = 32/4 = 8\n            for (var m: u32 = 0; m < ${useBlockwiseMatMulNBits ? dimAOuter : outputNumber}u; m++) {\n              ${a.indicesSet(\"a_indices\", inputRank - 2, useBlockwiseMatMulNBits ? \"m\" : `row * ${outputNumber} + m`)};\n              ${a.indicesSet(\"a_indices\", inputRank - 1, \"word_offset\")};\n              var input_offset = ${a.indicesToOffset(\"a_indices\")};\n              var a_data: ${qDqDataType};\n              for (var j: u32 = 0; j < ${8 / aComponents}; j++) {\n                a_data[j] = ${a.getByOffset(\"input_offset\")};\n                input_offset++;\n              }\n              ${useBlockwiseMatMulNBits ? \"workgroup_shared[workgroup_shared_offset + m]\" : \"output_values[m]\"}${components > 1 ? \"[c]\" : \"\"} += ${Array.from(\n            { length: 8 / aComponents },\n            (_, i) => `${aComponents === 1 ? `a_data[${i}] * b_dequantized_values[${i}]` : `dot(a_data[${i}], b_dequantized_values[${i}])`}`\n          ).join(\" + \")};\n            }\n            word_offset += ${8 / aComponents};\n          }\n        }`;\n          const updateZeroPointIndex = zeroPoints ? `\n          zero_point_offset += 4;\n          if (zero_point_offset == 32) {\n            zero_point_offset = 0;\n            zero_point_index++;\n            zero_point_word = ${zeroPoints.getByOffset(\"zero_point_index\")};\n          }` : \"\";\n          return useBlockwiseMatMulNBits ? `\n        var<workgroup> workgroup_shared: array<${output.type.value}, ${dimAOuter * nBlocksPerCol}>;\n        ${shaderHelper.declareVariables(...inputVariables, output)}\n        ${shaderHelper.mainStart([\n            nBlocksPerCol,\n            1,\n            1\n          ])}\n          var a_indices: ${a.type.indices};\n          var block = local_id.x;\n          var col = workgroup_id.y;\n          var batch = workgroup_id.z;\n          ${a.indicesSet(\"a_indices\", \"0\", \"batch\")};\n          // Two zero points are packed into one byte when uniforms.bits is 4.\n          for (var c: u32 = 0; c < ${components}; c++) {\n            let col_times_components_plus_c = col * ${components} + c;\n              ${zeroPoints ? `\n            var zero_point_bytes_per_col: u32 = (${nBlocksPerCol} + 1) / 2;\n            var zero_point_byte_count: u32 = col_times_components_plus_c * zero_point_bytes_per_col + (block >> 0x1u);\n            var zero_point_word_index: u32 = zero_point_byte_count >> 0x2u;\n            var zero_point_byte_offset: u32 = zero_point_byte_count & 0x3u;\n            var zero_point_nibble_offset: u32 = block & 0x1u;\n            var zero_point_bits_offset: u32 = (zero_point_byte_offset << 3) + (zero_point_nibble_offset << 2);\n            var zero_point_word: u32 = ${zeroPoints.getByOffset(\"zero_point_word_index\")} >> zero_point_bits_offset;` : \"\"}\n            var b_indices: ${b.type.indices};\n            ${b.indicesSet(\"b_indices\", \"0\", \"col_times_components_plus_c\")};\n            // The scale and zero points are computed per block.\n            var scales_index = col_times_components_plus_c * ${nBlocksPerCol} + block;\n            let scale = ${scales.getByOffset(\"scales_index\")};\n            // The default zero point is 8 for unsigned 4-bit quantization.\n            let zero_point = ${dataType2}(${zeroPoints ? \"(zero_point_word) & 0xFu\" : 8});\n            ${b.indicesSet(\"b_indices\", \"1\", \"block\")};\n            var word_offset: u32 = block * ${attributes.blockSize / aComponents};\n            var workgroup_shared_offset: u32 = block * ${dimAOuter};\n            ${processOneBlock}\n          }\n          workgroupBarrier();\n          if (local_id.x == 0u) {\n            var output_indices: ${output.type.indices};\n            ${output.indicesSet(\"output_indices\", \"0\", \"batch\")};\n            ${output.indicesSet(\"output_indices\", outputRank - 1, \"col\")};\n            ${output.indicesSet(\"output_indices\", outputRank - 2, \"0\")};\n            var output_offset = ${output.indicesToOffset(\"output_indices\")};\n            for (var m: u32 = 0u; m < ${dimAOuter}u; m++) {\n              var output_value: ${output.type.value} = ${output.type.value}(0);\n              var workgroup_shared_offset: u32 = m;\n              for (var b: u32 = 0u; b < ${nBlocksPerCol}u; b++) {\n                output_value += workgroup_shared[workgroup_shared_offset];\n                workgroup_shared_offset += ${dimAOuter};\n              }\n              ${output.setByOffset(\"output_offset\", \"output_value\")};\n              output_offset += ${dimBOuter / components};\n            }\n          }\n        }` : `\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n        ${shaderHelper.mainStart()}\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.output_size\")}\n          var output_values: array<${output.type.value}, ${outputNumber}>;\n          var output_indices = ${output.offsetToIndices(\"global_idx\")};\n          var col = ${output.indicesGet(\"output_indices\", outputRank - 1)};\n          var row = ${output.indicesGet(\"output_indices\", outputRank - 2)};\n          var a_indices: ${a.type.indices} = output_indices;\n          // Two zero points are packed into one byte because uniforms.bits <= 4.\n          // zero_point_offset is either 0 or 4. It is bit offset within one byte.\n          // TODO support zero_point_offset for bits > 4\n          ${zeroPoints ? `\n          var zero_point_abs_offset = col * ${components} * ((${nBlocksPerCol} + 1) / 2);\n          var zero_point_index: u32 = zero_point_abs_offset / 4;\n          var zero_point_word: u32 = ${zeroPoints.getByOffset(\"zero_point_index\")};\n          var zero_point_offset: u32 = (zero_point_abs_offset % 4) * 8;` : \"\"}\n          var scale_index = col * ${nBlocksPerCol * components};\n          var b_indices: ${b.type.indices};\n          for (var c: u32 = 0; c < ${components}; c++) {\n            ${b.indicesSet(\"b_indices\", \"0\", `col * ${components} + c`)};\n            var block_offset: u32 = 0;\n            for (var block: u32 = 0; block < ${nBlocksPerCol}; block++) {\n              // The scale and zero points are computed per block.\n              let scale = ${scales.getByOffset(\"scale_index\")};\n              // The default zero point is 8 for unsigned 4-bit quantization.\n              let zero_point = ${dataType2}(${zeroPoints ? \"extractBits(zero_point_word, zero_point_offset, 4)\" : 8});\n              ${b.indicesSet(\"b_indices\", \"1\", \"block\")};\n              var word_offset: u32 = block_offset;\n              ${processOneBlock}\n              scale_index++;\n              ${updateZeroPointIndex}\n              block_offset += uniforms.block_size / ${aComponents};\n            }\n            // Drop the trailing 4 bits if the zero_poit_offset is not a byte boundary to align with the next byte.\n            ${zeroPoints ? `if (zero_point_offset % 8 > 0) {\n                ${updateZeroPointIndex}\n              }` : \"\"}\n            }\n            for (var k: u32 = 0u; k < ${outputNumber}u; k++) {\n              ${output.indicesSet(\"output_indices\", outputRank - 2, `${outputNumber} * row + k`)};\n              ${output.setByIndices(\"output_indices\", \"output_values[k]\")}\n            }\n        }`;\n        };\n        return {\n          name: useBlockwiseMatMulNBits ? \"BlockwiseMatMulNBits\" : \"MatMulNBits\",\n          shaderCache: {\n            hint: `${attributes.cacheKey};${dimAOuter};${dataType};${inputs.length}`,\n            inputDependencies: Array(inputs.length).fill(\"rank\")\n          },\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType }],\n            name: useBlockwiseMatMulNBits ? \"BlockwiseMatMulNBits\" : \"MatMulNBits\",\n            dispatchGroup: useBlockwiseMatMulNBits ? { x: 1, y: Math.ceil(dimBOuter / components), z: batchSize } : { x: Math.ceil(\n              outputSize / 64\n              /* workgroup size */\n            ) },\n            programUniforms\n          }),\n          getShaderSource\n        };\n      };\n      matMulNBits = (context, attributes) => {\n        validateInputs17(context.inputs, attributes);\n        const maxComputeWorkgroupSizes = context.getMaxComputeWorkgroupSizes();\n        const maxComputeWorkgroupStorageSize = context.getMaxComputeWorkgroupStoragesize();\n        context.compute(createMatMulNBitsProgramInfo(\n          context.inputs,\n          attributes,\n          maxComputeWorkgroupSizes,\n          maxComputeWorkgroupStorageSize\n        ));\n      };\n      parseMatMulNBitsAttributes = (attributes) => createAttributeWithCacheKey(attributes);\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/multihead-attentiion.ts\n  var getInput, validateInputs18, parseMultiHeadAttentionAttributes, weightTransposeAttribute2, addBiasTranspose, maybeTransposeToBNSHAndAddBias, multiHeadAttention;\n  var init_multihead_attentiion = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/multihead-attentiion.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_attribute_with_cache_key();\n      init_types();\n      init_attention();\n      init_common();\n      init_transpose();\n      getInput = (inputs, i) => inputs.length > i && inputs[i].dims.length > 0 && ShapeUtil.size(inputs[i].dims) > 0 ? inputs[i] : void 0;\n      validateInputs18 = (inputs, attributes) => {\n        const query = inputs[0];\n        const key = getInput(inputs, 1);\n        const value = getInput(inputs, 2);\n        const bias = getInput(inputs, 3);\n        const keyPaddingMask = getInput(inputs, 4);\n        const relativePositionBias = getInput(inputs, 5);\n        const pastKey = getInput(inputs, 6);\n        const pastValue = getInput(inputs, 7);\n        if (query.dims.length !== 3 && query.dims.length !== 5) {\n          throw new Error(\"Input query is expected to have 3 or 5 dimensions\");\n        }\n        const dmmhaPacking = false;\n        const batchSize = query.dims[0];\n        const sequenceLength = query.dims[1];\n        const hiddenSize = query.dims.length === 3 ? dmmhaPacking ? query.dims[2] / 3 : query.dims[2] : attributes.numHeads * query.dims[4];\n        let kvSequenceLength = sequenceLength;\n        let pastSequenceLength = 0;\n        let maxSequenceLength = 0;\n        const headSize = Math.floor(hiddenSize / attributes.numHeads);\n        if (pastKey && pastValue) {\n          if (pastKey.dims.length !== 4) {\n            throw new Error('Input \"past_key\" is expected to have 4 dimensions');\n          }\n          if (pastKey.dims[0] !== batchSize || pastKey.dims[1] !== attributes.numHeads || pastKey.dims[3] !== headSize) {\n            throw new Error('Input \"past_key\" shape (batch_size, num_heads, past_sequence_length, head_size)');\n          }\n          if (pastValue.dims[0] !== batchSize || pastValue.dims[1] !== attributes.numHeads || pastValue.dims[3] !== headSize) {\n            throw new Error('Input \"past_value\" shape (batch_size, num_heads, past_sequence_length, head_size)');\n          }\n          if (pastKey.dims[2] !== pastValue.dims[2]) {\n            throw new Error('Input \"past_key\" and \"past_value\" shall have same dim 2 (past_sequence_length)');\n          }\n          if (pastValue.dims.length !== 4) {\n            throw new Error('Input \"past_value\" is expected to have 4 dimensions');\n          }\n          pastSequenceLength = pastKey.dims[2];\n          maxSequenceLength = pastKey.dims[2];\n        } else if (pastKey || pastValue) {\n          throw new Error('Input \"past_key\" and \"past_value\" shall be both present or both absent');\n        }\n        let qkvFormat;\n        if (key) {\n          if (query.dims.length !== 3) {\n            throw new Error('Input \"query\" is expected to have 3 dimensions when key is given');\n          }\n          if (key.dims.length < 3 || key.dims.length > 5) {\n            throw new Error('Input \"key\" is expected to have 3, 4, or 5 dimensions');\n          }\n          if (query.dims[0] !== key.dims[0]) {\n            throw new Error('Input \"query\" and \"key\" shall have same dim 0 (batch size)');\n          }\n          if (key.dims.length === 3) {\n            if (key.dims[2] !== query.dims[2]) {\n              throw new Error('Input \"query\" and \"key\" shall have same dim 2 (hidden_size)');\n            }\n            qkvFormat = 2 /* qkvBSNH */;\n            kvSequenceLength = key.dims[1];\n          } else if (key.dims.length === 5) {\n            if (key.dims[2] !== attributes.numHeads || key.dims[3] !== 2 || key.dims[4] !== headSize) {\n              throw new Error('Expect \"key\" shape (batch_size, kv_sequence_length, num_heads, 2, head_size) for packed kv');\n            }\n            if (value) {\n              throw new Error('Expect \"value\" be none when \"key\" has packed kv format.');\n            }\n            qkvFormat = 5 /* qKvBSNHxBSN2H */;\n            kvSequenceLength = key.dims[1];\n          } else {\n            if (key.dims[1] !== attributes.numHeads || key.dims[3] !== headSize) {\n              throw new Error('Expect \"key\" shape (batch_size, num_heads, kv_sequence_length, head_size) for past_key');\n            }\n            qkvFormat = 0 /* unknown */;\n            kvSequenceLength = key.dims[2];\n          }\n        } else {\n          if (query.dims.length !== 3 && query.dims.length !== 5) {\n            throw new Error('Input \"query\" is expected to have 3 or 5 dimensions when key is empty');\n          }\n          if (query.dims.length === 5 && (query.dims[2] !== attributes.numHeads || query.dims[3] !== 3)) {\n            throw new Error('Expect \"query\" shape (batch_size, kv_sequence_length, num_heads, 3, head_size) for packed kv');\n          }\n          qkvFormat = 3 /* qkvBSN3H */;\n        }\n        if (bias) {\n          if (bias.dims.length !== 1) {\n            throw new Error('Input \"bias\" is expected to have 1 dimension');\n          }\n          if (value) {\n            if (query.dims.length === 5 && query.dims[3] === 2) {\n              throw new Error(\"bias is not allowed for packed kv.\");\n            }\n          }\n        }\n        let maskType = 0 /* none */;\n        if (keyPaddingMask) {\n          maskType = 8 /* maskUnknown */;\n          const maskDims = keyPaddingMask.dims;\n          if (maskDims.length === 1) {\n            if (maskDims[0] === batchSize) {\n              maskType = 1 /* mask1dKeySeqLen */;\n            } else if (maskDims[0] === 3 * batchSize + 2) {\n              maskType = 3 /* mask1DKeySeqLenStart */;\n            }\n          } else if (maskDims.length === 2 && maskDims[0] === batchSize && maskDims[1] === kvSequenceLength) {\n            maskType = 5 /* mask2dKeyPadding */;\n          }\n          if (maskType === 8 /* maskUnknown */) {\n            throw new Error('Input \"key_padding_mask\" shape shall be (batch_size) or (batch_size, kv_sequence_length)');\n          }\n          throw new Error(\"Mask not supported\");\n        }\n        let passPastInKv = false;\n        let vHiddenSize = hiddenSize;\n        if (value) {\n          if (value.dims.length !== 3 && value.dims.length !== 4) {\n            throw new Error('Input \"value\" is expected to have 3 or 4 dimensions');\n          }\n          if (query.dims[0] !== value.dims[0]) {\n            throw new Error('Input \"query\" and \"value\" shall have same dim 0 (batch_size)');\n          }\n          if (value.dims.length === 3) {\n            if (kvSequenceLength !== value.dims[1]) {\n              throw new Error('Input \"key\" and \"value\" shall have the same dim 1 (kv_sequence_length)');\n            }\n            vHiddenSize = value.dims[2];\n          } else {\n            if (kvSequenceLength !== value.dims[2]) {\n              throw new Error('Input \"past_key\" and \"past_value\" shall have the same dim 2 (kv_sequence_length)');\n            }\n            vHiddenSize = value.dims[1] * value.dims[3];\n            passPastInKv = true;\n          }\n        }\n        const totalSequenceLength = pastSequenceLength + kvSequenceLength;\n        const broadcastResPosBias = false;\n        if (keyPaddingMask) {\n          throw new Error(\"Key padding mask is not supported\");\n        }\n        if (relativePositionBias) {\n          if (relativePositionBias.dims.length !== 4) {\n            throw new Error('Input \"relative_position_bias\" is expected to have 4 dimensions');\n          }\n          if (relativePositionBias.dims[0] !== batchSize && relativePositionBias.dims[0] !== 1 || relativePositionBias.dims[1] !== attributes.numHeads || relativePositionBias.dims[2] !== sequenceLength || relativePositionBias.dims[3] !== totalSequenceLength) {\n            throw new Error('Input \"relative_position_bias\" shape (batch_size, 1, sequence_length, kv_sequence_length)');\n          }\n        }\n        return {\n          batchSize,\n          sequenceLength,\n          pastSequenceLength,\n          kvSequenceLength,\n          totalSequenceLength,\n          maxSequenceLength,\n          inputHiddenSize: 0,\n          hiddenSize,\n          vHiddenSize,\n          headSize,\n          vHeadSize: Math.floor(vHiddenSize / attributes.numHeads),\n          numHeads: attributes.numHeads,\n          isUnidirectional: false,\n          pastPresentShareBuffer: false,\n          maskFilterValue: attributes.maskFilterValue,\n          maskType,\n          scale: attributes.scale,\n          broadcastResPosBias,\n          passPastInKv,\n          qkvFormat\n        };\n      };\n      parseMultiHeadAttentionAttributes = (attributes) => createAttributeWithCacheKey({ ...attributes });\n      weightTransposeAttribute2 = createAttributeWithCacheKey({ perm: [0, 2, 1, 3] });\n      addBiasTranspose = (context, qkv, bias, batchSize, sequenceLength, hiddenSize, biasOffset) => {\n        const outputShape = [batchSize, sequenceLength, hiddenSize];\n        const outputSize = ShapeUtil.size(outputShape);\n        const programUniforms = [\n          { type: 12 /* uint32 */, data: outputSize },\n          { type: 12 /* uint32 */, data: biasOffset },\n          { type: 12 /* uint32 */, data: hiddenSize }\n        ];\n        const getShaderSource = (shaderHelper) => {\n          const output = outputVariable(\"qkv_with_bias\", qkv.dataType, outputShape);\n          const qkvInput = inputVariable(\"qkv\", qkv.dataType, outputShape);\n          const biasInput = inputVariable(\"bias\", bias.dataType, outputShape);\n          const uniforms = [\n            { name: \"output_size\", type: \"u32\" },\n            { name: \"bias_offset\", type: \"u32\" },\n            { name: \"hidden_size\", type: \"u32\" }\n          ];\n          return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(qkvInput, biasInput, output)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.output_size\")}\n    let bias_offset_idx = (global_idx % uniforms.hidden_size) + uniforms.bias_offset;\n\n    qkv_with_bias[global_idx] = qkv[global_idx] + bias[bias_offset_idx];\n  }`;\n        };\n        return context.compute(\n          {\n            name: \"MultiHeadAttentionAddBias\",\n            shaderCache: { inputDependencies: [\"type\", \"type\"] },\n            getRunData: () => ({\n              outputs: [{ dims: outputShape, dataType: qkv.dataType, gpuDataType: 0 /* default */ }],\n              dispatchGroup: { x: Math.ceil(\n                outputSize / 64\n                /* workgroup size */\n              ) },\n              programUniforms\n            }),\n            getShaderSource\n          },\n          { inputs: [qkv, bias], outputs: [-1] }\n        )[0];\n      };\n      maybeTransposeToBNSHAndAddBias = (context, batchSize, numHeads, sequenceLength, headSize, input, bias, biasOffset) => {\n        let reshapedInput = input;\n        if (!bias) {\n          if (input.dims.length === 3) {\n            reshapedInput = input.reshape([batchSize, sequenceLength, numHeads, headSize]);\n          }\n          return context.compute(\n            createTransposeProgramInfo(reshapedInput, weightTransposeAttribute2.perm),\n            { inputs: [reshapedInput], outputs: [-1] }\n          )[0];\n        } else {\n          if (sequenceLength === 1) {\n            throw new Error(\"AddBiasReshape is not implemented. Please export your model with packed QKV or KV\");\n          } else {\n            reshapedInput = addBiasTranspose(context, input, bias, batchSize, sequenceLength, numHeads * headSize, biasOffset);\n            reshapedInput = reshapedInput.reshape([batchSize, sequenceLength, numHeads, headSize]);\n            return context.compute(\n              createTransposeProgramInfo(reshapedInput, weightTransposeAttribute2.perm),\n              { inputs: [reshapedInput], outputs: [-1] }\n            )[0];\n          }\n        }\n      };\n      multiHeadAttention = (context, attributes) => {\n        const params = validateInputs18(context.inputs, attributes);\n        const query = context.inputs[0];\n        const key = getInput(context.inputs, 1);\n        const value = getInput(context.inputs, 2);\n        const bias = getInput(context.inputs, 3);\n        const keyPaddingMask = getInput(context.inputs, 4);\n        const relativePositionBias = getInput(context.inputs, 5);\n        const pastKey = getInput(context.inputs, 6);\n        const pastValue = getInput(context.inputs, 7);\n        if (query.dims.length === 5) {\n          throw new Error(\"Packed QKV is not implemented\");\n        }\n        if (key?.dims.length === 5) {\n          throw new Error(\"Packed KV is not implemented\");\n        }\n        const kvBNSH = key && value && key.dims.length === 4 && value.dims.length === 4;\n        const Q = maybeTransposeToBNSHAndAddBias(\n          context,\n          params.batchSize,\n          params.numHeads,\n          params.sequenceLength,\n          params.headSize,\n          query,\n          bias,\n          0\n        );\n        if (kvBNSH) {\n          return applyAttention(\n            context,\n            Q,\n            key,\n            value,\n            keyPaddingMask,\n            void 0,\n            pastKey,\n            pastValue,\n            relativePositionBias,\n            params,\n            attributes\n          );\n        }\n        if (!key || !value) {\n          throw new Error(\"key and value must be provided\");\n        }\n        const K = maybeTransposeToBNSHAndAddBias(\n          context,\n          params.batchSize,\n          params.numHeads,\n          params.kvSequenceLength,\n          params.headSize,\n          key,\n          bias,\n          params.hiddenSize\n        );\n        const V = maybeTransposeToBNSHAndAddBias(\n          context,\n          params.batchSize,\n          params.numHeads,\n          params.kvSequenceLength,\n          params.vHeadSize,\n          value,\n          bias,\n          2 * params.hiddenSize\n        );\n        applyAttention(\n          context,\n          Q,\n          K,\n          V,\n          keyPaddingMask,\n          void 0,\n          pastKey,\n          pastValue,\n          relativePositionBias,\n          params,\n          attributes\n        );\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/pad.ts\n  var validateInputs19, getPadConstant, getPadReflect, getPadEdge, getPadWrap, getPadSnippet, createPadProgramInfo, createPadAttributesFromInputs, pad;\n  var init_pad = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/pad.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_common();\n      validateInputs19 = (inputs) => {\n        if (!inputs || inputs.length < 1) {\n          throw new Error(\"Too few inputs\");\n        }\n        if (inputs[0].dataType !== 1 /* float */ && inputs[0].dataType !== 10 /* float16 */) {\n          throw new Error(\"Input type must be float or float16.\");\n        }\n        if (inputs.length >= 2) {\n          let validPads = inputs[0].dims.length * 2 === inputs[1].dims[0];\n          if (inputs.length === 4) {\n            validPads = inputs[3].dims[0] * 2 === inputs[1].dims[0];\n          }\n          if (!validPads) {\n            throw new Error(\"The pads should be a 1D tensor of shape [2 * input_rank] or [2 * num_axes].\");\n          }\n        }\n      };\n      getPadConstant = (output, inputRank, padsLength) => {\n        let block = \"\";\n        for (let i = inputRank - 1; i >= 0; --i) {\n          block += `\n            k = i32(${output.indicesGet(\"indices\", i)}) - ${getElementAt(\"uniforms.pads\", i, padsLength)};\n            if (k < 0) {\n              break;\n            }\n            if (k >= i32(${getElementAt(\"uniforms.x_shape\", i, inputRank)})) {\n              break;\n            }\n            offset += k * i32(${getElementAt(\"uniforms.x_strides\", i, inputRank)});\n        `;\n        }\n        return `\n          value = ${output.type.value}(uniforms.constant_value);\n          for (var i = 0; i < 1; i++) {\n            var offset = 0;\n            var k = 0;\n            ${block}\n            value = x[offset];\n          }\n      `;\n      };\n      getPadReflect = (output, inputRank, padsLength) => {\n        let block = \"\";\n        for (let i = inputRank - 1; i >= 0; --i) {\n          block += `\n                k = i32(${output.indicesGet(\"indices\", i)}) - ${getElementAt(\"uniforms.pads\", i, padsLength)};\n                if (k < 0) {\n                  k = -k;\n                }\n                {\n                  let _2n_1 = 2 * (i32(${getElementAt(\"uniforms.x_shape\", i, inputRank)}) - 1);\n                  k = k % _2n_1;\n                  if(k >= i32(${getElementAt(\"uniforms.x_shape\", i, inputRank)})) {\n                    k = _2n_1 - k;\n                  }\n                }\n                offset += k * i32(${getElementAt(\"uniforms.x_strides\", i, inputRank)});\n            `;\n        }\n        return `\n              var offset = 0;\n              var k = 0;\n              ${block}\n              value = x[offset];\n          `;\n      };\n      getPadEdge = (output, inputRank, padsLength) => {\n        let block = \"\";\n        for (let i = inputRank - 1; i >= 0; --i) {\n          block += `\n                k = i32(${output.indicesGet(\"indices\", i)}) - ${getElementAt(\"uniforms.pads\", i, padsLength)};\n                if (k < 0) {\n                  k = 0;\n                }\n                if (k >= i32(${getElementAt(\"uniforms.x_shape\", i, inputRank)})) {\n                  k = i32(${getElementAt(\"uniforms.x_shape\", i, inputRank)}) - 1;\n                }\n                offset += k * i32(${getElementAt(\"uniforms.x_strides\", i, inputRank)});\n            `;\n        }\n        return `\n              var offset = 0;\n              var k = 0;\n              ${block}\n              value = x[offset];\n          `;\n      };\n      getPadWrap = (output, inputRank, padsLength) => {\n        let block = \"\";\n        for (let i = inputRank - 1; i >= 0; --i) {\n          block += `\n                k = i32(${output.indicesGet(\"indices\", i)}) - ${getElementAt(\"uniforms.pads\", i, padsLength)};\n                if (k < 0)  {\n                  k += i32(${getElementAt(\"uniforms.x_shape\", i, inputRank)}]);\n                }\n                if (k >= i32(${getElementAt(\"uniforms.x_shape\", i, inputRank)})) {\n                  k -= i32(${getElementAt(\"uniforms.x_shape\", i, inputRank)});\n                }\n                offset += k * i32(${getElementAt(\"uniforms.x_strides\", i, inputRank)});\n            `;\n        }\n        return `\n              var offset = 0;\n              var k = 0;\n              ${block}\n              value = x[offset];\n          `;\n      };\n      getPadSnippet = (output, inputRank, attributes) => {\n        switch (attributes.mode) {\n          case 0:\n            return getPadConstant(output, inputRank, attributes.pads.length);\n          case 1:\n            return getPadReflect(output, inputRank, attributes.pads.length);\n          case 2:\n            return getPadEdge(output, inputRank, attributes.pads.length);\n          case 3:\n            return getPadWrap(output, inputRank, attributes.pads.length);\n          default:\n            throw new Error(\"Invalid mode\");\n        }\n      };\n      createPadProgramInfo = (inputs, attributes) => {\n        const outputShape = ShapeUtil.padShape(inputs[0].dims.slice(), attributes.pads);\n        const inputDims = inputs[0].dims;\n        const outputSize = ShapeUtil.size(outputShape);\n        const programUniforms = [{ type: 12 /* uint32 */, data: outputSize }, { type: 6 /* int32 */, data: attributes.pads }];\n        if (attributes.mode === 0) {\n          programUniforms.push({ type: inputs[0].dataType, data: attributes.value });\n        }\n        programUniforms.push(...createTensorShapeVariables(inputs[0].dims, outputShape));\n        const inputDependencies = [\"rank\"];\n        const getShaderSource = (shaderHelper) => {\n          const output = outputVariable(\"output\", inputs[0].dataType, outputShape.length);\n          const input = inputVariable(\"x\", inputs[0].dataType, inputDims.length);\n          const dataType = input.type.value;\n          const padSnippet = getPadSnippet(output, inputDims.length, attributes);\n          const uniforms = [{ name: \"output_size\", type: \"u32\" }, { name: \"pads\", type: \"i32\", length: attributes.pads.length }];\n          if (attributes.mode === 0) {\n            uniforms.push({ name: \"constant_value\", type: dataType });\n          }\n          return `\n            ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)}\n            ${shaderHelper.mainStart()}\n            ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.output_size\")}\n\n            let indices = ${output.offsetToIndices(\"global_idx\")};\n\n            var value = ${dataType}(0);\n            ${padSnippet}\n            output[global_idx] = value;\n        }`;\n        };\n        return {\n          name: \"Pad\",\n          shaderCache: { hint: `${attributes.mode}`, inputDependencies },\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n            dispatchGroup: { x: Math.ceil(\n              ShapeUtil.size(outputShape) / 64\n              /* workgroup size */\n            ) },\n            programUniforms\n          }),\n          getShaderSource\n        };\n      };\n      createPadAttributesFromInputs = (inputs, attributes) => {\n        if (inputs.length > 1) {\n          const bigInt64Pads = inputs[1].getBigInt64Array();\n          const value = inputs.length >= 3 && inputs[2].data ? inputs[2].getFloat32Array()[0] : 0;\n          const inputRank = inputs[0].dims.length;\n          const updatePads = new Int32Array(2 * inputRank).fill(0);\n          if (inputs.length >= 4) {\n            const axes = inputs[3].getBigInt64Array();\n            for (let i = 0; i < axes.length; i++) {\n              updatePads[Number(axes[i])] = Number(bigInt64Pads[i]);\n              updatePads[Number(axes[i]) + inputRank] = Number(bigInt64Pads[i + axes.length]);\n            }\n          } else {\n            bigInt64Pads.forEach((v, i) => updatePads[Number(i)] = Number(v));\n          }\n          const pads = [];\n          updatePads.forEach((v) => pads.push(v));\n          return { mode: attributes.mode, value, pads };\n        } else {\n          return attributes;\n        }\n      };\n      pad = (context, attributes) => {\n        validateInputs19(context.inputs);\n        const updatedAttributes = createPadAttributesFromInputs(context.inputs, attributes);\n        context.compute(createPadProgramInfo(context.inputs, updatedAttributes), { inputs: [0] });\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/pool.ts\n  var validateInputs20, getAdjustedPoolAttributesAndOutputShape, getUniformAndPadInfo, generatePoolingCode, createShaderKeyFromAttributes, createAveragePoolShaderKeyFromAttributes, createMaxPoolShaderKeyFromAttributes, parsePoolCommonAttributes, createAveragePoolProgramInfo, parseAveragePoolAttributes, averagePool, globalPoolAttributes, parseGlobalAveragePoolAttributes, globalAveragePool, createMaxPoolProgramInfo, maxPool, parseMaxPoolAttributes, parseGlobalMaxPoolAttributes, globalMaxPool;\n  var init_pool = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/pool.ts\"() {\n      \"use strict\";\n      init_esm();\n      init_wasm_common();\n      init_util();\n      init_common();\n      validateInputs20 = (inputs) => {\n        if (env2.webgpu.validateInputContent && (!inputs || inputs.length !== 1)) {\n          throw new Error(\"Pool ops requires 1 input.\");\n        }\n      };\n      getAdjustedPoolAttributesAndOutputShape = (input, attributes, isGlobalOperator) => {\n        const isChannelsLast = attributes.format === \"NHWC\";\n        const inputShapeAsChannelFirst = input.dims.slice();\n        if (isChannelsLast) {\n          inputShapeAsChannelFirst.splice(1, 0, inputShapeAsChannelFirst.pop());\n        }\n        const hasDilations = Object.hasOwnProperty.call(attributes, \"dilations\");\n        const kernelShape = attributes.kernelShape.slice();\n        const strides = attributes.strides.slice();\n        const dilations = hasDilations ? attributes.dilations.slice() : [];\n        const pads = attributes.pads.slice();\n        PoolConvUtil.adjustPoolAttributes(isGlobalOperator, inputShapeAsChannelFirst, kernelShape, strides, dilations, pads);\n        const outputShapeAsChannelFirst = PoolConvUtil.computePoolOutputShape(\n          isGlobalOperator,\n          inputShapeAsChannelFirst,\n          strides,\n          dilations,\n          kernelShape,\n          pads,\n          attributes.autoPad\n        );\n        const newAttributes = Object.assign({}, attributes);\n        if (hasDilations) {\n          Object.assign(newAttributes, { kernelShape, strides, pads, dilations, cacheKey: attributes.cacheKey });\n        } else {\n          Object.assign(newAttributes, { kernelShape, strides, pads, cacheKey: attributes.cacheKey });\n        }\n        const outputShapeAsChannelLast = outputShapeAsChannelFirst.slice();\n        outputShapeAsChannelLast.push(outputShapeAsChannelLast.splice(1, 1)[0]);\n        return [newAttributes, isChannelsLast ? outputShapeAsChannelLast : outputShapeAsChannelFirst];\n      };\n      getUniformAndPadInfo = (outputShape, attributes) => {\n        const isChannelsLast = attributes.format === \"NHWC\";\n        const outputSize = ShapeUtil.size(outputShape);\n        const kernelSize = ShapeUtil.size(attributes.kernelShape);\n        const programUniforms = [{ type: 12 /* uint32 */, data: outputSize }, { type: 12 /* uint32 */, data: kernelSize }];\n        const uniforms = [{ name: \"outputSize\", type: \"u32\" }, { name: \"kernelSize\", type: \"u32\" }];\n        if (attributes.kernelShape.length <= 2) {\n          const kw = attributes.kernelShape[attributes.kernelShape.length - 1];\n          const sw = attributes.strides[attributes.strides.length - 1];\n          const pwStart = attributes.pads[attributes.pads.length / 2 - 1];\n          const pwEnd = attributes.pads[attributes.pads.length - 1];\n          const pwStartEndNotZero = !!(pwStart + pwEnd);\n          programUniforms.push(\n            { type: 12 /* uint32 */, data: kw },\n            { type: 12 /* uint32 */, data: sw },\n            { type: 12 /* uint32 */, data: pwStart },\n            { type: 12 /* uint32 */, data: pwEnd }\n          );\n          uniforms.push(\n            { name: \"kw\", type: \"u32\" },\n            { name: \"sw\", type: \"u32\" },\n            { name: \"pwStart\", type: \"u32\" },\n            { name: \"pwEnd\", type: \"u32\" }\n          );\n          let phStartEndNotZero = false;\n          if (attributes.kernelShape.length === 2) {\n            const kh = attributes.kernelShape[attributes.kernelShape.length - 2];\n            const sh = attributes.strides[attributes.strides.length - 2];\n            const phStart = attributes.pads[attributes.pads.length / 2 - 2];\n            const phEnd = attributes.pads[attributes.pads.length - 2];\n            phStartEndNotZero = !!(phStart + phEnd);\n            programUniforms.push(\n              { type: 12 /* uint32 */, data: kh },\n              { type: 12 /* uint32 */, data: sh },\n              { type: 12 /* uint32 */, data: phStart },\n              { type: 12 /* uint32 */, data: phEnd }\n            );\n            uniforms.push(\n              { name: \"kh\", type: \"u32\" },\n              { name: \"sh\", type: \"u32\" },\n              { name: \"phStart\", type: \"u32\" },\n              { name: \"phEnd\", type: \"u32\" }\n            );\n          }\n          return [programUniforms, uniforms, true, pwStartEndNotZero, phStartEndNotZero];\n        } else {\n          if (isChannelsLast) {\n            throw new Error(\"Pooling with kernelShape.length > 2 is not supported for NHWC format.\");\n          }\n          const kernelStrides = ShapeUtil.computeStrides(attributes.kernelShape);\n          programUniforms.push(\n            { type: 12 /* uint32 */, data: kernelStrides },\n            { type: 12 /* uint32 */, data: attributes.pads },\n            { type: 12 /* uint32 */, data: attributes.strides }\n          );\n          uniforms.push(\n            { name: \"kernelStrides\", type: \"u32\", length: kernelStrides.length },\n            { name: \"pads\", type: \"u32\", length: attributes.pads.length },\n            { name: \"strides\", type: \"u32\", length: attributes.strides.length }\n          );\n          const hasPads = attributes.pads.reduce((sum, cur) => sum + cur);\n          return [programUniforms, uniforms, !!hasPads, false, false];\n        }\n      };\n      generatePoolingCode = (shaderHelper, x, rank, outputShapeRank, attributes, op1, op2, start, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero) => {\n        const isChannelsLast = attributes.format === \"NHWC\";\n        const dataType = x.type.value;\n        const output = outputVariable(\"output\", x.type.tensor, outputShapeRank);\n        if (attributes.kernelShape.length <= 2) {\n          let codeW = \"\";\n          let codeH = \"\";\n          let codeHEnd = \"\";\n          const dimIdxW = rank - (isChannelsLast ? 2 : 1);\n          if (pwStartEndNotZero) {\n            codeW = `\n                for (var i: u32 = 0u; i < uniforms.kw; i++) {\n                  xIndices[${dimIdxW}] = indices[${dimIdxW}] * uniforms.sw - uniforms.pwStart + i;\n                  if (xIndices[${dimIdxW}] < 0 || xIndices[${dimIdxW}]\n                      >= uniforms.x_shape[${dimIdxW}]) {\n                    pad++;\n                    continue;\n                  }\n                  let x_val = x[${x.indicesToOffset(\"xIndices\")}];\n                  ${op1}\n                }`;\n          } else {\n            codeW = `\n                for (var i: u32 = 0u; i < uniforms.kw; i++) {\n                  xIndices[${dimIdxW}] = indices[${dimIdxW}] * uniforms.sw - uniforms.pwStart + i;\n                  let x_val = x[${x.indicesToOffset(\"xIndices\")}];\n                  ${op1}\n                }`;\n          }\n          if (attributes.kernelShape.length === 2) {\n            const dimIdxH = rank - (isChannelsLast ? 3 : 2);\n            if (phStartEndNotZero) {\n              codeH = `\n                for (var j: u32 = 0u; j < uniforms.kh; j++) {\n                  xIndices[${dimIdxH}] = indices[${dimIdxH}] * uniforms.sh - uniforms.phStart + j;\n                  if (xIndices[${dimIdxH}] < 0 || xIndices[${dimIdxH}] >= uniforms.x_shape[${dimIdxH}]) {\n                    pad += i32(uniforms.kw);\n                    continue;\n                  }\n              `;\n            } else {\n              codeH = `\n                for (var j: u32 = 0u; j < uniforms.kh; j++) {\n                  xIndices[${dimIdxH}] = indices[${dimIdxH}] * uniforms.sh - uniforms.phStart + j;\n                `;\n            }\n            codeHEnd = `\n              }\n            `;\n          }\n          const poolingCode = `\n            ${shaderHelper.registerUniforms(uniforms).declareVariables(x, output)}\n\n            ${shaderHelper.mainStart()}\n              ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.outputSize\")}\n\n              let indices = ${output.offsetToIndices(\"global_idx\")};\n              var xIndices = ${output.offsetToIndices(\"global_idx\")};\n\n              var value = ${dataType}(${start});\n              var pad = 0;\n              ${codeH}\n              ${codeW}\n              ${codeHEnd}\n              ${op2}\n\n              output[global_idx] = value;\n            }`;\n          return poolingCode;\n        } else {\n          if (isChannelsLast) {\n            throw new Error(\"Pooling with kernelShape.length > 2 is not supported for NHWC format.\");\n          }\n          const stridesRank = attributes.kernelShape.length;\n          const padsRank = attributes.pads.length;\n          let padCode = \"\";\n          if (hasPads) {\n            padCode = `\n                if (xIndices[j] >= uniforms.x_shape[j]) {\n                  pad++;\n                  isPad = true;\n                  break;\n                }\n              }\n              if (!isPad) {\n                let x_val = x[${x.indicesToOffset(\"xIndices\")}];\n                ${op1}\n              }`;\n          } else {\n            padCode = `\n              }\n              let x_val = x[${x.indicesToOffset(\"xIndices\")}];\n              ${op1}\n            `;\n          }\n          const poolingCode = `\n            ${shaderHelper.registerUniforms(uniforms).declareVariables(x, output)}\n\n            ${shaderHelper.mainStart()}\n              ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.outputSize\")}\n              let indices = ${output.offsetToIndices(\"global_idx\")};\n              var xIndices = ${output.offsetToIndices(\"global_idx\")};\n\n              var offsets: array<u32, ${stridesRank}>;\n\n              var value = ${dataType}(${start});\n              var pad = 0;\n              var isPad = false;\n\n              for (var i: u32 = 0u; i < uniforms.kernelSize; i++) {\n                var offset = i;\n                for (var j = 0u; j < ${stridesRank - 1}u; j++) {\n                  offsets[j] = offset / ${getElementAt(\"uniforms.kernelStrides\", \"j\", stridesRank)};\n                  offset -= offsets[j] * ${getElementAt(\"uniforms.kernelStrides\", \"j\", stridesRank)};\n                }\n                offsets[${stridesRank - 1}] = offset;\n\n                isPad = false;\n                for (var j = ${rank - stridesRank}u; j < ${rank}u; j++) {\n                  xIndices[j] = indices[j] * ${getElementAt(\"uniforms.strides\", `j - ${rank - stridesRank}u`, stridesRank)}\n                    + offsets[j - ${rank - stridesRank}u] - ${getElementAt(\"uniforms.pads\", \"j - 2u\", padsRank)};\n                  ${padCode}\n              }\n              ${op2}\n\n              output[global_idx] = value;\n            }`;\n          return poolingCode;\n        }\n      };\n      createShaderKeyFromAttributes = (attributes) => `${attributes.format};${attributes.ceilMode};${attributes.autoPad};${attributes.kernelShape.length}`;\n      createAveragePoolShaderKeyFromAttributes = (attributes) => `${createShaderKeyFromAttributes(attributes)};${attributes.countIncludePad}`;\n      createMaxPoolShaderKeyFromAttributes = (attributes) => `${createShaderKeyFromAttributes(attributes)};${attributes.storageOrder};${attributes.dilations}`;\n      parsePoolCommonAttributes = (attributes) => ({\n        format: attributes.format,\n        autoPad: [\"NOTSET\", \"VALID\", \"SAME_UPPER\", \"SAME_LOWER\"][attributes.auto_pad],\n        ceilMode: attributes.ceil_mode,\n        kernelShape: attributes.kernel_shape,\n        strides: attributes.strides,\n        pads: attributes.pads\n      });\n      createAveragePoolProgramInfo = (name, input, isGlobalOperator, attributes) => {\n        const [adjustedAttributes, outputShape] = getAdjustedPoolAttributesAndOutputShape(input, attributes, isGlobalOperator);\n        const x = inputVariable(\"x\", input.dataType, input.dims.length);\n        const dataType = x.type.value;\n        const op1 = \"value += x_val;\";\n        let op2 = \"\";\n        if (adjustedAttributes.countIncludePad) {\n          op2 += `value /= ${dataType}(uniforms.kernelSize);`;\n        } else {\n          op2 += `value /= ${dataType}(i32(uniforms.kernelSize) - pad);`;\n        }\n        const [programUniforms, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero] = getUniformAndPadInfo(outputShape, adjustedAttributes);\n        programUniforms.push(...createTensorShapeVariables(input.dims, outputShape));\n        const inputDependencies = [\"rank\"];\n        return {\n          name,\n          shaderCache: { hint: `${attributes.cacheKey};${hasPads};${pwStartEndNotZero};${phStartEndNotZero}`, inputDependencies },\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: input.dataType }],\n            dispatchGroup: { x: Math.ceil(\n              ShapeUtil.size(outputShape) / 64\n              /* workgroup size */\n            ) },\n            programUniforms\n          }),\n          getShaderSource: (shaderHelper) => generatePoolingCode(\n            shaderHelper,\n            x,\n            input.dims.length,\n            outputShape.length,\n            adjustedAttributes,\n            op1,\n            op2,\n            0,\n            uniforms,\n            hasPads,\n            pwStartEndNotZero,\n            phStartEndNotZero\n          )\n        };\n      };\n      parseAveragePoolAttributes = (attributes) => {\n        const countIncludePad = attributes.count_include_pad === 0 ? false : true;\n        const attr = parsePoolCommonAttributes(attributes);\n        if (attr.ceilMode !== 0) {\n          throw new Error(\"using ceil() in shape computation is not yet supported for AveragePool\");\n        }\n        const averagePoolAttributes = { countIncludePad, ...attr, cacheKey: \"\" };\n        return { ...averagePoolAttributes, cacheKey: createAveragePoolShaderKeyFromAttributes(averagePoolAttributes) };\n      };\n      averagePool = (context, attributes) => {\n        validateInputs20(context.inputs);\n        context.compute(createAveragePoolProgramInfo(\"AveragePool\", context.inputs[0], false, attributes));\n      };\n      globalPoolAttributes = {\n        autoPad: \"\",\n        ceilMode: 0,\n        countIncludePad: false,\n        kernelShape: [],\n        strides: [],\n        pads: [],\n        storageOrder: 0,\n        dilations: []\n      };\n      parseGlobalAveragePoolAttributes = (attributes) => {\n        const format = attributes.format;\n        return { format, ...globalPoolAttributes, cacheKey: format };\n      };\n      globalAveragePool = (context, attributes) => {\n        validateInputs20(context.inputs);\n        context.compute(createAveragePoolProgramInfo(\"GlobalAveragePool\", context.inputs[0], true, attributes));\n      };\n      createMaxPoolProgramInfo = (name, input, isGlobalOperator, attributes) => {\n        const [adjustedAttributes, outputShape] = getAdjustedPoolAttributesAndOutputShape(input, attributes, isGlobalOperator);\n        const op1 = `\n      value = max(x_val, value);\n    `;\n        const op2 = \"\";\n        const x = inputVariable(\"x\", input.dataType, input.dims.length);\n        const inputDependencies = [\"rank\"];\n        const [programUniforms, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero] = getUniformAndPadInfo(outputShape, adjustedAttributes);\n        programUniforms.push(...createTensorShapeVariables(input.dims, outputShape));\n        return {\n          name,\n          shaderCache: { hint: `${attributes.cacheKey};${hasPads};${pwStartEndNotZero};${phStartEndNotZero}`, inputDependencies },\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: input.dataType }],\n            dispatchGroup: { x: Math.ceil(\n              ShapeUtil.size(outputShape) / 64\n              /* workgroup size */\n            ) },\n            programUniforms\n          }),\n          getShaderSource: (shaderHelper) => generatePoolingCode(\n            shaderHelper,\n            x,\n            input.dims.length,\n            outputShape.length,\n            adjustedAttributes,\n            op1,\n            op2,\n            input.dataType === 10 /* float16 */ ? -65504 : -1e5,\n            uniforms,\n            hasPads,\n            pwStartEndNotZero,\n            phStartEndNotZero\n          )\n        };\n      };\n      maxPool = (context, attributes) => {\n        validateInputs20(context.inputs);\n        context.compute(createMaxPoolProgramInfo(\"MaxPool\", context.inputs[0], false, attributes));\n      };\n      parseMaxPoolAttributes = (attributes) => {\n        const storageOrder = attributes.storage_order;\n        const dilations = attributes.dilations;\n        const attr = parsePoolCommonAttributes(attributes);\n        if (storageOrder !== 0) {\n          throw new Error(\"column major storage order is not yet supported for MaxPool\");\n        }\n        if (attr.ceilMode !== 0) {\n          throw new Error(\"using ceil() in shape computation is not yet supported for MaxPool\");\n        }\n        const maxPoolAttributes = { storageOrder, dilations, ...attr, cacheKey: \"\" };\n        return { ...maxPoolAttributes, cacheKey: createMaxPoolShaderKeyFromAttributes(maxPoolAttributes) };\n      };\n      parseGlobalMaxPoolAttributes = (attributes) => {\n        const format = attributes.format;\n        return { format, ...globalPoolAttributes, cacheKey: format };\n      };\n      globalMaxPool = (context, attributes) => {\n        validateInputs20(context.inputs);\n        context.compute(createMaxPoolProgramInfo(\"GlobalMaxPool\", context.inputs[0], true, attributes));\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/range.ts\n  var validateInputsContent, createRangeProgramInfo, range;\n  var init_range = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/range.ts\"() {\n      \"use strict\";\n      init_esm();\n      init_wasm_common();\n      init_common();\n      validateInputsContent = (start, limit, delta) => {\n        const sameStartLimit = start === limit;\n        const increasingRangeNegativeStep = start < limit && delta < 0;\n        const decreasingRangePositiveStep = start > limit && delta > 0;\n        if (sameStartLimit || increasingRangeNegativeStep || decreasingRangePositiveStep) {\n          throw new Error(\"Range these inputs' contents are invalid.\");\n        }\n      };\n      createRangeProgramInfo = (start, limit, delta, dataType) => {\n        const numElements = Math.abs(Math.ceil((limit - start) / delta));\n        const outputShape = [numElements];\n        const outputSize = numElements;\n        const programUniforms = [\n          { type: 12 /* uint32 */, data: outputSize },\n          { type: dataType, data: start },\n          { type: dataType, data: delta },\n          ...createTensorShapeVariables(outputShape)\n        ];\n        const getShaderSource = (shaderHelper) => {\n          const output = outputVariable(\"output\", dataType, outputShape.length);\n          const wgslType = output.type.value;\n          const uniforms = [\n            { name: \"outputSize\", type: \"u32\" },\n            { name: \"start\", type: wgslType },\n            { name: \"delta\", type: wgslType }\n          ];\n          return `\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(output)}\n        ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.outputSize\")}\n        output[global_idx] = uniforms.start + ${wgslType}(global_idx) * uniforms.delta;\n      }`;\n        };\n        return {\n          name: \"Range\",\n          shaderCache: { hint: `${dataType}` },\n          getShaderSource,\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType }],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64\n              /* workgroup size */\n            ) },\n            programUniforms\n          })\n        };\n      };\n      range = (context) => {\n        let start = 0;\n        let limit = 0;\n        let delta = 0;\n        if (context.inputs[0].dataType === 6 /* int32 */) {\n          start = context.inputs[0].getInt32Array()[0];\n          limit = context.inputs[1].getInt32Array()[0];\n          delta = context.inputs[2].getInt32Array()[0];\n        } else if (context.inputs[0].dataType === 1 /* float */) {\n          start = context.inputs[0].getFloat32Array()[0];\n          limit = context.inputs[1].getFloat32Array()[0];\n          delta = context.inputs[2].getFloat32Array()[0];\n        }\n        if (env2.webgpu.validateInputContent) {\n          validateInputsContent(start, limit, delta);\n        }\n        context.compute(createRangeProgramInfo(start, limit, delta, context.inputs[0].dataType), { inputs: [] });\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/resize.ts\n  var validateScales, updateScales, validateInputs21, getOriginalCoordinateFromResizedCoordinate, getNearestPixelFromOriginal, updateRoI, initOutputShape, adjustOutputShape, calculateOriginalIndicesFromOutputIndices, calculateInputIndicesFromOutputIndices, checkInputIndices, setChannelAndBatchIndices, bilinearInterpolation, bicubicInterpolation, trilinearInterpolation, createResizeProgramInfo, getOpsetVersionFromCustomDataBuffer, resize, parseResizeAttributes;\n  var init_resize = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/resize.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_attribute_with_cache_key();\n      init_common();\n      validateScales = (scales, attributes) => {\n        scales.every((value) => value > 0 || (() => {\n          throw new Error(\"Resize requires scales input values to be positive\");\n        }));\n        if (scales.length > 0) {\n          if (attributes.mode === \"linear\") {\n            if (!(scales.length === 2 || scales.length === 3 || scales.length === 4 && scales[0] === 1 && scales[1] === 1 || scales.length === 4 && scales[0] === 1 && scales[3] === 1 || scales.length === 5 && scales[0] === 1 && scales[1] === 1)) {\n              throw new Error(\n                `For linear mode, Resize requires scales to be 2D, 3D, 4D with either two outermost or one innermost and\n            one outermost scale values equal to 1, or 5D with two outermost scale values equal to 1`\n              );\n            }\n          } else if (attributes.mode === \"cubic\") {\n            if (!(scales.length === 2 || scales.length === 4 && scales[0] === 1 && scales[1] === 1 || scales.length === 4 && scales[0] === 1 && scales[3] === 1)) {\n              throw new Error(\"Resize requires scales input size to be 2 or 4 for cubic mode\");\n            }\n          }\n        }\n      };\n      updateScales = (scales, axes, rank) => {\n        axes.every((value) => value >= 0 && value < rank || (() => {\n          throw new Error(\"Resize requires axes input values to be positive and less than rank\");\n        }));\n        const newScales = new Array(rank).fill(1);\n        axes.forEach((value, index) => newScales[value] = scales[index]);\n        return newScales;\n      };\n      validateInputs21 = (inputs, attributes, opsetVersion, scales, sizes, roi) => {\n        const [roiInputIndex, scalesInputIndex, sizesInputIndex] = opsetVersion > 10 ? [1, 2, 3] : [-1, inputs.length > 1 ? 1 : -1, -1];\n        const rank = inputs[0].dims.length;\n        if (roiInputIndex > 0 && inputs.length > roiInputIndex && inputs[roiInputIndex].dims.length > 0) {\n          inputs[roiInputIndex].getFloat32Array().forEach((value) => roi.push(value));\n        } else if (attributes.coordinateTransformMode === \"tf_crop_and_resize\") {\n          throw new Error(\"Resize requires RoI input to be specified when coordinateTransformMode is tfCropAndResize\");\n        }\n        if (scalesInputIndex > 0 && inputs.length > scalesInputIndex && inputs[scalesInputIndex].dims.length > 0) {\n          inputs[scalesInputIndex].getFloat32Array().forEach((value) => scales.push(value));\n          if (scales.length !== 0 && (scales.length !== rank && (opsetVersion >= 18 && scales.length !== attributes.axes.length))) {\n            throw new Error(\n              \"Resize requires scales input size to be same as input rank or axes size for opset 18 and up\"\n            );\n          }\n          validateScales(scales, attributes);\n          if (attributes.axes.length > 0) {\n            updateScales(scales, attributes.axes, rank).forEach((value, index) => scales[index] = value);\n          }\n        }\n        if (sizesInputIndex > 0 && inputs.length > sizesInputIndex) {\n          inputs[sizesInputIndex].getBigInt64Array().forEach((value) => sizes.push(Number(value)));\n          if (sizes.length !== rank || opsetVersion >= 18 && sizes.length === attributes.axes.length) {\n            throw new Error(\"Resize requires sizes input size to be same as input rank or axes size for opset 18 and up\");\n          }\n        }\n        if (attributes.axes.length > 0) {\n          if (scales.length !== attributes.axes.length) {\n            throw new Error('Resize requires \"scales\" input size to be of axes rank when axes attributes is specified');\n          }\n          if (sizes.length !== attributes.axes.length) {\n            throw new Error(\n              'Resize requires \"sizes\" input size to be of rank axes rank when axes attributes is specified'\n            );\n          }\n        }\n        if (typeof scales !== \"undefined\" && typeof sizes !== \"undefined\" && scales.length > 0 && sizes.length > rank) {\n          throw new Error(\"Resize requires only of scales or sizes to be specified\");\n        }\n      };\n      getOriginalCoordinateFromResizedCoordinate = (coordinateTransferMode, dType) => `fn getOriginalCoordinateFromResizedCoordinate(xResized: u32, xScale: f32, lengthResized: u32,\n     lengthOriginal: u32, roiStart: f32, roiEnd: f32) -> ${dType} { ` + (() => {\n        switch (coordinateTransferMode) {\n          case \"asymmetric\":\n            return `return ${dType}(xResized) / ${dType}(xScale);`;\n          case \"pytorch_half_pixel\":\n            return `if (lengthResized > 1) {\n                    return (${dType}(xResized) + 0.5) / ${dType}(xScale) - 0.5;\n                  } else {\n                    return 0.0;\n                  }`;\n          case \"tf_half_pixel_for_nn\":\n            return `return (${dType}(xResized) + 0.5) / ${dType}(xScale);`;\n          case \"align_corners\":\n            return `if (lengthResized == 1) {\n                    return 0.0;\n                  } else {\n                    // The whole part and the fractional part are calculated separately due to inaccuracy of floating\n                    // point division. As an example, f32(21) / f32(7) may evaluate to 2.99... instead of 3, causing an\n                    // offset-by-one error later in floor().\n                    let whole = ${dType}(xResized * (lengthOriginal - 1) / (lengthResized - 1));\n                    let fract =\n                        ${dType}(xResized * (lengthOriginal - 1) % (lengthResized - 1)) / ${dType}(lengthResized - 1);\n                    return whole + fract;\n                  }`;\n          case \"tf_crop_and_resize\":\n            return `if (lengthResized > 1) {\n                    return ${dType}(roiStart) * ${dType}(lengthOriginal - 1) +\n                        (${dType}(xResized) * ${dType}(roiEnd - roiStart) * ${dType}(lengthOriginal - 1)) /\n                        ${dType}(lengthResized - 1);\n                  } else {\n                    return 0.5 * ${dType}(roiStart + roiEnd) * ${dType}(lengthOriginal - 1);\n                  }`;\n          case \"half_pixel_symmetric\":\n            return `const outputWidth = ${dType}xScale * ${dType}(lengthResized);\n                  const adjustment = ${dType}(lengthResized) / outputWidth;\n                  const center = ${dType}(lengthOriginal) / 2;\n                  const offset = center * (1 - adjustment);\n                  return offset + ((${dType}(xResized) + 0.5) / ${dType}(xScale)) - 0.5;`;\n          case \"half_pixel\":\n            return `return ((${dType}(xResized) + 0.5) / ${dType}(xScale)) - 0.5;`;\n          default:\n            throw new Error(`Coordinate transform mode ${coordinateTransferMode} is not supported`);\n        }\n      })() + \"}\";\n      getNearestPixelFromOriginal = (nearestMode, opsetVersion, dType) => `fn getNearestPixelFromOriginal(xOriginal: ${dType}, isDownSample: bool) -> ${dType} {` + (() => {\n        switch (nearestMode) {\n          case \"round_prefer_ceil\":\n            return \"if (fract(xOriginal) == 0.5) {             return ceil(xOriginal);           } else {             return round(xOriginal);           }\";\n          case \"floor\":\n            return \"return floor(xOriginal);\";\n          case \"ceil\":\n            return \"return ceil(xOriginal);\";\n          case \"round_prefer_floor\":\n            return \"if (fract(xOriginal) == 0.5) {                     return floor(xOriginal);                   } else {                     return round(xOriginal);                   }\";\n          case \"simple\":\n          default:\n            if (opsetVersion < 11) {\n              return \"if (isDownSample)                     {                       return ceil(xOriginal);                     } else {                       return xOriginal;                     }\";\n            }\n            throw new Error(`Nearest mode ${nearestMode} is not supported`);\n        }\n      })() + \"}\";\n      updateRoI = (roi, axes, rank) => {\n        const roiTmp = new Array(rank).fill(0).concat(new Array(rank).fill(1));\n        const roiLocal = roi.length === 0 ? roiTmp : roi.slice();\n        if (axes.length > 0) {\n          axes.forEach((v, i) => {\n            roiTmp[v] = roiLocal[i];\n            roiTmp[i + rank] = roiLocal[axes.length + i];\n          });\n          return roiTmp;\n        }\n        return roiLocal;\n      };\n      initOutputShape = (inputShape, scales, sizes, axes) => {\n        let outputShape = [];\n        if (sizes.length > 0) {\n          if (axes.length > 0) {\n            inputShape.forEach((v) => outputShape.push(v));\n            if (Math.max(...axes) > inputShape.length) {\n              throw new Error(\"axes is out of bound\");\n            }\n            axes.forEach((v, i) => outputShape[v] = sizes[i]);\n          } else {\n            sizes.forEach((v) => outputShape.push(v));\n          }\n        } else {\n          if (scales.length === 0) {\n            throw new Error(\"Resize requires either scales or sizes.\");\n          } else {\n            outputShape = inputShape.map((value, index) => Math.round(value * scales[index]));\n          }\n        }\n        return outputShape;\n      };\n      adjustOutputShape = (inputShape, scales, attributes) => {\n        const scaleInPolicy = (() => {\n          switch (attributes.keepAspectRatioPolicy) {\n            case \"not_larger\":\n              return attributes.axes.length > 0 ? Math.min(...attributes.axes.map((i) => scales[i]), Number.MAX_VALUE) : Math.min(...scales, Number.MAX_VALUE);\n            case \"not_smaller\":\n              return attributes.axes.length > 0 ? Math.max(...attributes.axes.map((i) => scales[i]), Number.MIN_VALUE) : Math.max(...scales, Number.MIN_VALUE);\n            default:\n              throw new Error(`Keep aspect ratio policy ${attributes.keepAspectRatioPolicy} is not supported`);\n          }\n        })();\n        scales.fill(1, 0, scales.length);\n        const adjustedOutputShape = inputShape.slice();\n        if (attributes.axes.length > 0) {\n          attributes.axes.forEach((v) => scales[v] = scaleInPolicy);\n          attributes.axes.forEach((v) => adjustedOutputShape[v] = Math.round(inputShape[v] * scales[v]));\n        } else {\n          scales.fill(scaleInPolicy, 0, scales.length);\n          adjustedOutputShape.forEach((v, i) => adjustedOutputShape[i] = Math.round(v * scales[i]));\n        }\n        return adjustedOutputShape;\n      };\n      calculateOriginalIndicesFromOutputIndices = (output, inputShape, outputShape, scalesLength, roiLength) => `\n    fn calculateOriginalIndicesFromOutputIndices(output_indices: ${output.type.indices}) -> array<${output.type.value}, ${outputShape.length}> {\n      var original_indices: array<${output.type.value}, ${outputShape.length}>;\n      for (var i:u32 = 0; i < ${outputShape.length}; i++) {\n        var output_index = ${output.indicesGet(\"output_indices\", \"i\")};\n        var scale = ${getElementAt(\"uniforms.scales\", \"i\", scalesLength)};\n        var roi_low = ${getElementAt(\"uniforms.roi\", \"i\", roiLength)};\n        var roi_hi = ${getElementAt(\"uniforms.roi\", `i + ${inputShape.length}`, roiLength)};\n        if (scale == 1.0) {\n          original_indices[i] = ${output.type.value}(output_index);\n        } else {\n          var input_shape_i = ${getElementAt(\"uniforms.input_shape\", \"i\", inputShape.length)};\n          var output_shape_i = ${getElementAt(\"uniforms.output_shape\", \"i\", outputShape.length)};\n          original_indices[i] = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i,\n                                                                           input_shape_i, roi_low, roi_hi);\n        }\n      }\n      return original_indices;\n    }`;\n      calculateInputIndicesFromOutputIndices = (input, output, inputShape, outputShape, scalesLength, roiLength, useExtrapolation) => `\n    fn calculateInputIndicesFromOutputIndices(output_indices: ${output.type.indices}) -> ${input.type.indices} {\n      var input_indices: ${input.type.indices};\n      for (var i:u32 = 0; i < ${outputShape.length}; i++) {\n        var output_index = ${output.indicesGet(\"output_indices\", \"i\")};\n        var input_index: u32;\n        var scale = ${getElementAt(\"uniforms.scales\", \"i\", scalesLength)};\n        if (scale == 1.0) {\n          input_index = output_index;\n        } else {\n          var roi_low = ${getElementAt(\"uniforms.roi\", \"i\", roiLength)};\n          var roi_hi = ${getElementAt(\"uniforms.roi\", `i + ${inputShape.length}`, roiLength)};\n          var input_shape_i = ${getElementAt(\"uniforms.input_shape\", \"i\", inputShape.length)};\n          var output_shape_i = ${getElementAt(\"uniforms.output_shape\", \"i\", outputShape.length)};\n          var original_idx = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i,\n                                                                        input_shape_i, roi_low, roi_hi);\n          if (!${useExtrapolation} || (original_idx >= 0 && original_idx < ${output.type.value}(input_shape_i))) {\n            if (original_idx < 0) {\n              input_index = 0;\n            } else if (original_idx > ${output.type.value}(input_shape_i - 1)) {\n              input_index = input_shape_i - 1;\n            } else {\n              input_index = u32(getNearestPixelFromOriginal(original_idx, scale < 1));\n            }\n          } else {\n            input_index = u32(original_idx);\n          }\n        }\n        ${input.indicesSet(\"input_indices\", \"i\", \" input_index\")}\n      }\n      return input_indices;\n    }`;\n      checkInputIndices = (input, inputShape) => `\n    fn checkInputIndices(input_indices: ${input.type.indices}) -> bool {\n      for (var i:u32 = 0; i < ${inputShape.length}; i++) {\n        var input_index = ${input.indicesGet(\"input_indices\", \"i\")};\n        if (input_index < 0 || input_index >= ${getElementAt(\"uniforms.input_shape\", \"i\", inputShape.length)}) {\n          return false;\n        }\n      }\n      return true;\n    }`;\n      setChannelAndBatchIndices = (input, channelIdx, batchIdx, spacialDims) => input.rank > spacialDims ? `\n    ${input.indicesSet(\"input_indices\", channelIdx, \"channel\")};\n    ${input.indicesSet(\"input_indices\", batchIdx, \"batch\")};\n` : \"\";\n      bilinearInterpolation = (input, output, inputShape, useExtrapolation, extrapolationValue) => {\n        const isNchw = true;\n        const [batchIdx, heightIdx, widthIdx, channelIdx] = inputShape.length === 2 ? [-1, 0, 1, -1] : isNchw ? [0, 2, 3, 1] : [0, 1, 2, 3];\n        const dType = input.type.value;\n        return `\n    fn getInputValue(batch: u32, channel: u32, row: u32, col: u32) -> ${dType} {\n      var input_indices: ${input.type.indices};\n      ${input.indicesSet(\"input_indices\", heightIdx, `max(0, min(row, ${inputShape[heightIdx]} - 1))`)};\n      ${input.indicesSet(\"input_indices\", widthIdx, `max(0, min(col, ${inputShape[widthIdx]} - 1))`)};\n      ${setChannelAndBatchIndices(input, channelIdx, batchIdx, 2)}\n      return ${input.getByIndices(\"input_indices\")};\n    }\n\n    fn bilinearInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n      var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices);\n      var row:${dType} = originalIndices[${heightIdx}];\n      var col:${dType} = originalIndices[${widthIdx}];\n      ${useExtrapolation ? `if (row < 0 || row > (${inputShape[heightIdx]} - 1) || col < 0 || col > (${inputShape[widthIdx]} - 1)) {\n        return ${extrapolationValue};\n      }` : \"\"};\n      row = max(0, min(row, ${inputShape[heightIdx]} - 1));\n      col = max(0, min(col, ${inputShape[widthIdx]} - 1));\n      var row1: u32 = u32(row);\n      var col1: u32 = u32(col);\n      var row2: u32 = u32(row + 1);\n      var col2: u32 = u32(col + 1);\n      var channel: u32 = ${inputShape.length > 2 ? `u32(originalIndices[${channelIdx}])` : \"0\"};\n      var batch: u32 =  ${inputShape.length > 2 ? `u32(originalIndices[${batchIdx}])` : \"0\"};\n      var x11: ${dType} = getInputValue(batch, channel, row1, col1);\n      var x12: ${dType} = getInputValue(batch, channel, row1, col2);\n      var x21: ${dType} = getInputValue(batch, channel, row2, col1);\n      var x22: ${dType} = getInputValue(batch, channel, row2, col2);\n      var dx1: ${dType} = abs(row - ${dType}(row1));\n      var dx2: ${dType} = abs(${dType}(row2) - row);\n      var dy1: ${dType} = abs(col - ${dType}(col1));\n      var dy2: ${dType} = abs(${dType}(col2) - col);\n      if (row1 == row2) {\n        dx1 = 0.5;\n        dx2 = 0.5;\n      }\n      if (col1 == col2) {\n        dy1 = 0.5;\n        dy2 = 0.5;\n      }\n      return (x11 * dx2 * dy2 + x12 * dx2 * dy1 + x21 * dx1 * dy2 + x22 * dx1 * dy1);\n    }`;\n      };\n      bicubicInterpolation = (input, output, inputShape, outputShape, scales, roi, cubicCoeffA, useExtrapolation, extrapolationValue, excludeOutside) => {\n        const is2D = inputShape.length === 2;\n        const isNchw = true;\n        const [heightIdx, widthIdx] = is2D ? [0, 1] : isNchw ? [2, 3] : [1, 2];\n        const dType = input.type.value;\n        const createCubicInterpolationFunction = (idx) => {\n          const direction = idx === heightIdx ? \"row\" : \"col\";\n          return `\n      fn ${direction}CubicInterpolation(input_indices: ${input.type.indices}, output_indices: ${output.type.indices}) -> ${dType} {\n        var output_index = ${output.indicesGet(\"output_indices\", idx)};\n        var originalIdx: ${dType} = getOriginalCoordinateFromResizedCoordinate(output_index, ${scales[idx]},\n        ${outputShape[idx]}, ${inputShape[idx]}, ${roi[idx]}, ${roi[idx]} + ${inputShape.length});\n        var fractOriginalIdx: ${dType} = originalIdx - floor(originalIdx);\n        var coefs = getCubicInterpolationCoefs(fractOriginalIdx);\n\n        if (${useExtrapolation} && (originalIdx < 0 || originalIdx > (${inputShape[idx]} - 1))) {\n          return ${extrapolationValue};\n        }\n        var data: array<${dType}, 4> = array<${dType}, 4>(0.0, 0.0, 0.0, 0.0);\n        for (var i: i32 = -1; i < 3; i++) {\n          var ${direction}: ${dType} = originalIdx + ${dType}(i);\n          if (${direction} < 0 || ${direction} >= ${inputShape[idx]}) {\n            ${(() => {\n            if (excludeOutside) {\n              return `coefs[i + 1] = 0.0;\n                        continue;`;\n            } else if (useExtrapolation) {\n              return `return ${extrapolationValue};`;\n            } else {\n              return `${direction} = max(0, min(${direction}, ${inputShape[idx]} - 1));`;\n            }\n          })()};\n          }\n        var input_indices_copy: ${input.type.indices} = input_indices;\n          ${input.indicesSet(\"input_indices_copy\", idx, `u32(${direction})`)};\n          data[i + 1] = ${idx === heightIdx ? input.getByIndices(\"input_indices_copy\") : \"rowCubicInterpolation(input_indices_copy, output_indices)\"};\n        }\n        return cubicInterpolation1D(data, coefs);\n      }`;\n        };\n        return `\n    ${createCubicInterpolationFunction(heightIdx)};\n    ${createCubicInterpolationFunction(widthIdx)};\n  fn getCubicInterpolationCoefs(s: ${dType}) -> array<${dType}, 4> {\n    var absS = abs(s);\n    var coeffs: array<${dType}, 4> = array<${dType}, 4>(0.0, 0.0, 0.0, 0.0);\n    var oneMinusAbsS: ${dType} = 1.0 - absS;\n    var twoMinusAbsS: ${dType} = 2.0 - absS;\n    var onePlusAbsS: ${dType} = 1.0 + absS;\n    coeffs[0] = ((${cubicCoeffA} * onePlusAbsS - 5 * ${cubicCoeffA}) * onePlusAbsS + 8 * ${cubicCoeffA}) * onePlusAbsS - 4 * ${cubicCoeffA};\n    coeffs[1] = ((${cubicCoeffA} + 2) * absS - (${cubicCoeffA} + 3)) * absS * absS + 1;\n    coeffs[2] = ((${cubicCoeffA} + 2) * oneMinusAbsS - (${cubicCoeffA} + 3)) * oneMinusAbsS * oneMinusAbsS + 1;\n    coeffs[3] = ((${cubicCoeffA} * twoMinusAbsS - 5 * ${cubicCoeffA}) * twoMinusAbsS + 8 * ${cubicCoeffA}) * twoMinusAbsS - 4 * ${cubicCoeffA};\n    return coeffs;\n  }\n\n  fn cubicInterpolation1D(x: array<${dType}, 4>, coefs: array<${dType}, 4>) -> ${dType} {\n    var coefsSum: ${dType} = coefs[0] + coefs[1] + coefs[2] + coefs[3];\n    return (x[0] * coefs[0] + x[1] * coefs[1]+ x[2] * coefs[2]+ x[3] * coefs[3]) / coefsSum;\n  }\n\n  fn bicubicInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n    var input_indices: ${input.type.indices} = output_indices;\n    return colCubicInterpolation(input_indices, output_indices);\n  }\n    `;\n      };\n      trilinearInterpolation = (input, output, inputShape, useExtrapolation, extrapolationValue) => {\n        const isNchw = true;\n        const [batchIdx, depthIdx, heightIdx, widthIdx, channelIdx] = inputShape.length === 3 ? [-1, 0, 1, 2, -1] : isNchw ? [0, 2, 3, 4, 1] : [0, 1, 2, 3, 4];\n        const dType = input.type.value;\n        return `\n    fn getInputValue(batch: u32, channel: u32, depth:u32, height: u32, width: u32) -> ${dType} {\n      var input_indices: ${input.type.indices};\n      ${input.indicesSet(\"input_indices\", depthIdx, `max(0, min(depth, ${inputShape[depthIdx]} - 1))`)};\n      ${input.indicesSet(\"input_indices\", heightIdx, `max(0, min(height, ${inputShape[heightIdx]} - 1))`)};\n      ${input.indicesSet(\"input_indices\", widthIdx, `max(0, min(width, ${inputShape[widthIdx]} - 1))`)};\n      ${setChannelAndBatchIndices(input, channelIdx, batchIdx, 3)}\n      return ${input.getByIndices(\"input_indices\")};\n    }\n\n    fn trilinearInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n      var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices);\n      var depth:${dType} = originalIndices[${depthIdx}];\n      var height:${dType} = originalIndices[${heightIdx}];\n      var width:${dType} = originalIndices[${widthIdx}];\n      ${useExtrapolation ? `if (depth < 0 || depth > (${inputShape[depthIdx]} - 1) || height < 0 || height > (${inputShape[heightIdx]} - 1) || width < 0 || (width > ${inputShape[widthIdx]} - 1)) {\n      return ${extrapolationValue};\n        }` : \"\"};\n\n    depth = max(0, min(depth, ${inputShape[depthIdx]} - 1));\n      height = max(0, min(height, ${inputShape[heightIdx]} - 1));\n      width = max(0, min(width, ${inputShape[widthIdx]} - 1));\n      var depth1: u32 = u32(depth);\n      var height1: u32 = u32(height);\n      var width1: u32 = u32(width);\n      var depth2: u32 = u32(depth + 1);\n      var height2: u32 = u32(height + 1);\n      var width2: u32 = u32(width + 1);\n      var channel: u32 = ${inputShape.length > 3 ? `u32(originalIndices[${channelIdx}])` : \"0\"};\n      var batch: u32 =  ${inputShape.length > 3 ? `u32(originalIndices[${batchIdx}])` : \"0\"};\n\n      var x111: ${dType} = getInputValue(batch, channel, depth1, height1, width1);\n      var x112: ${dType} = getInputValue(batch, channel, depth1, height1, width2);\n      var x121: ${dType} = getInputValue(batch, channel, depth1, height2, width1);\n      var x122: ${dType} = getInputValue(batch, channel, depth1, height2, width2);\n      var x211: ${dType} = getInputValue(batch, channel, depth2, height1, width1);\n      var x212: ${dType} = getInputValue(batch, channel, depth2, height1, width2);\n      var x221: ${dType} = getInputValue(batch, channel, depth2, height2, width1);\n      var x222: ${dType} = getInputValue(batch, channel, depth2, height2, width2);\n      var dx1: ${dType} = abs(depth - ${dType}(depth1));\n      var dx2: ${dType} = abs(${dType}(depth2) - depth);\n      var dy1: ${dType} = abs(height - ${dType}(height1));\n      var dy2: ${dType} = abs(${dType}(height2) - height);\n      var dz1: ${dType} = abs(width - ${dType}(width1));\n      var dz2: ${dType} = abs(${dType}(width2) - width);\n      if (depth1 == depth2) {\n        dx1 = 0.5;\n        dx2 = 0.5;\n      }\n      if (height1 == height2) {\n        dy1 = 0.5;\n        dy2 = 0.5;\n      }\n      if (width1 == width2) {\n        dz1 = 0.5;\n        dz2 = 0.5;\n      }\n      return (x111 * dx2 * dy2 * dz2 + x112 * dx2 * dy2 * dz1 + x121 * dx2 * dy1 *dz2 + x122 * dx2 * dy1 * dz1 +\n              x211 * dx1 * dy2 * dz2 + x212 * dx1 * dy2 * dz1 + x221 * dx1 * dy1 *dz2 + x222 * dx1 * dy1 * dz1);\n    }`;\n      };\n      createResizeProgramInfo = (inputTensor, attributes, opsetVersion, scalesInput, sizes, roiInput) => {\n        const inputShape = inputTensor.dims;\n        const roi = updateRoI(roiInput, attributes.axes, inputShape.length);\n        let outputShape = initOutputShape(inputShape, scalesInput, sizes, attributes.axes);\n        let scales = scalesInput.slice();\n        if (scalesInput.length === 0) {\n          scales = inputShape.map((value, index) => value === 0 ? 1 : outputShape[index] / value);\n          if (attributes.keepAspectRatioPolicy !== \"stretch\") {\n            outputShape = adjustOutputShape(inputShape, scales, attributes);\n          }\n        }\n        const output = outputVariable(\"output\", inputTensor.dataType, outputShape.length);\n        const input = inputVariable(\"input\", inputTensor.dataType, inputShape.length);\n        const outputSize = ShapeUtil.size(outputShape);\n        const noScale = inputShape.length === outputShape.length && inputShape.every((d, i) => d === outputShape[i]);\n        const useExtrapolation = attributes.coordinateTransformMode === \"tf_crop_and_resize\";\n        const extrapolationValue = attributes.extrapolationValue;\n        const dataType = input.type.value;\n        const getShaderSource = (shaderHelper) => `\n      ${noScale ? \"\" : `\n      ${getOriginalCoordinateFromResizedCoordinate(attributes.coordinateTransformMode, dataType)};\n      ${(() => {\n          switch (attributes.mode) {\n            case \"nearest\":\n              return `\n              ${checkInputIndices(input, inputShape)};\n              ${getNearestPixelFromOriginal(attributes.nearestMode, opsetVersion, dataType)};\n              ${calculateInputIndicesFromOutputIndices(\n                input,\n                output,\n                inputShape,\n                outputShape,\n                scales.length,\n                roi.length,\n                useExtrapolation\n              )};\n              `;\n            case \"linear\":\n              return `\n              ${calculateOriginalIndicesFromOutputIndices(output, inputShape, outputShape, scales.length, roi.length)};\n              ${(() => {\n                if (inputShape.length === 2 || inputShape.length === 4) {\n                  return `${bilinearInterpolation(input, output, inputShape, useExtrapolation, extrapolationValue)}`;\n                } else if (inputShape.length === 3 || inputShape.length === 5) {\n                  return `${trilinearInterpolation(input, output, inputShape, useExtrapolation, extrapolationValue)}`;\n                } else {\n                  throw Error(\"Linear mode only supports input dims 2, 3, 4 and 5 are supported in linear mode.\");\n                }\n              })()};\n            `;\n            case \"cubic\":\n              return `\n            ${(() => {\n                if (inputShape.length === 2 || inputShape.length === 4) {\n                  return `${bicubicInterpolation(\n                    input,\n                    output,\n                    inputShape,\n                    outputShape,\n                    scales,\n                    roi,\n                    attributes.cubicCoeffA,\n                    useExtrapolation,\n                    attributes.extrapolationValue,\n                    attributes.excludeOutside\n                  )}`;\n                } else {\n                  throw Error(\"Cubic mode only supports input dims 2 and 4 are supported in linear mode.\");\n                }\n              })()};\n            `;\n            default:\n              throw Error(\"Invalid resize mode\");\n          }\n        })()};\n      `}\n      ${shaderHelper.registerUniform(\"output_size\", \"u32\").registerUniform(\"scales\", \"f32\", scales.length).registerUniform(\"roi\", \"f32\", roi.length).declareVariables(input, output)}\n      ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.output_size\")}\n        ${noScale ? \"output[global_idx] = input[global_idx];\" : `\n        let output_indices = ${output.offsetToIndices(\"global_idx\")};\n        var input_indices: ${input.type.indices};\n        ${(() => {\n          switch (attributes.mode) {\n            case \"nearest\":\n              return `input_indices = calculateInputIndicesFromOutputIndices(output_indices);\n                if (checkInputIndices(input_indices)) {\n                  output[global_idx] = ${input.getByIndices(\"input_indices\")};\n                } else {\n                  output[global_idx] = ${attributes.extrapolationValue};\n                }`;\n            case \"linear\":\n              return `output[global_idx] = ${inputShape.length === 2 || inputShape.length === 4 ? \"bilinearInterpolation\" : \"trilinearInterpolation\"}(output_indices);`;\n            case \"cubic\":\n              return \"output[global_idx] = bicubicInterpolation(output_indices);\";\n            default:\n              throw Error(`Unsupported resize mode: ${attributes.mode}`);\n          }\n        })()};\n`}\n      }`;\n        return {\n          name: \"Resize\",\n          shaderCache: {\n            hint: `${attributes.cacheKey}|${opsetVersion}|${scales.length > 0 ? scales : \"\"}|${sizes.length > 0 ? sizes : \"\"}|${roi.length > 0 ? roi : \"\"}|${noScale}|${inputShape}`,\n            inputDependencies: [\"rank\"]\n          },\n          getShaderSource,\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: inputTensor.dataType }],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64\n              /* workgroup size */\n            ) },\n            programUniforms: [\n              { type: 12 /* uint32 */, data: outputSize },\n              { type: 1 /* float */, data: scales },\n              { type: 1 /* float */, data: roi },\n              ...createTensorShapeVariables(inputShape, outputShape)\n            ]\n          })\n        };\n      };\n      getOpsetVersionFromCustomDataBuffer = (context) => {\n        const customDataBuffer = context.customDataBuffer;\n        const customDataBuffer32 = new Uint32Array(customDataBuffer, customDataBuffer.byteOffset, 1);\n        const opsetVersion = customDataBuffer32[0];\n        return opsetVersion;\n      };\n      resize = (context, attributes) => {\n        const scales = [];\n        const sizes = [];\n        const roi = [];\n        const opsetVersion = getOpsetVersionFromCustomDataBuffer(context);\n        if (attributes.antialias !== 0) {\n          throw Error(\"Only default value (0) for Antialias attribute is supported\");\n        }\n        validateInputs21(context.inputs, attributes, opsetVersion, scales, sizes, roi);\n        context.compute(\n          createResizeProgramInfo(context.inputs[0], attributes, opsetVersion, scales, sizes, roi),\n          { inputs: [0] }\n        );\n      };\n      parseResizeAttributes = (attributes) => {\n        const antialias = attributes.antialias;\n        const axes = attributes.axes;\n        const coordinateTransformMode = attributes.coordinateTransformMode;\n        const cubicCoeffA = attributes.cubicCoeffA;\n        const excludeOutside = attributes.excludeOutside !== 0;\n        const extrapolationValue = attributes.extrapolationValue;\n        const keepAspectRatioPolicy = attributes.keepAspectRatioPolicy;\n        const mode = attributes.mode;\n        const nearestMode = attributes.nearestMode === \"\" ? \"simple\" : attributes.nearestMode;\n        return createAttributeWithCacheKey({\n          antialias,\n          axes,\n          coordinateTransformMode,\n          cubicCoeffA,\n          excludeOutside,\n          extrapolationValue,\n          keepAspectRatioPolicy,\n          mode,\n          nearestMode\n        });\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/rotary-embedding.ts\n  var validateInputs22, createRotaryEmbeddingProgramInfo, rotaryEmbedding;\n  var init_rotary_embedding = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/rotary-embedding.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_attribute_with_cache_key();\n      init_common();\n      validateInputs22 = (inputs, attributes) => {\n        const [input, positionIds, cosCache, sinCache] = inputs;\n        const { numHeads, rotaryEmbeddingDim } = attributes;\n        if (input.dims.length !== 3 && input.dims.length !== 4) {\n          throw new Error(`Input 'x' is expected to have 3 or 4 dimensions, got ${input.dims.length}`);\n        }\n        if (!ShapeUtil.areEqual(positionIds.dims, []) && !ShapeUtil.areEqual(positionIds.dims, [1]) && positionIds.dims.length !== 2) {\n          throw new Error(`Input 'position_ids' is expected to have 0, 1, or 2 dimensions, got ${positionIds.dims.length}`);\n        }\n        if (cosCache.dims.length !== 2) {\n          throw new Error(`Input 'cos_cache' is expected to have 2 dimensions, got ${cosCache.dims.length}`);\n        }\n        if (sinCache.dims.length !== 2) {\n          throw new Error(`Input 'sin_cache' is expected to have 2 dimensions, got ${sinCache.dims.length}`);\n        }\n        if (!ShapeUtil.areEqual(cosCache.dims, sinCache.dims)) {\n          throw new Error(\"Inputs 'cos_cache' and 'sin_cache' are expected to have the same shape\");\n        }\n        if (rotaryEmbeddingDim > 0 && numHeads === 0) {\n          throw new Error(\"num_heads must be provided if rotary_embedding_dim is specified\");\n        }\n        const batchSize = input.dims[0];\n        const sequenceLength = input.dims[input.dims.length - 2];\n        const maxSequenceLength = cosCache.dims[0];\n        const hiddenSize = ShapeUtil.sizeFromDimension(input.dims, 1) / sequenceLength;\n        const headSize = rotaryEmbeddingDim === 0 ? cosCache.dims[1] * 2 : hiddenSize / numHeads;\n        if (rotaryEmbeddingDim > headSize) {\n          throw new Error(\"rotary_embedding_dim must be less than or equal to head_size\");\n        }\n        if (positionIds.dims.length === 2) {\n          if (batchSize !== positionIds.dims[0]) {\n            throw new Error(`Input 'position_ids' dimension 0 should be of size batch_size, got ${positionIds.dims[0]}`);\n          }\n          if (sequenceLength !== positionIds.dims[1]) {\n            throw new Error(`Input 'position_ids' dimension 1 should be of size sequence_length, got ${positionIds.dims[1]}`);\n          }\n        }\n        if (headSize / 2 !== cosCache.dims[1] && rotaryEmbeddingDim / 2 !== cosCache.dims[1]) {\n          throw new Error(`Input 'cos_cache' dimension 1 should be same as head_size / 2 or rotary_embedding_dim / 2, got ${cosCache.dims[1]}`);\n        }\n        if (sequenceLength > maxSequenceLength) {\n          throw new Error(\"Updating cos_cache and sin_cache in RotaryEmbedding is not currently supported\");\n        }\n      };\n      createRotaryEmbeddingProgramInfo = (inputs, attributes) => {\n        const { interleaved, numHeads, rotaryEmbeddingDim, scale } = attributes;\n        const batchSize = inputs[0].dims[0];\n        const batchStride = ShapeUtil.sizeFromDimension(inputs[0].dims, 1);\n        const sequenceLength = inputs[0].dims[inputs[0].dims.length - 2];\n        const hiddenSize = batchStride / sequenceLength;\n        const halfRotaryEmbeddingDim = inputs[2].dims[1];\n        const headSize = rotaryEmbeddingDim === 0 ? halfRotaryEmbeddingDim * 2 : hiddenSize / numHeads;\n        const globalShape = new Array(batchSize, sequenceLength, hiddenSize / headSize, headSize - halfRotaryEmbeddingDim);\n        const globalStrides = ShapeUtil.computeStrides(globalShape);\n        const programUniforms = [\n          { type: 1 /* float */, data: scale },\n          { type: 12 /* uint32 */, data: globalShape },\n          { type: 12 /* uint32 */, data: globalStrides },\n          // strides for addressing the input/output tensor, in permutated order to align with the unfolded global index,\n          // i.e. BSNH\n          ...inputs[0].dims.length === 3 ? new Array({ type: 12 /* uint32 */, data: [batchStride, hiddenSize, headSize, 1] }) : [],\n          ...inputs[0].dims.length === 4 ? new Array(\n            { type: 12 /* uint32 */, data: [batchStride, headSize, sequenceLength * headSize, 1] }\n          ) : [],\n          ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims, inputs[2].dims, inputs[3].dims, inputs[0].dims)\n        ];\n        const getShaderSource = (shaderHelper) => {\n          const input = inputVariable(\"input\", inputs[0].dataType, inputs[0].dims.length);\n          const positionIds = inputVariable(\"position_ids\", inputs[1].dataType, inputs[1].dims.length);\n          const cosCache = inputVariable(\"cos_cache\", inputs[2].dataType, inputs[2].dims.length);\n          const sinCache = inputVariable(\"sin_cache\", inputs[3].dataType, inputs[3].dims.length);\n          const output = outputVariable(\"output\", inputs[0].dataType, inputs[0].dims.length);\n          shaderHelper.registerUniforms([\n            { name: \"scale\", type: \"f32\" },\n            { name: \"global_shape\", type: \"u32\", length: globalShape.length },\n            { name: \"global_strides\", type: \"u32\", length: globalStrides.length },\n            { name: \"input_output_strides\", type: \"u32\", length: globalStrides.length }\n          ]);\n          return `\n        ${shaderHelper.declareVariables(input, positionIds, cosCache, sinCache, output)}\n\n        ${shaderHelper.mainStart(WORKGROUP_SIZE)}\n          let half_rotary_emb_dim = uniforms.${cosCache.name}_shape[1];\n          let bsnh = global_idx / uniforms.global_strides % uniforms.global_shape;\n          let size = uniforms.global_shape[0] * uniforms.global_strides[0];\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"size\")}\n\n          if (bsnh[3] < half_rotary_emb_dim) {\n            let position_ids_idx =\n                ${positionIds.broadcastedIndicesToOffset(\"bsnh.xy\", outputVariable(\"\", positionIds.type.tensor, 2))};\n            let position_id =\n                u32(${positionIds.getByOffset(\"position_ids_idx\")}) + select(0, bsnh[1], position_ids_idx == 0);\n            let i = dot(bsnh, uniforms.input_output_strides) + select(0, bsnh[3], ${interleaved});\n            let j = i + select(half_rotary_emb_dim, 1, ${interleaved});\n            let re = ${input.getByOffset(\"i\")} * ${cosCache.get(\"position_id\", \"bsnh[3]\")} -\n                ${input.getByOffset(\"j\")} * ${sinCache.get(\"position_id\", \"bsnh[3]\")};\n            ${output.setByOffset(\"i\", \"re\")}\n            let im = ${input.getByOffset(\"i\")} * ${sinCache.get(\"position_id\", \"bsnh[3]\")} +\n                ${input.getByOffset(\"j\")} * ${cosCache.get(\"position_id\", \"bsnh[3]\")};\n            ${output.setByOffset(\"j\", \"im\")}\n          } else {\n            let k = dot(bsnh, uniforms.input_output_strides) + half_rotary_emb_dim;\n            ${output.setByOffset(\"k\", input.getByOffset(\"k\"))}\n          }\n        }`;\n        };\n        return {\n          name: \"RotaryEmbedding\",\n          shaderCache: {\n            hint: createAttributeWithCacheKey({\n              interleaved\n            }).cacheKey,\n            inputDependencies: [\"rank\", \"rank\", \"rank\", \"rank\"]\n          },\n          getShaderSource,\n          getRunData: () => ({\n            outputs: [{ dims: inputs[0].dims, dataType: inputs[0].dataType }],\n            dispatchGroup: { x: Math.ceil(ShapeUtil.size(globalShape) / WORKGROUP_SIZE) },\n            programUniforms\n          })\n        };\n      };\n      rotaryEmbedding = (context, attributes) => {\n        validateInputs22(context.inputs, attributes);\n        context.compute(createRotaryEmbeddingProgramInfo(context.inputs, attributes));\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/skip-layer-norm.ts\n  var validateInputs23, createSkipLayerNormProgramInfo, skipLayerNorm;\n  var init_skip_layer_norm = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/skip-layer-norm.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_common();\n      validateInputs23 = (inputs) => {\n        if (!inputs || inputs.length < 3) {\n          throw new Error(\"layerNorm requires at least 3 inputs.\");\n        }\n        const input = inputs[0];\n        const skip = inputs[1];\n        const gamma = inputs[2];\n        if (input.dataType !== skip.dataType || input.dataType !== gamma.dataType) {\n          throw new Error(\"All inputs must have the same data type\");\n        }\n        if (input.dims.length !== 3 && input.dims.length !== 2) {\n          throw new Error(\"Input must be 2D or 3D\");\n        }\n        if (skip.dims.length !== 3 && skip.dims.length !== 2) {\n          throw new Error(\"Skip must be 2D or 3D\");\n        }\n        const hiddenSize = input.dims[input.dims.length - 1];\n        const sequenceLength = input.dims[input.dims.length - 2];\n        if (skip.dims[skip.dims.length - 1] !== hiddenSize) {\n          throw new Error(\"Skip must have the same hidden size as input\");\n        }\n        if (skip.dims[skip.dims.length - 2] !== sequenceLength) {\n          throw new Error(\"Skip must have the same sequence length as input\");\n        }\n        if (gamma.dims.length !== 1) {\n          throw new Error(\"Gamma must be 1D\");\n        }\n        if (gamma.dims[gamma.dims.length - 1] !== hiddenSize) {\n          throw new Error(\"Gamma must have the same hidden size as input\");\n        }\n        if (inputs.length > 3) {\n          const beta = inputs[3];\n          if (beta.dims.length !== 1) {\n            throw new Error(\"Beta must be 1D\");\n          }\n          if (beta.dims[beta.dims.length - 1] !== hiddenSize) {\n            throw new Error(\"Beta must have the same hidden size as input\");\n          }\n        }\n        if (inputs.length > 4) {\n          const bias = inputs[4];\n          if (bias.dims.length !== 1) {\n            throw new Error(\"Bias must be 1D\");\n          }\n          if (bias.dims[bias.dims.length - 1] !== hiddenSize) {\n            throw new Error(\"Bias must have the same hidden size as input\");\n          }\n        }\n      };\n      createSkipLayerNormProgramInfo = (inputs, attributes, outputCount, isTraining) => {\n        const simplified = attributes.simplified;\n        const inputShape = inputs[0].dims;\n        const inputSize = ShapeUtil.size(inputShape);\n        const outputShape = inputShape;\n        const outputSize = inputSize;\n        const hiddenSize = inputShape.slice(-1)[0];\n        const meanInvStdDevDim = isTraining ? inputShape.slice(0, -1).concat(1) : [];\n        const hasBetaInput = !simplified && inputs.length > 3;\n        const hasBiasInput = inputs.length > 4;\n        const hasMeanOutput = isTraining && outputCount > 1;\n        const hasInvStdDevOutput = isTraining && outputCount > 2;\n        const hasInputSkipBiasSumOutput = outputCount > 3;\n        const components = getMaxComponents(hiddenSize);\n        const programUniforms = [\n          { type: 12 /* uint32 */, data: outputSize },\n          { type: 12 /* uint32 */, data: components },\n          { type: 12 /* uint32 */, data: hiddenSize },\n          { type: 1 /* float */, data: attributes.epsilon }\n        ];\n        const getShaderSource = (shaderHelper) => {\n          const uniformsArray = [\n            { name: \"output_size\", type: \"u32\" },\n            { name: \"components\", type: \"u32\" },\n            { name: \"hidden_size\", type: \"u32\" },\n            { name: \"epsilon\", type: \"f32\" }\n          ];\n          const variables = [\n            inputVariable(\"x\", inputs[0].dataType, inputs[0].dims, components),\n            inputVariable(\"skip\", inputs[1].dataType, inputs[1].dims, components),\n            inputVariable(\"gamma\", inputs[2].dataType, inputs[2].dims, components)\n          ];\n          if (hasBetaInput) {\n            variables.push(inputVariable(\"beta\", inputs[3].dataType, inputs[3].dims, components));\n          }\n          if (hasBiasInput) {\n            variables.push(inputVariable(\"bias\", inputs[4].dataType, inputs[4].dims, components));\n          }\n          variables.push(outputVariable(\"output\", inputs[0].dataType, outputShape, components));\n          if (hasMeanOutput) {\n            variables.push(outputVariable(\"mean_output\", 1 /* float */, meanInvStdDevDim));\n          }\n          if (hasInvStdDevOutput) {\n            variables.push(outputVariable(\"inv_std_output\", 1 /* float */, meanInvStdDevDim));\n          }\n          if (hasInputSkipBiasSumOutput) {\n            variables.push(outputVariable(\"input_skip_bias_sum\", inputs[0].dataType, outputShape, components));\n          }\n          const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n          return `\n\n      ${shaderHelper.registerUniforms(uniformsArray).declareVariables(...variables)}\n\n      ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.output_size / uniforms.hidden_size\")}\n        let hidden_size_vectorized: u32 = uniforms.hidden_size / uniforms.components;\n        let offset = global_idx * hidden_size_vectorized;\n        var sum = ${fillVector(\"f32\", components)};\n        var squareSum = ${fillVector(\"f32\", components)};\n        for (var i: u32 = 0; i < hidden_size_vectorized; i++) {\n          let skip_value = skip[offset + i];\n          let bias_value = ${hasBiasInput ? \"bias[i]\" : dataType + \"(0.0)\"};\n          let input_value = x[offset + i];\n          let value = input_value + skip_value + bias_value;\n          ${hasInputSkipBiasSumOutput ? \"input_skip_bias_sum[offset + i] = value;\" : \"\"}\n          output[offset + i] = value;\n          let f32_value = ${castToF32(dataType, components, \"value\")};\n          sum += f32_value;\n          squareSum += f32_value * f32_value;\n        }\n        let mean = ${sumVector(\"sum\", components)} / f32(uniforms.hidden_size);\n        let inv_std_dev = inverseSqrt(${sumVector(\"squareSum\", components)} / f32(uniforms.hidden_size) ${simplified ? \"\" : \"- mean * mean\"} + uniforms.epsilon);\n        ${hasMeanOutput ? \"mean_output[global_idx] = mean;\" : \"\"}\n        ${hasInvStdDevOutput ? \"inv_std_output[global_idx] = inv_std_dev;\" : \"\"}\n        for (var i: u32 = 0; i < hidden_size_vectorized; i++) {\n          output[offset + i] = (output[offset + i] ${simplified ? \"\" : `- ${dataType}(mean)`}) * ${dataType}(inv_std_dev) * gamma[i] ${hasBetaInput ? \"+ beta[i]\" : \"\"};\n        }\n      }`;\n        };\n        const outputs = [{ dims: outputShape, dataType: inputs[0].dataType }];\n        if (outputCount > 1) {\n          outputs.push({ dims: meanInvStdDevDim, dataType: 1 /* float */ });\n        }\n        if (outputCount > 2) {\n          outputs.push({ dims: meanInvStdDevDim, dataType: 1 /* float */ });\n        }\n        if (outputCount > 3) {\n          outputs.push({ dims: inputShape, dataType: inputs[0].dataType });\n        }\n        return {\n          name: \"SkipLayerNormalization\",\n          shaderCache: {\n            hint: `${components};${hasMeanOutput};${hasInvStdDevOutput};${hasInputSkipBiasSumOutput}`,\n            inputDependencies: inputs.map((_input, _index) => \"type\")\n          },\n          getShaderSource,\n          getRunData: () => ({ outputs, dispatchGroup: { x: Math.ceil(outputSize / hiddenSize / 64) }, programUniforms })\n        };\n      };\n      skipLayerNorm = (context, attributes) => {\n        const isTraining = false;\n        validateInputs23(context.inputs);\n        const outputs = [0];\n        if (context.outputCount > 1) {\n          outputs.push(isTraining ? 1 : -3);\n        }\n        if (context.outputCount > 2) {\n          outputs.push(isTraining ? 2 : -3);\n        }\n        if (context.outputCount > 3) {\n          outputs.push(3);\n        }\n        context.compute(\n          createSkipLayerNormProgramInfo(context.inputs, attributes, context.outputCount, isTraining),\n          { outputs }\n        );\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/slice.ts\n  var validateInputs24, readInput, createSliceAttributesFromInputs, fixStartEndValues, calculateInputIndicesImpl, createSliceProgramInfo, slice, parseSliceAttributes;\n  var init_slice = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/slice.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_attribute_with_cache_key();\n      init_common();\n      validateInputs24 = (inputs, attributes) => {\n        if (!inputs || inputs.length < 1) {\n          throw new Error(\"too few inputs\");\n        }\n        if (attributes.axes.length !== 0) {\n          if (attributes.axes.length !== attributes.starts.length || attributes.axes.length !== attributes.ends.length) {\n            throw new Error(\"axes, starts and ends must have the same length\");\n          }\n        } else if (attributes.starts.length !== attributes.ends.length) {\n          throw new Error(\"starts and ends must have the same length\");\n        }\n        inputs.slice(1).forEach((_, idx) => {\n          if (inputs[idx + 1].dataType !== 6 /* int32 */ && inputs[idx + 1].dataType !== 7 /* int64 */) {\n            throw new Error(`Input ${idx} must be an array of int32 or int64`);\n          }\n        });\n      };\n      readInput = (inputs, idx) => {\n        const input = [];\n        if (inputs.length > idx) {\n          if (inputs[idx].dataType === 7 /* int64 */) {\n            inputs[idx].getBigInt64Array().forEach((v) => input.push(Number(v)));\n          } else if (inputs[idx].dataType === 6 /* int32 */) {\n            inputs[idx].getInt32Array().forEach((v) => input.push(Number(v)));\n          } else {\n            throw new Error(`Input ${idx} must be an array of int32 or int64`);\n          }\n        }\n        return input;\n      };\n      createSliceAttributesFromInputs = (inputs, attributes) => {\n        if (inputs.length > 1) {\n          const starts = readInput(inputs, 1);\n          const ends = readInput(inputs, 2);\n          let axes = readInput(inputs, 3);\n          if (axes.length === 0) {\n            axes = [...Array(inputs[0].dims.length).keys()];\n          }\n          return createAttributeWithCacheKey({ starts, ends, axes });\n        } else {\n          return attributes;\n        }\n      };\n      fixStartEndValues = (value, index, inputShape, axes, steps) => {\n        let newValue = value;\n        if (value < 0) {\n          newValue += inputShape[axes[index]];\n        }\n        if (steps[index] < 0) {\n          return Math.max(0, Math.min(newValue, inputShape[axes[index]] - 1));\n        } else {\n          return Math.max(0, Math.min(newValue, inputShape[axes[index]]));\n        }\n      };\n      calculateInputIndicesImpl = (input, output, inputShape) => `fn calculateInputIndices(output_indices: ${output.type.indices}) -> ${input.type.indices} {\n          var input_indices: ${input.type.indices};\n          var carry = 0u;\n          for (var i = ${inputShape.length}; i >= 0; i--) {\n            let input_shape_i = ${getElementAt(\"uniforms.input_shape\", \"i\", inputShape.length)};\n            let steps_i = ${getElementAt(\"uniforms.steps\", \"i\", inputShape.length)};\n            let signs_i = ${getElementAt(\"uniforms.signs\", \"i\", inputShape.length)};\n            let starts_i = ${getElementAt(\"uniforms.starts\", \"i\", inputShape.length)};\n            var output_index = ${output.indicesGet(\"output_indices\", \"i\")};\n            var input_index = output_index * steps_i + starts_i + carry;\n            carry = input_index / input_shape_i;\n            input_index = input_index % input_shape_i;\n            if (signs_i < 0) {\n              input_index = input_shape_i - input_index - 1u + starts_i;\n            }\n            ${input.indicesSet(\"input_indices\", \"i\", \"input_index\")};\n          }\n          return input_indices;\n      }`;\n      createSliceProgramInfo = (inputs, attributes) => {\n        const inputShape = inputs[0].dims;\n        const inputSize = ShapeUtil.size(inputShape);\n        const axes = attributes.axes.length > 0 ? ShapeUtil.normalizeAxes(attributes.axes, inputShape.length) : [...Array(inputShape.length).keys()];\n        let steps = readInput(inputs, 4);\n        steps.forEach((step) => step !== 0 || (() => {\n          throw new Error(\"step cannot be 0\");\n        }));\n        if (steps.length === 0) {\n          steps = Array(axes.length).fill(1);\n        }\n        const starts = attributes.starts.map((start, i) => fixStartEndValues(start, i, inputShape, axes, steps));\n        const ends = attributes.ends.map((end, i) => fixStartEndValues(end, i, inputShape, axes, steps));\n        if (axes.length !== starts.length || axes.length !== ends.length) {\n          throw new Error(\"start, ends and axes should have the same number of elements\");\n        }\n        if (axes.length !== inputShape.length) {\n          for (let i = 0; i < inputShape.length; ++i) {\n            if (!axes.includes(i)) {\n              starts.splice(i, 0, 0);\n              ends.splice(i, 0, inputShape[i]);\n              steps.splice(i, 0, 1);\n            }\n          }\n        }\n        const signs = steps.map((step) => Math.sign(step));\n        steps.forEach((step, i, array) => {\n          if (step < 0) {\n            const numSteps = (ends[i] - starts[i]) / step;\n            const newEnd = starts[i];\n            const newStart = newEnd + numSteps * steps[i];\n            starts[i] = newStart;\n            ends[i] = newEnd;\n            array[i] = -step;\n          }\n        });\n        const outputShape = inputShape.slice(0);\n        axes.forEach((axis, _) => {\n          outputShape[axis] = Math.ceil((ends[axis] - starts[axis]) / steps[axis]);\n        });\n        const outputTensorInfo = { dims: outputShape, dataType: inputs[0].dataType };\n        const output = outputVariable(\"output\", inputs[0].dataType, outputShape.length);\n        const input = inputVariable(\"input\", inputs[0].dataType, inputs[0].dims.length);\n        const outputSize = ShapeUtil.size(outputShape);\n        const uniforms = [\n          { name: \"outputSize\", type: \"u32\" },\n          { name: \"starts\", type: \"u32\", length: starts.length },\n          { name: \"signs\", type: \"i32\", length: signs.length },\n          { name: \"steps\", type: \"u32\", length: steps.length }\n        ];\n        const programUniforms = [\n          { type: 12 /* uint32 */, data: outputSize },\n          { type: 12 /* uint32 */, data: starts },\n          { type: 6 /* int32 */, data: signs },\n          { type: 12 /* uint32 */, data: steps },\n          ...createTensorShapeVariables(inputs[0].dims, outputShape)\n        ];\n        const getShaderSource = (shaderHelper) => `\n      ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)}\n        ${calculateInputIndicesImpl(input, output, inputShape)}\n        ${shaderHelper.mainStart()}\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.outputSize\")}\n          let output_indices = ${output.offsetToIndices(\"global_idx\")};\n          let input_indices = calculateInputIndices(output_indices);\n          ${output.setByOffset(\"global_idx\", input.getByIndices(\"input_indices\"))}\n      }`;\n        return {\n          name: \"Slice\",\n          shaderCache: { hint: `${signs.length}_${starts.length}_${steps.length}`, inputDependencies: [\"rank\"] },\n          getShaderSource,\n          getRunData: () => ({\n            outputs: [outputTensorInfo],\n            dispatchGroup: { x: Math.ceil(\n              inputSize / 64\n              /* workgroup size */\n            ) },\n            programUniforms\n          })\n        };\n      };\n      slice = (context, attributes) => {\n        validateInputs24(context.inputs, attributes);\n        const updatedAttributes = createSliceAttributesFromInputs(context.inputs, attributes);\n        context.compute(createSliceProgramInfo(context.inputs, updatedAttributes), { inputs: [0] });\n      };\n      parseSliceAttributes = (attributes) => {\n        const starts = attributes.starts;\n        const ends = attributes.ends;\n        const axes = attributes.axes;\n        return createAttributeWithCacheKey({ starts, ends, axes });\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/softmax.ts\n  var validateInputs25, createSoftmaxProgramInfo, softmax, parseSoftmaxAttributes;\n  var init_softmax = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/softmax.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_attribute_with_cache_key();\n      init_common();\n      validateInputs25 = (inputs) => {\n        if (!inputs || inputs.length !== 1) {\n          throw new Error(\"Softmax op requires 1 input.\");\n        }\n      };\n      createSoftmaxProgramInfo = (input, attributes) => {\n        const shape = input.dims;\n        const outputSize = ShapeUtil.size(shape);\n        const WG = 64;\n        let axis = attributes.axis;\n        if (axis < 0) {\n          axis = shape.length + axis;\n        }\n        if (axis < shape.length - 1) {\n          throw new Error(\"softmax only supports last axis for now.\");\n        }\n        const cols = shape[axis];\n        const rows = outputSize / cols;\n        const components = getMaxComponents(cols);\n        const packedCols = cols / components;\n        const maxVector = (name, components2) => {\n          if (components2 === 4) {\n            return `max(max(${name}.x, ${name}.y), max(${name}.z, ${name}.w))`;\n          } else if (components2 === 2) {\n            return `max(${name}.x, ${name}.y)`;\n          } else if (components2 === 3) {\n            return `max(max(${name}.x, ${name}.y), ${name}.z)`;\n          }\n          return name;\n        };\n        const x = inputVariable(\"x\", input.dataType, input.dims, components);\n        const output = outputVariable(\"result\", input.dataType, input.dims, components);\n        const valueType = x.type.value;\n        const threadMaxDecl = tensorTypeToWsglStorageType(input.dataType) === \"f32\" ? `var threadMax = ${valueType}(-3.402823e+38f);` : `var threadMax = ${valueType}(-65504.0h);`;\n        const getShaderSource = (shaderHelper) => `\n      var<workgroup> rowMaxShared : ${valueType};\n      var<workgroup> rowSumShared : ${valueType};\n      var<workgroup> threadShared : array<${valueType}, ${WG}>;\n\n      fn getValue(row: i32, col: i32, row_stride: i32) -> ${valueType} {\n        let index = row * row_stride + col;\n        return x[index];\n      }\n\n      fn setValue(row: i32, col: i32, row_stride: i32, value: ${valueType}) {\n        let index = row * row_stride + col;\n        result[index] = value;\n      }\n      ${shaderHelper.registerUniform(\"packedCols\", \"i32\").declareVariables(x, output)}\n      ${shaderHelper.mainStart()}\n        let gindex = i32(global_idx);\n        let lindex = i32(local_idx);\n        const wg = ${WG};\n        let row = gindex / wg;\n        let cols = uniforms.packedCols;\n        let row_stride : i32 = uniforms.packedCols;\n\n        // find the rows max\n        ${threadMaxDecl}\n        for (var col = lindex; col < cols; col += wg) {\n          let value = getValue(row, col, row_stride);\n          threadMax = max(threadMax, value);\n        }\n        if (lindex < cols) {\n          threadShared[lindex] = threadMax;\n        }\n        workgroupBarrier();\n\n        var reduceSize = min(cols, wg);\n        for (var currSize = reduceSize >> 1;  currSize > 0; currSize = reduceSize >> 1) {\n          reduceSize = currSize + (reduceSize & 1);\n          if (lindex < currSize) {\n            threadShared[lindex] = max(threadShared[lindex], threadShared[lindex + reduceSize]);\n          }\n          workgroupBarrier();\n        }\n        if (lindex == 0) {\n          rowMaxShared = ${valueType}(${maxVector(\"threadShared[0]\", components)});\n        }\n        workgroupBarrier();\n\n        // find the rows sum\n        var threadSum = ${valueType}(0.0);\n        for (var col = lindex; col < cols; col += wg) {\n          let subExp = exp(getValue(row, col, row_stride) - rowMaxShared);\n          threadSum += subExp;\n        }\n        threadShared[lindex] = threadSum;\n        workgroupBarrier();\n\n        for (var currSize = wg >> 1;  currSize > 0; currSize = currSize >> 1) {\n          if (lindex < currSize) {\n            threadShared[lindex] = threadShared[lindex] + threadShared[lindex + currSize];\n          }\n          workgroupBarrier();\n        }\n        if (lindex == 0) {\n          rowSumShared = ${valueType}(${sumVector(\"threadShared[0]\", components)});\n        }\n        workgroupBarrier();\n\n        // calculate final value for each element in the row\n        for (var col = lindex; col < cols; col += wg) {\n          let value = exp(getValue(row, col, row_stride) - rowMaxShared) / rowSumShared;\n          setValue(row, col, row_stride, value);\n        }\n      }`;\n        return {\n          name: \"Softmax\",\n          shaderCache: { hint: `${components}`, inputDependencies: [\"type\"] },\n          getRunData: () => ({\n            outputs: [{ dims: shape, dataType: input.dataType }],\n            dispatchGroup: { x: rows },\n            programUniforms: [{ type: 6 /* int32 */, data: packedCols }]\n          }),\n          getShaderSource\n        };\n      };\n      softmax = (context, attributes) => {\n        validateInputs25(context.inputs);\n        context.compute(createSoftmaxProgramInfo(context.inputs[0], attributes));\n      };\n      parseSoftmaxAttributes = (attributes) => createAttributeWithCacheKey({ axis: attributes.axis });\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/split.ts\n  var validateInputs26, createSplitAttributesFromInputs, calculateOutputIndexImpl, writeBufferDataImpl, createSplitProgramInfo, split, parseSplitAttributes;\n  var init_split = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/split.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_attribute_with_cache_key();\n      init_common();\n      validateInputs26 = (inputs) => {\n        if (!inputs || inputs.length < 1) {\n          throw new Error(\"too few inputs\");\n        }\n      };\n      createSplitAttributesFromInputs = (inputs, attributes) => {\n        const splitSizes = [];\n        let numOutputs = attributes.numOutputs;\n        if (inputs[1].dims[0] > 0) {\n          inputs[1].getBigInt64Array().forEach((v) => splitSizes.push(Number(v)));\n          numOutputs = splitSizes.length;\n        }\n        return createAttributeWithCacheKey({ numOutputs, axis: attributes.axis, splitSizes });\n      };\n      calculateOutputIndexImpl = (numberOfTensors) => `\nfn calculateOutputIndex(index: u32) -> u32 {\n    for (var i: u32 = 0u; i < ${numberOfTensors}u; i += 1u ) {\n    if (index < ${getElementAt(\"uniforms.size_in_split_axis\", \"i\", numberOfTensors)}) {\n        return i;\n    }\n    }\n    return ${numberOfTensors}u;\n}`;\n      writeBufferDataImpl = (outputs) => {\n        const numberOfTensors = outputs.length;\n        const codeLines = [];\n        for (let i = 0; i < numberOfTensors; ++i) {\n          const returnSnippet = outputs[i].setByIndices(\"indices\", \"input[global_idx]\");\n          if (numberOfTensors === 1) {\n            codeLines.push(returnSnippet);\n          } else if (i === 0) {\n            codeLines.push(`if (output_number == ${i}u) { ${returnSnippet} }`);\n          } else if (i === numberOfTensors - 1) {\n            codeLines.push(`else { ${returnSnippet} }`);\n          } else {\n            codeLines.push(`else if (output_number == ${i}) { ${returnSnippet} }`);\n          }\n        }\n        return `\n      fn writeBufferData(output_number: u32, indices: ${outputs[0].type.indices}, global_idx: u32) {\n        ${codeLines.join(\"\\n\")}\n      }`;\n      };\n      createSplitProgramInfo = (inputs, attributes) => {\n        const inputShape = inputs[0].dims;\n        const inputSize = ShapeUtil.size(inputShape);\n        const dataType = inputs[0].dataType;\n        const axis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);\n        const outputs = new Array(attributes.numOutputs);\n        const input = inputVariable(\"input\", dataType, inputShape.length);\n        const sizeInSplitAxis = new Array(attributes.numOutputs);\n        const outputsTensorInfo = [];\n        const outputShapes = [];\n        let previousSum = 0;\n        const programUniforms = [{ type: 12 /* uint32 */, data: inputSize }];\n        for (let i = 0; i < attributes.numOutputs; i++) {\n          previousSum += attributes.splitSizes[i];\n          sizeInSplitAxis[i] = previousSum;\n          const outputShape = inputShape.slice();\n          outputShape[attributes.axis] = attributes.splitSizes[i];\n          outputShapes.push(outputShape);\n          outputs[i] = outputVariable(`output${i}`, dataType, outputShape.length);\n          outputsTensorInfo.push({ dims: outputShapes[i], dataType: inputs[0].dataType });\n        }\n        programUniforms.push(\n          { type: 12 /* uint32 */, data: sizeInSplitAxis },\n          ...createTensorShapeVariables(inputShape, ...outputShapes)\n        );\n        const getShaderSource = (shaderHelper) => `\n  ${shaderHelper.registerUniform(\"input_size\", \"u32\").registerUniform(\"size_in_split_axis\", \"u32\", sizeInSplitAxis.length).declareVariables(input, ...outputs)}\n  ${calculateOutputIndexImpl(sizeInSplitAxis.length)}\n  ${writeBufferDataImpl(outputs)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.input_size\")}\n\n    var indices = ${input.offsetToIndices(\"global_idx\")};\n    var index = ${input.indicesGet(\"indices\", axis)};\n    let output_number = calculateOutputIndex(index);\n    if (output_number != 0) {\n      index -= ${getElementAt(\"uniforms.size_in_split_axis\", \"output_number - 1u\", sizeInSplitAxis.length)};\n      ${input.indicesSet(\"indices\", axis, \"index\")};\n    }\n    writeBufferData(output_number, indices, global_idx);\n  }`;\n        return {\n          name: \"Split\",\n          shaderCache: { hint: attributes.cacheKey, inputDependencies: [\"rank\"] },\n          getShaderSource,\n          getRunData: () => ({\n            outputs: outputsTensorInfo,\n            dispatchGroup: { x: Math.ceil(\n              inputSize / 64\n              /* workgroup size */\n            ) },\n            programUniforms\n          })\n        };\n      };\n      split = (context, attributes) => {\n        validateInputs26(context.inputs);\n        const updatedAttributes = context.inputs.length === 1 ? attributes : createSplitAttributesFromInputs(context.inputs, attributes);\n        context.compute(createSplitProgramInfo(context.inputs, updatedAttributes), { inputs: [0] });\n      };\n      parseSplitAttributes = (attributes) => {\n        const axis = attributes.axis;\n        const splitSizes = attributes.splitSizes;\n        const numOutputs = attributes.numOutputs < 0 ? splitSizes.length : attributes.numOutputs;\n        if (numOutputs !== splitSizes.length) {\n          throw new Error(\"numOutputs and splitSizes lengh must be equal\");\n        }\n        return createAttributeWithCacheKey({ axis, numOutputs, splitSizes });\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/tile.ts\n  var getRepeats, validateInputs27, getOutputShape2, createTileProgramInfo, tile;\n  var init_tile = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/tile.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_common();\n      getRepeats = (repeatsTensorView) => Array.from(repeatsTensorView.getBigInt64Array(), Number);\n      validateInputs27 = (inputs) => {\n        if (!inputs || inputs.length !== 2) {\n          throw new Error(\"Tile requires 2 inputs.\");\n        }\n        if (inputs[0].dataType !== 1 /* float */ && inputs[0].dataType !== 6 /* int32 */ && inputs[0].dataType !== 12 /* uint32 */) {\n          throw new Error(\"Tile only support float, int32, and uint32 data types\");\n        }\n        if (inputs[1].dataType !== 7 /* int64 */) {\n          throw new Error(\"Tile `repeats` input should be of int64 data type\");\n        }\n        if (inputs[1].dims.length !== 1) {\n          throw new Error(\"Tile `repeats` input should be 1-D\");\n        }\n        const repeats = getRepeats(inputs[1]);\n        if (repeats.length !== inputs[0].dims.length) {\n          throw new Error(\"Tile `repeats` input should have same number of elements as rank of input data tensor\");\n        }\n      };\n      getOutputShape2 = (inputShape, repeats) => {\n        const outputShape = [];\n        for (let i = 0; i < inputShape.length; ++i) {\n          outputShape.push(inputShape[i] * repeats[i]);\n        }\n        return outputShape;\n      };\n      createTileProgramInfo = (inputs) => {\n        const inputShape = inputs[0].dims;\n        const repeats = getRepeats(inputs[1]);\n        const outputShape = getOutputShape2(inputShape, repeats);\n        const outputSize = ShapeUtil.size(outputShape);\n        const dataType = inputs[0].dataType;\n        const input = inputVariable(\"input\", dataType, inputShape.length);\n        const output = outputVariable(\"output\", dataType, outputShape.length);\n        const getShaderSource = (shaderHelper) => `\n      const inputShape = ${input.indices(...inputShape)};\n      ${shaderHelper.registerUniform(\"output_size\", \"u32\").declareVariables(input, output)}\n      ${shaderHelper.mainStart()}\n      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.output_size\")}\n      let output_indices = ${output.offsetToIndices(\"global_idx\")};\n      var input_indices: ${input.type.indices};\n      for (var i = 0; i < ${inputShape.length}; i++) {\n        let input_dim_i = ${input.indicesGet(\"uniforms.input_shape\", \"i\")};\n        let input_dim_value = ${output.indicesGet(\"output_indices\", \"i\")}  % input_dim_i;\n\n        ${input.indicesSet(\"input_indices\", \"i\", \"input_dim_value\")}\n      }\n      ${output.setByOffset(\"global_idx\", input.getByIndices(\"input_indices\"))}\n    }`;\n        return {\n          name: \"Tile\",\n          shaderCache: { hint: `${repeats}`, inputDependencies: [\"rank\"] },\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64\n              /* workgroup size */\n            ) },\n            programUniforms: [{ type: 12 /* uint32 */, data: outputSize }, ...createTensorShapeVariables(inputs[0].dims, outputShape)]\n          }),\n          getShaderSource\n        };\n      };\n      tile = (context) => {\n        validateInputs27(context.inputs);\n        context.compute(createTileProgramInfo(context.inputs), { inputs: [0] });\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/ops/where.ts\n  var createWhereOpProgramShader, createWhereOpProgramInfo, where;\n  var init_where = __esm({\n    \"web/lib/wasm/jsep/webgpu/ops/where.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_util();\n      init_common();\n      createWhereOpProgramShader = (shaderHelper, inputs, dimsOutput, isBroadcast, typeOutput) => {\n        const output = outputVariable(\"output_data\", typeOutput, dimsOutput.length, 4);\n        const a = inputVariable(\"a_data\", inputs[1].dataType, inputs[1].dims.length, 4);\n        const b = inputVariable(\"b_data\", inputs[2].dataType, inputs[2].dims.length, 4);\n        const c = inputVariable(\"c_data\", inputs[0].dataType, inputs[0].dims.length, 4);\n        let assignment;\n        const expression = (a2, b2, c2) => `select(${b2}, ${a2}, ${c2})`;\n        if (!isBroadcast) {\n          assignment = output.setByOffset(\n            \"global_idx\",\n            expression(a.getByOffset(\"global_idx\"), b.getByOffset(\"global_idx\"), c.getByOffset(\"global_idx\"))\n          );\n        } else {\n          const singleAssignment = (resStr, x, typeCast = \"\") => {\n            const expressionA = `a_data[index_a${x}][component_a${x}]`;\n            const expressionB = `b_data[index_b${x}][component_b${x}]`;\n            const expressionC = `bool(c_data[index_c${x}] & (0xffu << (component_c${x} * 8)))`;\n            return `\n            let output_indices${x} = ${output.offsetToIndices(`global_idx * 4u + ${x}u`)};\n            let offset_a${x} = ${a.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n            let offset_b${x} = ${b.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n            let offset_c${x} = ${c.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n            let index_a${x} = offset_a${x} / 4u;\n            let index_b${x} = offset_b${x} / 4u;\n            let index_c${x} = offset_c${x} / 4u;\n            let component_a${x} = offset_a${x} % 4u;\n            let component_b${x} = offset_b${x} % 4u;\n            let component_c${x} = offset_c${x} % 4u;\n            ${resStr}[${x}] = ${typeCast}(${expression(expressionA, expressionB, expressionC)});\n          `;\n          };\n          if (typeOutput === 9 /* bool */) {\n            assignment = `\n            var data = vec4<u32>(0);\n            ${singleAssignment(\"data\", 0, \"u32\")}\n            ${singleAssignment(\"data\", 1, \"u32\")}\n            ${singleAssignment(\"data\", 2, \"u32\")}\n            ${singleAssignment(\"data\", 3, \"u32\")}\n            output_data[global_idx] = dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(data));`;\n          } else {\n            assignment = `\n            ${singleAssignment(\"output_data[global_idx]\", 0)}\n            ${singleAssignment(\"output_data[global_idx]\", 1)}\n            ${singleAssignment(\"output_data[global_idx]\", 2)}\n            ${singleAssignment(\"output_data[global_idx]\", 3)}\n          `;\n          }\n        }\n        return `\n        ${shaderHelper.registerUniform(\"vec_size\", \"u32\").declareVariables(c, a, b, output)}\n        ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(\"uniforms.vec_size\")}\n        ${assignment}\n      }`;\n      };\n      createWhereOpProgramInfo = (inputs) => {\n        const dimsA = inputs[1].dims;\n        const dimsB = inputs[2].dims;\n        const dimsC = inputs[0].dims;\n        const outputDataType = inputs[1].dataType;\n        const isBroadcast = !(ShapeUtil.areEqual(dimsA, dimsB) && ShapeUtil.areEqual(dimsB, dimsC));\n        let outputShape = dimsA;\n        let outputSize = ShapeUtil.size(dimsA);\n        if (isBroadcast) {\n          const calculatedShape = BroadcastUtil.calcShape(BroadcastUtil.calcShape(dimsA, dimsB, false), dimsC, false);\n          if (!calculatedShape) {\n            throw new Error(\"Can't perform where op on the given tensors\");\n          }\n          outputShape = calculatedShape;\n          outputSize = ShapeUtil.size(outputShape);\n        }\n        const vecSize = Math.ceil(outputSize / 4);\n        return {\n          name: \"Where\",\n          shaderCache: { inputDependencies: [\"rank\", \"rank\", \"rank\"] },\n          getShaderSource: (shaderHelper) => createWhereOpProgramShader(shaderHelper, inputs, outputShape, isBroadcast, outputDataType),\n          getRunData: () => ({\n            outputs: [{ dims: outputShape, dataType: outputDataType }],\n            dispatchGroup: { x: Math.ceil(\n              outputSize / 64 / 4\n              /* vec size */\n            ) },\n            programUniforms: [{ type: 12 /* uint32 */, data: vecSize }, ...createTensorShapeVariables(dimsC, dimsA, dimsB, outputShape)]\n          })\n        };\n      };\n      where = (context) => {\n        context.compute(createWhereOpProgramInfo(context.inputs));\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/op-resolve-rules.ts\n  var WEBGPU_OP_RESOLVE_RULES;\n  var init_op_resolve_rules = __esm({\n    \"web/lib/wasm/jsep/webgpu/op-resolve-rules.ts\"() {\n      \"use strict\";\n      init_argminmax();\n      init_attention();\n      init_batch_norm();\n      init_bias_add();\n      init_bias_split_gelu();\n      init_binary_op();\n      init_concat();\n      init_conv();\n      init_conv_transpose();\n      init_cumsum();\n      init_depth_to_space();\n      init_einsum();\n      init_expand();\n      init_fast_gelu();\n      init_gather();\n      init_gather_elements();\n      init_gemm();\n      init_instance_norm();\n      init_layer_norm();\n      init_matmul();\n      init_matmulnbits();\n      init_multihead_attentiion();\n      init_pad();\n      init_pool();\n      init_range();\n      init_reduce();\n      init_resize();\n      init_rotary_embedding();\n      init_skip_layer_norm();\n      init_slice();\n      init_softmax();\n      init_split();\n      init_tile();\n      init_transpose();\n      init_unary_op();\n      init_where();\n      WEBGPU_OP_RESOLVE_RULES = /* @__PURE__ */ new Map([\n        [\"Abs\", [abs]],\n        [\"Acos\", [acos]],\n        [\"Acosh\", [acosh]],\n        [\"Add\", [add]],\n        [\"ArgMax\", [argMax, parseArgMinMaxAttributes]],\n        [\"ArgMin\", [argMin, parseArgMinMaxAttributes]],\n        [\"Asin\", [asin]],\n        [\"Asinh\", [asinh]],\n        [\"Atan\", [atan]],\n        [\"Atanh\", [atanh]],\n        [\"Attention\", [attention]],\n        // TODO: support new attributes for AveragePool-10\n        [\"AveragePool\", [averagePool, parseAveragePoolAttributes]],\n        [\"BatchNormalization\", [batchNorm]],\n        [\"BiasAdd\", [biasAdd]],\n        [\"BiasSplitGelu\", [biasSplitGelu]],\n        [\"Cast\", [cast, parseCastAttributes]],\n        [\"Ceil\", [ceil]],\n        [\"Clip\", [clip]],\n        [\"Concat\", [concat, parseConcatAttributes]],\n        [\"Conv\", [conv, parseConvAttributes]],\n        [\"ConvTranspose\", [convTranspose, parseConvTransposeAttributes]],\n        [\"Cos\", [cos]],\n        [\"Cosh\", [cosh]],\n        [\"CumSum\", [cumsum, parseCumSumAttributes]],\n        [\"DepthToSpace\", [depthToSpace, parseDepthToSpaceAttributes]],\n        [\"Div\", [div]],\n        [\"Einsum\", [einsum, parseEinsumAttributes]],\n        [\"Elu\", [elu, parseAlphaAttributes]],\n        [\"Equal\", [equal]],\n        [\"Erf\", [erf]],\n        [\"Exp\", [exp]],\n        [\"Expand\", [expand]],\n        [\"FastGelu\", [fastGelu2]],\n        [\"Floor\", [floor]],\n        [\"FusedConv\", [conv, parseConvAttributes]],\n        [\"Gather\", [gather, parseGatherAttributes]],\n        [\"GatherElements\", [gatherElements, parseGatherElementsAttributes]],\n        [\"Gelu\", [gelu]],\n        [\"Gemm\", [gemm, parseGemmAttributes]],\n        [\"GlobalAveragePool\", [globalAveragePool, parseGlobalAveragePoolAttributes]],\n        [\"GlobalMaxPool\", [globalMaxPool, parseGlobalMaxPoolAttributes]],\n        [\"Greater\", [greater]],\n        [\"GreaterOrEqual\", [greaterOrEqual]],\n        [\"HardSigmoid\", [hardSigmoid, parseHardSigmoidAttributes]],\n        [\"InstanceNormalization\", [instanceNorm]],\n        [\"LayerNormalization\", [layerNorm]],\n        [\"LeakyRelu\", [leakyRelu, parseAlphaAttributes]],\n        [\"Less\", [less]],\n        [\"LessOrEqual\", [lessOrEqual]],\n        [\"Log\", [log]],\n        [\"MatMul\", [matMul]],\n        [\"MatMulNBits\", [matMulNBits, parseMatMulNBitsAttributes]],\n        // TODO: support new attributes for MaxPool-8 and MaxPool-10\n        [\"MaxPool\", [maxPool, parseMaxPoolAttributes]],\n        [\"Mul\", [mul]],\n        [\"MultiHeadAttention\", [multiHeadAttention, parseMultiHeadAttentionAttributes]],\n        [\"Neg\", [neg]],\n        [\"Not\", [not]],\n        [\"Pad\", [pad]],\n        [\"Pow\", [pow]],\n        [\"Range\", [range]],\n        [\"Reciprocal\", [reciprocal]],\n        [\"ReduceMin\", [reduceMin]],\n        [\"ReduceMean\", [reduceMean]],\n        [\"ReduceMax\", [reduceMax]],\n        [\"ReduceSum\", [reduceSum]],\n        [\"ReduceProd\", [reduceProd]],\n        [\"ReduceL1\", [reduceL1]],\n        [\"ReduceL2\", [reduceL2]],\n        [\"ReduceLogSum\", [reduceLogSum]],\n        [\"ReduceLogSumExp\", [reduceLogSumExp]],\n        [\"ReduceSumSquare\", [reduceSumSquare]],\n        [\"Relu\", [relu]],\n        [\"Resize\", [resize, parseResizeAttributes]],\n        [\"RotaryEmbedding\", [rotaryEmbedding]],\n        [\"Sigmoid\", [sigmoid]],\n        [\"Sin\", [sin]],\n        [\"Sinh\", [sinh]],\n        [\"Slice\", [slice, parseSliceAttributes]],\n        [\"SkipLayerNormalization\", [skipLayerNorm]],\n        [\"Split\", [split, parseSplitAttributes]],\n        [\"Sqrt\", [sqrt]],\n        [\"Softmax\", [softmax, parseSoftmaxAttributes]],\n        [\"Sub\", [sub]],\n        [\"Tan\", [tan]],\n        [\"Tanh\", [tanh]],\n        [\"ThresholdedRelu\", [thresholdedRelu, parseAlphaAttributes]],\n        [\"Tile\", [tile]],\n        [\"Transpose\", [transpose, parseTransposeAttributes]],\n        [\"Where\", [where]]\n      ]);\n    }\n  });\n\n  // web/lib/wasm/jsep/webgpu/program-manager.ts\n  var ProgramManager;\n  var init_program_manager = __esm({\n    \"web/lib/wasm/jsep/webgpu/program-manager.ts\"() {\n      \"use strict\";\n      init_esm();\n      init_log();\n      init_common();\n      ProgramManager = class {\n        constructor(backend) {\n          this.backend = backend;\n          this.repo = /* @__PURE__ */ new Map();\n          this.attributesBound = false;\n        }\n        getArtifact(key) {\n          return this.repo.get(key);\n        }\n        setArtifact(key, artifact) {\n          this.repo.set(key, artifact);\n        }\n        run(buildArtifact, inputs, outputs, dispatchGroup, uniformBufferBinding) {\n          TRACE_FUNC_BEGIN(buildArtifact.programInfo.name);\n          const device = this.backend.device;\n          const computePassEncoder = this.backend.getComputePassEncoder();\n          this.backend.writeTimestamp(this.backend.pendingDispatchNumber * 2);\n          const entries = [];\n          for (const input of inputs) {\n            entries.push({ binding: entries.length, resource: { buffer: input.buffer } });\n          }\n          for (const output of outputs) {\n            entries.push({ binding: entries.length, resource: { buffer: output.buffer } });\n          }\n          if (uniformBufferBinding) {\n            entries.push({ binding: entries.length, resource: uniformBufferBinding });\n          }\n          const bindGroup = device.createBindGroup(\n            { layout: buildArtifact.computePipeline.getBindGroupLayout(0), entries, label: buildArtifact.programInfo.name }\n          );\n          if (this.backend.sessionStatus === \"capturing\") {\n            const commandInfo = {\n              kernelId: this.backend.currentKernelId,\n              computePipeline: buildArtifact.computePipeline,\n              bindGroup,\n              dispatchGroup\n            };\n            const sessionCommandList = this.backend.capturedCommandList.get(this.backend.currentSessionId);\n            sessionCommandList.push(commandInfo);\n          }\n          computePassEncoder.setPipeline(buildArtifact.computePipeline);\n          computePassEncoder.setBindGroup(0, bindGroup);\n          computePassEncoder.dispatchWorkgroups(...dispatchGroup);\n          this.backend.writeTimestamp(this.backend.pendingDispatchNumber * 2 + 1);\n          this.backend.pendingDispatchNumber++;\n          if (this.backend.pendingDispatchNumber >= this.backend.maxDispatchNumber || this.backend.queryType === \"at-passes\") {\n            this.backend.endComputePass();\n          }\n          if (this.backend.pendingDispatchNumber >= this.backend.maxDispatchNumber) {\n            this.backend.flush();\n          }\n          TRACE_FUNC_END(buildArtifact.programInfo.name);\n        }\n        dispose() {\n        }\n        build(programInfo, normalizedDispatchGroupSize) {\n          TRACE_FUNC_BEGIN(programInfo.name);\n          const device = this.backend.device;\n          const extensions = [];\n          if (device.features.has(\"shader-f16\")) {\n            extensions.push(\"enable f16;\");\n          }\n          const shaderHelper = createShaderHelper(normalizedDispatchGroupSize, this.backend.device.limits);\n          const userCode = programInfo.getShaderSource(shaderHelper);\n          const code = `${extensions.join(\"\\n\")}\n${shaderHelper.additionalImplementations}\n${userCode}`;\n          const shaderModule = device.createShaderModule({ code, label: programInfo.name });\n          LOG_DEBUG(\"verbose\", () => `[WebGPU] ${programInfo.name} shader code: ${code}`);\n          const computePipeline = device.createComputePipeline(\n            { compute: { module: shaderModule, entryPoint: \"main\" }, layout: \"auto\", label: programInfo.name }\n          );\n          TRACE_FUNC_END(programInfo.name);\n          return { programInfo, computePipeline, uniformVariablesInfo: shaderHelper.variablesInfo };\n        }\n        normalizeDispatchGroupSize(dispatchGroup) {\n          const x = typeof dispatchGroup === \"number\" ? dispatchGroup : dispatchGroup.x;\n          const y = typeof dispatchGroup === \"number\" ? 1 : dispatchGroup.y || 1;\n          const z = typeof dispatchGroup === \"number\" ? 1 : dispatchGroup.z || 1;\n          const limitPerDimension = this.backend.device.limits.maxComputeWorkgroupsPerDimension;\n          if (x <= limitPerDimension && y <= limitPerDimension && z <= limitPerDimension) {\n            return [x, y, z];\n          }\n          const size = x * y * z;\n          let dispatchAverage = Math.ceil(Math.sqrt(size));\n          if (dispatchAverage > limitPerDimension) {\n            dispatchAverage = Math.ceil(Math.cbrt(size));\n            if (dispatchAverage > limitPerDimension) {\n              throw new Error(\"Total dispatch size exceeds WebGPU maximum.\");\n            }\n            return [dispatchAverage, dispatchAverage, dispatchAverage];\n          } else {\n            return [dispatchAverage, dispatchAverage, 1];\n          }\n        }\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/backend-webgpu.ts\n  var getProgramInputTensorInfoDependencyKey, getProgramInfoUniqueKey, AdapterInfoImpl, WebGpuBackend;\n  var init_backend_webgpu = __esm({\n    \"web/lib/wasm/jsep/backend-webgpu.ts\"() {\n      \"use strict\";\n      init_esm();\n      init_wasm_common();\n      init_log();\n      init_tensor_view();\n      init_gpu_data_manager();\n      init_op_resolve_rules();\n      init_program_manager();\n      getProgramInputTensorInfoDependencyKey = (inputTensors, inputDependencies) => {\n        if (inputDependencies.length !== inputTensors.length) {\n          throw new Error(`inputDependencies length ${inputDependencies.length} is not equal to inputTensors length ${inputTensors.length}.`);\n        }\n        const inputInfos = [];\n        for (let i = 0; i < inputTensors.length; ++i) {\n          const type = inputTensors[i].dataType;\n          switch (inputDependencies[i]) {\n            case \"none\": {\n              inputInfos.push(\"\");\n              break;\n            }\n            case \"type\": {\n              inputInfos.push(`${type}`);\n              break;\n            }\n            case \"rank\": {\n              const rank = inputTensors[i].dims.length;\n              inputInfos.push(`${type};${rank}`);\n              break;\n            }\n            case \"dims\": {\n              const dims = inputTensors[i].dims.join(\",\");\n              inputInfos.push(`${type};${dims}`);\n              break;\n            }\n            default:\n              throw new Error(`unsupported input dependency: ${inputDependencies[i]}`);\n          }\n        }\n        return inputInfos.join(\"|\");\n      };\n      getProgramInfoUniqueKey = (programInfo, inputTensors, is1DimensionDispatch) => {\n        let key = programInfo.name;\n        if (programInfo.shaderCache?.hint) {\n          key += \"[\" + programInfo.shaderCache.hint + \"]\";\n        }\n        key += \":\" + is1DimensionDispatch + `:${getProgramInputTensorInfoDependencyKey(\n          inputTensors,\n          programInfo.shaderCache?.inputDependencies ?? new Array(inputTensors.length).fill(\"dims\")\n        )}`;\n        return key;\n      };\n      AdapterInfoImpl = class {\n        constructor(adapterInfo) {\n          if (adapterInfo) {\n            this.architecture = adapterInfo.architecture;\n            this.vendor = adapterInfo.vendor;\n          }\n        }\n        isArchitecture(architecture) {\n          return this.architecture === architecture;\n        }\n        isVendor(vendor) {\n          return this.vendor === vendor;\n        }\n      };\n      WebGpuBackend = class {\n        constructor() {\n          /**\n           * representing the session ID of which is currently being run.\n           * `null` means no session is being run.\n           * only valid when session.run is executed.\n           */\n          this.currentSessionId = null;\n          /**\n           * representing the kernel ID of which is currently being computed (CPU code perspective).\n           * `null` means no kernel is being computed.\n           * only one kernel can be computed at a moment.\n           */\n          this.currentKernelId = null;\n          this.commandEncoder = null;\n          this.computePassEncoder = null;\n          this.maxDispatchNumber = 16;\n          this.pendingDispatchNumber = 0;\n          // info of kernels pending submission for a single batch\n          this.pendingKernels = [];\n          // queryReadBuffer -> pendingKernels mapping for all the batches\n          this.pendingQueries = /* @__PURE__ */ new Map();\n          this.sessionStatus = \"default\";\n          /**\n           * a SessionID -> CommandInfo[] mapping. It's used to record all GPU commands for corresponding session.\n           */\n          this.capturedCommandList = /* @__PURE__ */ new Map();\n          /**\n           * a SessionID -> PendingKernelInfo[] mapping for profiling.\n           */\n          this.capturedPendingKernels = /* @__PURE__ */ new Map();\n          /**\n           * a SessionID -> a Map of (InputOutputIndex -> [ID, GPUBuffer]) mapping.\n           */\n          this.sessionExternalDataMapping = /* @__PURE__ */ new Map();\n        }\n        /**\n         * get the custom data of the current kernel\n         */\n        get currentKernelCustomData() {\n          if (this.currentKernelId === null) {\n            throw new Error(\"currentKernelCustomData(): currentKernelId is null. (should not happen)\");\n          }\n          let data = this.kernelCustomData.get(this.currentKernelId);\n          if (!data) {\n            data = {};\n            this.kernelCustomData.set(this.currentKernelId, data);\n          }\n          return data;\n        }\n        async initialize(env3, adapter) {\n          this.env = env3;\n          const requiredFeatures = [];\n          const deviceDescriptor = {\n            requiredLimits: {\n              maxComputeWorkgroupStorageSize: adapter.limits.maxComputeWorkgroupStorageSize,\n              maxComputeWorkgroupsPerDimension: adapter.limits.maxComputeWorkgroupsPerDimension,\n              maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,\n              maxBufferSize: adapter.limits.maxBufferSize,\n              maxComputeInvocationsPerWorkgroup: adapter.limits.maxComputeInvocationsPerWorkgroup,\n              maxComputeWorkgroupSizeX: adapter.limits.maxComputeWorkgroupSizeX,\n              maxComputeWorkgroupSizeY: adapter.limits.maxComputeWorkgroupSizeY,\n              maxComputeWorkgroupSizeZ: adapter.limits.maxComputeWorkgroupSizeZ\n            },\n            requiredFeatures\n          };\n          if (adapter.features.has(\"chromium-experimental-timestamp-query-inside-passes\")) {\n            requiredFeatures.push(\"chromium-experimental-timestamp-query-inside-passes\");\n          } else if (adapter.features.has(\"timestamp-query\")) {\n            requiredFeatures.push(\"timestamp-query\");\n          }\n          if (adapter.features.has(\"shader-f16\")) {\n            requiredFeatures.push(\"shader-f16\");\n          }\n          this.device = await adapter.requestDevice(deviceDescriptor);\n          this.adapterInfo = new AdapterInfoImpl(await adapter.requestAdapterInfo());\n          this.gpuDataManager = createGpuDataManager(this);\n          this.programManager = new ProgramManager(this);\n          this.kernels = /* @__PURE__ */ new Map();\n          this.kernelPersistentData = /* @__PURE__ */ new Map();\n          this.kernelCustomData = /* @__PURE__ */ new Map();\n          configureLogger(env3.logLevel, !!env3.debug);\n          this.device.onuncapturederror = (ev) => {\n            if (ev.error instanceof GPUValidationError) {\n              console.error(`An uncaught WebGPU validation error was raised: ${ev.error.message}`);\n            }\n          };\n          Object.defineProperty(\n            this.env.webgpu,\n            \"device\",\n            { value: this.device, writable: false, enumerable: true, configurable: false }\n          );\n          Object.defineProperty(\n            this.env.webgpu,\n            \"adapter\",\n            { value: adapter, writable: false, enumerable: true, configurable: false }\n          );\n          this.setQueryType();\n        }\n        dispose() {\n          if (typeof this.querySet !== \"undefined\") {\n            this.querySet.destroy();\n          }\n          this.gpuDataManager.dispose();\n        }\n        getCommandEncoder() {\n          if (!this.commandEncoder) {\n            this.commandEncoder = this.device.createCommandEncoder();\n          }\n          return this.commandEncoder;\n        }\n        getComputePassEncoder() {\n          if (!this.computePassEncoder) {\n            const commandEncoder = this.getCommandEncoder();\n            const computePassDescriptor = {};\n            if (this.queryType === \"at-passes\") {\n              computePassDescriptor.timestampWrites = {\n                querySet: this.querySet,\n                beginningOfPassWriteIndex: this.pendingDispatchNumber * 2,\n                endOfPassWriteIndex: this.pendingDispatchNumber * 2 + 1\n              };\n            }\n            this.computePassEncoder = commandEncoder.beginComputePass(computePassDescriptor);\n          }\n          return this.computePassEncoder;\n        }\n        endComputePass() {\n          if (this.computePassEncoder) {\n            this.computePassEncoder.end();\n            this.computePassEncoder = null;\n          }\n        }\n        flush() {\n          if (!this.commandEncoder) {\n            return;\n          }\n          TRACE_FUNC_BEGIN();\n          this.endComputePass();\n          let queryReadBuffer;\n          if (this.queryType !== \"none\") {\n            this.commandEncoder.resolveQuerySet(\n              this.querySet,\n              0,\n              this.pendingDispatchNumber * 2,\n              this.queryResolveBuffer,\n              0\n            );\n            queryReadBuffer = this.device.createBuffer(\n              // eslint-disable-next-line no-bitwise\n              { size: this.pendingDispatchNumber * 2 * 8, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST }\n            );\n            this.pendingQueries.set(queryReadBuffer, this.pendingKernels);\n            this.pendingKernels = [];\n            this.commandEncoder.copyBufferToBuffer(\n              this.queryResolveBuffer,\n              0,\n              queryReadBuffer,\n              0,\n              this.pendingDispatchNumber * 2 * 8\n            );\n          }\n          this.device.queue.submit([this.commandEncoder.finish()]);\n          this.gpuDataManager.refreshPendingBuffers();\n          this.commandEncoder = null;\n          this.pendingDispatchNumber = 0;\n          if (this.queryType !== \"none\") {\n            void queryReadBuffer.mapAsync(GPUMapMode.READ).then(() => {\n              const mappedData = new BigUint64Array(queryReadBuffer.getMappedRange());\n              const pendingKernels = this.pendingQueries.get(queryReadBuffer);\n              for (let i = 0; i < mappedData.length / 2; i++) {\n                const pendingKernelInfo = pendingKernels[i];\n                const kernelId = pendingKernelInfo.kernelId;\n                const kernelInfo = this.kernels.get(kernelId);\n                const kernelType = kernelInfo.kernelType;\n                const kernelName = kernelInfo.kernelName;\n                const programName = pendingKernelInfo.programName;\n                const inputTensorViews = pendingKernelInfo.inputTensorViews;\n                const outputTensorViews = pendingKernelInfo.outputTensorViews;\n                const startTimeU64 = mappedData[i * 2];\n                const endTimeU64 = mappedData[i * 2 + 1];\n                if (typeof this.queryTimeBase === \"undefined\") {\n                  this.queryTimeBase = startTimeU64;\n                }\n                const startTime = Number(startTimeU64 - this.queryTimeBase);\n                const endTime = Number(endTimeU64 - this.queryTimeBase);\n                if (!Number.isSafeInteger(startTime) || !Number.isSafeInteger(endTime)) {\n                  throw new RangeError(\"incorrect timestamp range\");\n                }\n                if (this.env.webgpu.profiling?.ondata) {\n                  this.env.webgpu.profiling.ondata({\n                    version: 1,\n                    inputsMetadata: inputTensorViews.map(\n                      (value) => ({ dims: value.dims, dataType: tensorDataTypeEnumToString(value.dataType) })\n                    ),\n                    outputsMetadata: outputTensorViews.map(\n                      (value) => ({ dims: value.dims, dataType: tensorDataTypeEnumToString(value.dataType) })\n                    ),\n                    kernelId,\n                    kernelType,\n                    kernelName,\n                    programName,\n                    startTime,\n                    endTime\n                  });\n                } else {\n                  let inputShapes = \"\";\n                  inputTensorViews.forEach((value, i2) => {\n                    inputShapes += `input[${i2}]: [${value.dims}] | ${tensorDataTypeEnumToString(value.dataType)}, `;\n                  });\n                  let outputShapes = \"\";\n                  outputTensorViews.forEach((value, i2) => {\n                    outputShapes += `output[${i2}]: [${value.dims}] | ${tensorDataTypeEnumToString(value.dataType)}, `;\n                  });\n                  console.log(`[profiling] kernel \"${kernelId}|${kernelType}|${kernelName}|${programName}\" ${inputShapes}${outputShapes}execution time: ${endTime - startTime} ns`);\n                }\n                TRACE(\"GPU\", `${programName}::${startTimeU64}::${endTimeU64}`);\n              }\n              queryReadBuffer.unmap();\n              this.pendingQueries.delete(queryReadBuffer);\n            });\n          }\n          TRACE_FUNC_END();\n        }\n        /**\n         * run a WebGPU program.\n         * @param program a ProgramInfo instance\n         * @param inputTensorViews a TensorView array. each element represents a value already exists in GPU.\n         * @param outputIndices an indices array. each element can be either -1 (temporary data), -2 (persistent data) or an\n         * index to the kernel's output.\n         * @param createKernelOutput a callback function that create a value to kernel's output with the given index\n         * @param createIntermediateOutput a callback function that create a value as a intermediate value, either temporary\n         * or persistent (owned by the current kernel)\n         * @returns a TensorView array representing the result.\n         */\n        run(program, inputTensorViews, outputIndices, createKernelOutput, createIntermediateOutput, outputCount) {\n          TRACE_FUNC_BEGIN(program.name);\n          const inputDatas = [];\n          for (let i = 0; i < inputTensorViews.length; ++i) {\n            const data = inputTensorViews[i].data;\n            if (data === 0) {\n              continue;\n            }\n            const gpuData = this.gpuDataManager.get(data);\n            if (!gpuData) {\n              throw new Error(`no GPU data for input: ${data}`);\n            }\n            inputDatas.push(gpuData);\n          }\n          const { outputs, dispatchGroup, programUniforms } = program.getRunData(inputTensorViews);\n          const validatedOutputIndices = outputIndices.length === 0 ? outputs.map((_, i) => i) : outputIndices;\n          if (validatedOutputIndices.length !== outputs.length) {\n            throw new Error(`Output size ${validatedOutputIndices.length} must be equal to ${outputs.length}.`);\n          }\n          const outputTensorViews = [];\n          const outputDatas = [];\n          for (let i = 0; i < outputs.length; ++i) {\n            if (!Number.isInteger(validatedOutputIndices[i]) || validatedOutputIndices[i] < -3 || validatedOutputIndices[i] >= outputCount) {\n              throw new Error(`Invalid output index: ${validatedOutputIndices[i]}`);\n            }\n            if (validatedOutputIndices[i] === -3) {\n              continue;\n            }\n            const isTemporary = validatedOutputIndices[i] === -1;\n            const isPersistent = validatedOutputIndices[i] === -2;\n            const tensorView = isTemporary || isPersistent ? createIntermediateOutput(outputs[i].dataType, outputs[i].dims) : createKernelOutput(validatedOutputIndices[i], outputs[i].dataType, outputs[i].dims);\n            outputTensorViews.push(tensorView);\n            if (tensorView.data === 0) {\n              continue;\n            }\n            const gpuData = this.gpuDataManager.get(tensorView.data);\n            if (!gpuData) {\n              throw new Error(`no GPU data for output: ${tensorView.data}`);\n            }\n            if (isTemporary) {\n              this.temporaryData.push(gpuData);\n            }\n            if (isPersistent) {\n              let persistentData = this.kernelPersistentData.get(this.currentKernelId);\n              if (!persistentData) {\n                persistentData = [];\n                this.kernelPersistentData.set(this.currentKernelId, persistentData);\n              }\n              persistentData.push(gpuData);\n            }\n            outputDatas.push(gpuData);\n          }\n          if (inputDatas.length !== inputTensorViews.length || outputDatas.length !== outputTensorViews.length) {\n            if (outputDatas.length === 0) {\n              TRACE_FUNC_END(program.name);\n              return outputTensorViews;\n            }\n            throw new Error(\n              `Program ${program.name} has zero-sized tensor(s) in inputs or outputs. This is not supported now.`\n            );\n          }\n          let uniformBufferBinding;\n          if (programUniforms) {\n            let currentOffset = 0;\n            const offsets = [];\n            programUniforms.forEach((v) => {\n              const data = typeof v.data === \"number\" ? [v.data] : v.data;\n              if (data.length === 0) {\n                return;\n              }\n              const sizeOfElement = v.type === 10 /* float16 */ ? 2 : 4;\n              let sizeOfVecOrMat;\n              let baseAlignment;\n              if (v.type === 10 /* float16 */) {\n                baseAlignment = data.length > 4 ? 16 : data.length > 2 ? 8 : data.length * sizeOfElement;\n                sizeOfVecOrMat = data.length > 4 ? 16 : sizeOfElement * data.length;\n              } else {\n                baseAlignment = data.length <= 2 ? data.length * sizeOfElement : 16;\n                sizeOfVecOrMat = 16;\n              }\n              currentOffset = Math.ceil(currentOffset / baseAlignment) * baseAlignment;\n              offsets.push(currentOffset);\n              const elementPerVecOrMat = v.type === 10 /* float16 */ ? 8 : 4;\n              currentOffset += data.length > 4 ? Math.ceil(data.length / elementPerVecOrMat) * sizeOfVecOrMat : data.length * sizeOfElement;\n            });\n            const maxAlignmentOfField = 16;\n            currentOffset = Math.ceil(currentOffset / maxAlignmentOfField) * maxAlignmentOfField;\n            const arrayBuffer = new ArrayBuffer(currentOffset);\n            programUniforms.forEach((v, i) => {\n              const offset = offsets[i];\n              const data = typeof v.data === \"number\" ? [v.data] : v.data;\n              if (v.type === 6 /* int32 */) {\n                new Int32Array(arrayBuffer, offset, data.length).set(data);\n              } else if (v.type === 12 /* uint32 */) {\n                new Uint32Array(arrayBuffer, offset, data.length).set(data);\n              } else if (v.type === 10 /* float16 */) {\n                new Uint16Array(arrayBuffer, offset, data.length).set(data);\n              } else if (v.type === 1 /* float */) {\n                new Float32Array(arrayBuffer, offset, data.length).set(data);\n              } else {\n                throw new Error(`Unsupported uniform type: ${tensorDataTypeEnumToString(v.type)}`);\n              }\n            });\n            const uniformBufferData = (\n              // eslint-disable-next-line no-bitwise\n              this.gpuDataManager.create(currentOffset, GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM)\n            );\n            this.device.queue.writeBuffer(uniformBufferData.buffer, 0, arrayBuffer, 0, currentOffset);\n            this.gpuDataManager.release(uniformBufferData.id);\n            uniformBufferBinding = { offset: 0, size: currentOffset, buffer: uniformBufferData.buffer };\n          }\n          const normalizedDispatchGroup = this.programManager.normalizeDispatchGroupSize(dispatchGroup);\n          const is1DimensionDispatch = normalizedDispatchGroup[1] === 1 && normalizedDispatchGroup[2] === 1;\n          const key = getProgramInfoUniqueKey(program, inputTensorViews, is1DimensionDispatch);\n          let artifact = this.programManager.getArtifact(key);\n          if (!artifact) {\n            artifact = this.programManager.build(program, normalizedDispatchGroup);\n            this.programManager.setArtifact(key, artifact);\n            LOG_DEBUG(\"info\", () => `[artifact] key: ${key}, programName: ${program.name}`);\n          }\n          if (programUniforms && artifact.uniformVariablesInfo) {\n            if (programUniforms.length !== artifact.uniformVariablesInfo.length) {\n              throw new Error(`Uniform variables count mismatch: expect ${artifact.uniformVariablesInfo.length}, got ${programUniforms.length} in program \"${artifact.programInfo.name}\".`);\n            }\n            for (let i = 0; i < programUniforms.length; i++) {\n              const uniform = programUniforms[i];\n              const actualType = uniform.type;\n              const actualLength = typeof uniform.data === \"number\" ? 1 : uniform.data.length;\n              const [type, length] = artifact.uniformVariablesInfo[i];\n              if (actualType !== type || actualLength !== length) {\n                throw new Error(`Uniform variable ${i} mismatch: expect type ${type} with size ${length}, got type ${actualType} with size ${actualLength} in program \"${artifact.programInfo.name}\".`);\n              }\n            }\n          }\n          LOG_DEBUG(\n            \"info\",\n            () => `[ProgramManager] run \"${program.name}\" (key=${key}) with ${normalizedDispatchGroup[0]}x${normalizedDispatchGroup[1]}x${normalizedDispatchGroup[2]}`\n          );\n          if (this.queryType !== \"none\" || this.sessionStatus === \"capturing\") {\n            const pendingKernelInfo = {\n              kernelId: this.currentKernelId,\n              programName: artifact.programInfo.name,\n              inputTensorViews,\n              outputTensorViews\n            };\n            this.pendingKernels.push(pendingKernelInfo);\n            if (this.sessionStatus === \"capturing\") {\n              const sessionPendingKernels = this.capturedPendingKernels.get(this.currentSessionId);\n              sessionPendingKernels.push(pendingKernelInfo);\n            }\n          }\n          this.programManager.run(artifact, inputDatas, outputDatas, normalizedDispatchGroup, uniformBufferBinding);\n          TRACE_FUNC_END(program.name);\n          return outputTensorViews;\n        }\n        upload(gpuDataId, data) {\n          this.gpuDataManager.upload(gpuDataId, data);\n        }\n        memcpy(src, dst) {\n          this.gpuDataManager.memcpy(src, dst);\n        }\n        async download(gpuDataId, getTargetBuffer) {\n          await this.gpuDataManager.download(gpuDataId, getTargetBuffer);\n        }\n        alloc(size) {\n          return this.gpuDataManager.create(size).id;\n        }\n        free(ptr) {\n          return this.gpuDataManager.release(ptr);\n        }\n        createKernel(kernelType, kernelId, attribute, kernelName) {\n          const op = WEBGPU_OP_RESOLVE_RULES.get(kernelType);\n          if (!op) {\n            throw new Error(`kernel not implemented: ${kernelType}`);\n          }\n          const kernelInfo = {\n            kernelType,\n            kernelName,\n            kernelEntry: op[0],\n            attributes: [op[1], attribute]\n          };\n          this.kernels.set(kernelId, kernelInfo);\n        }\n        releaseKernel(kernelId) {\n          const persistentData = this.kernelPersistentData.get(kernelId);\n          if (persistentData) {\n            for (const data of persistentData) {\n              this.gpuDataManager.release(data.id);\n            }\n            this.kernelPersistentData.delete(kernelId);\n          }\n          this.kernelCustomData.delete(kernelId);\n          this.kernels.delete(kernelId);\n        }\n        computeKernel(kernelId, context, errors) {\n          const kernel = this.kernels.get(kernelId);\n          if (!kernel) {\n            throw new Error(`kernel not created: ${kernelId}`);\n          }\n          const kernelType = kernel.kernelType;\n          const kernelName = kernel.kernelName;\n          const kernelEntry = kernel.kernelEntry;\n          const attributes = kernel.attributes;\n          if (this.currentKernelId !== null) {\n            throw new Error(`kernel \"[${kernelType}] ${kernelName}\" is not allowed to be called recursively`);\n          }\n          this.currentKernelId = kernelId;\n          if (attributes[0]) {\n            attributes[1] = attributes[0](attributes[1]);\n            attributes[0] = void 0;\n          }\n          LOG_DEBUG(\"info\", () => `[WebGPU] Start to run kernel \"[${kernelType}] ${kernelName}\"...`);\n          const useErrorScope = this.env.debug;\n          this.temporaryData = [];\n          try {\n            if (useErrorScope) {\n              this.device.pushErrorScope(\"validation\");\n            }\n            kernelEntry(context, attributes[1]);\n            return 0;\n          } catch (e) {\n            errors.push(Promise.resolve(`[WebGPU] Kernel \"[${kernelType}] ${kernelName}\" failed. ${e}`));\n            return 1;\n          } finally {\n            if (useErrorScope) {\n              errors.push(this.device.popErrorScope().then(\n                (err) => err ? `GPU validation error for kernel \"[${kernelType}] ${kernelName}\": ${err.message}` : null\n              ));\n            }\n            for (const data of this.temporaryData) {\n              this.gpuDataManager.release(data.id);\n            }\n            this.temporaryData = [];\n            this.currentKernelId = null;\n          }\n        }\n        // #region external buffer\n        registerBuffer(sessionId, index, buffer, size) {\n          let sessionInputOutputMapping = this.sessionExternalDataMapping.get(sessionId);\n          if (!sessionInputOutputMapping) {\n            sessionInputOutputMapping = /* @__PURE__ */ new Map();\n            this.sessionExternalDataMapping.set(sessionId, sessionInputOutputMapping);\n          }\n          const previousBuffer = sessionInputOutputMapping.get(index);\n          const id = this.gpuDataManager.registerExternalBuffer(buffer, size, previousBuffer?.[1]);\n          sessionInputOutputMapping.set(index, [id, buffer]);\n          return id;\n        }\n        unregisterBuffers(sessionId) {\n          const sessionInputOutputMapping = this.sessionExternalDataMapping.get(sessionId);\n          if (sessionInputOutputMapping) {\n            sessionInputOutputMapping.forEach((bufferInfo) => this.gpuDataManager.unregisterExternalBuffer(bufferInfo[1]));\n            this.sessionExternalDataMapping.delete(sessionId);\n          }\n        }\n        getBuffer(gpuDataId) {\n          const gpuData = this.gpuDataManager.get(gpuDataId);\n          if (!gpuData) {\n            throw new Error(`no GPU data for buffer: ${gpuDataId}`);\n          }\n          return gpuData.buffer;\n        }\n        createDownloader(gpuBuffer, size, type) {\n          return async () => {\n            const data = await downloadGpuData(this, gpuBuffer, size);\n            return createView(data.buffer, type);\n          };\n        }\n        // #endregion\n        writeTimestamp(index) {\n          if (this.queryType !== \"inside-passes\") {\n            return;\n          }\n          this.computePassEncoder.writeTimestamp(this.querySet, index);\n        }\n        setQueryType() {\n          this.queryType = \"none\";\n          if (this.env.webgpu.profiling?.mode === \"default\" || (typeof this.env.trace === \"undefined\" ? this.env.wasm.trace : this.env.trace)) {\n            if (this.device.features.has(\"chromium-experimental-timestamp-query-inside-passes\")) {\n              this.queryType = \"inside-passes\";\n            } else if (this.device.features.has(\"timestamp-query\")) {\n              this.queryType = \"at-passes\";\n            }\n            if (this.queryType !== \"none\" && typeof this.querySet === \"undefined\") {\n              this.querySet = this.device.createQuerySet({\n                type: \"timestamp\",\n                count: this.maxDispatchNumber * 2\n              });\n              this.queryResolveBuffer = this.device.createBuffer(\n                // eslint-disable-next-line no-bitwise\n                { size: this.maxDispatchNumber * 2 * 8, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE }\n              );\n            }\n          }\n        }\n        captureBegin() {\n          LOG_DEBUG(\"info\", \"captureBegin\");\n          if (!this.capturedCommandList.get(this.currentSessionId)) {\n            this.capturedCommandList.set(this.currentSessionId, []);\n          }\n          if (!this.capturedPendingKernels.get(this.currentSessionId)) {\n            this.capturedPendingKernels.set(this.currentSessionId, []);\n          }\n          this.flush();\n          this.sessionStatus = \"capturing\";\n        }\n        captureEnd() {\n          LOG_DEBUG(\"info\", \"captureEnd\");\n          this.flush();\n          this.sessionStatus = \"default\";\n        }\n        replay() {\n          LOG_DEBUG(\"info\", \"replay\");\n          this.sessionStatus = \"replaying\";\n          const sessionCommandList = this.capturedCommandList.get(this.currentSessionId);\n          const sessionPendingKernels = this.capturedPendingKernels.get(this.currentSessionId);\n          const length = sessionCommandList.length;\n          this.pendingKernels = [];\n          for (let i = 0; i < length; i++) {\n            const computePassEncoder = this.getComputePassEncoder();\n            const command = sessionCommandList[i];\n            this.writeTimestamp(this.pendingDispatchNumber * 2);\n            computePassEncoder.setPipeline(command.computePipeline);\n            computePassEncoder.setBindGroup(0, command.bindGroup);\n            computePassEncoder.dispatchWorkgroups(...command.dispatchGroup);\n            this.writeTimestamp(this.pendingDispatchNumber * 2 + 1);\n            this.pendingDispatchNumber++;\n            if (this.queryType !== \"none\") {\n              this.pendingKernels.push(sessionPendingKernels[i]);\n            }\n            if (this.pendingDispatchNumber >= this.maxDispatchNumber || this.queryType === \"at-passes\") {\n              this.endComputePass();\n            }\n            if (this.pendingDispatchNumber >= this.maxDispatchNumber) {\n              this.flush();\n            }\n          }\n          this.flush();\n          this.sessionStatus = \"default\";\n        }\n        onReleaseSession(sessionId) {\n          this.unregisterBuffers(sessionId);\n          if (this.capturedCommandList.has(sessionId)) {\n            this.capturedCommandList.delete(sessionId);\n          }\n          if (this.capturedPendingKernels.has(sessionId)) {\n            this.capturedPendingKernels.delete(sessionId);\n          }\n          this.gpuDataManager.onReleaseSession(sessionId);\n        }\n        onRunStart(sessionId) {\n          this.currentSessionId = sessionId;\n          this.setQueryType();\n        }\n      };\n    }\n  });\n\n  // web/lib/wasm/jsep/init.ts\n  var init_exports = {};\n  __export(init_exports, {\n    init: () => init\n  });\n  var TensorViewImpl, ComputeContextImpl, init;\n  var init_init = __esm({\n    \"web/lib/wasm/jsep/init.ts\"() {\n      \"use strict\";\n      init_wasm_common();\n      init_backend_webgpu();\n      init_log();\n      init_util();\n      TensorViewImpl = class _TensorViewImpl {\n        constructor(module, dataType, data, dims) {\n          this.module = module;\n          this.dataType = dataType;\n          this.data = data;\n          this.dims = dims;\n        }\n        getFloat32Array() {\n          if (this.dataType !== 1 /* float */) {\n            throw new Error(\"Invalid data type\");\n          }\n          const elementCount = ShapeUtil.size(this.dims);\n          return elementCount === 0 ? new Float32Array() : new Float32Array(this.module.HEAP8.buffer, this.data, elementCount);\n        }\n        getBigInt64Array() {\n          if (this.dataType !== 7 /* int64 */) {\n            throw new Error(\"Invalid data type\");\n          }\n          const elementCount = ShapeUtil.size(this.dims);\n          return elementCount === 0 ? new BigInt64Array() : new BigInt64Array(this.module.HEAP8.buffer, this.data, elementCount);\n        }\n        getInt32Array() {\n          if (this.dataType !== 6 /* int32 */) {\n            throw new Error(\"Invalid data type\");\n          }\n          const elementCount = ShapeUtil.size(this.dims);\n          return elementCount === 0 ? new Int32Array() : new Int32Array(this.module.HEAP8.buffer, this.data, elementCount);\n        }\n        reshape(newDims) {\n          if (ShapeUtil.size(newDims) !== ShapeUtil.size(this.dims)) {\n            throw new Error(\"Invalid new shape\");\n          }\n          return new _TensorViewImpl(this.module, this.dataType, this.data, newDims);\n        }\n      };\n      ComputeContextImpl = class {\n        constructor(module, backend, contextDataOffset) {\n          this.module = module;\n          this.backend = backend;\n          this.customDataOffset = 0;\n          this.customDataSize = 0;\n          this.adapterInfo = backend.adapterInfo;\n          const heapU32 = module.HEAPU32;\n          let dataIndex = contextDataOffset >>> 2;\n          this.opKernelContext = heapU32[dataIndex++];\n          const inputCount = heapU32[dataIndex++];\n          this.outputCount = heapU32[dataIndex++];\n          this.customDataOffset = heapU32[dataIndex++];\n          this.customDataSize = heapU32[dataIndex++];\n          const inputs = [];\n          for (let i = 0; i < inputCount; i++) {\n            const dataType = heapU32[dataIndex++];\n            const data = heapU32[dataIndex++];\n            const dim = heapU32[dataIndex++];\n            const dims = [];\n            for (let d = 0; d < dim; d++) {\n              dims.push(heapU32[dataIndex++]);\n            }\n            inputs.push(new TensorViewImpl(module, dataType, data, dims));\n          }\n          this.inputs = inputs;\n        }\n        get kernelCustomData() {\n          return this.backend.currentKernelCustomData;\n        }\n        get customDataBuffer() {\n          return this.module.HEAPU8.subarray(this.customDataOffset, this.customDataOffset + this.customDataSize);\n        }\n        getMaxComputeWorkgroupSizes() {\n          return [\n            this.backend.device.limits.maxComputeWorkgroupSizeX,\n            this.backend.device.limits.maxComputeWorkgroupSizeY,\n            this.backend.device.limits.maxComputeWorkgroupSizeZ\n          ];\n        }\n        getMaxComputeWorkgroupStoragesize() {\n          return this.backend.device.limits.maxComputeWorkgroupStorageSize;\n        }\n        compute(program, inputsOutputsMapping) {\n          const mappedInputs = inputsOutputsMapping?.inputs?.map((i) => typeof i === \"number\" ? this.inputs[i] : i) ?? this.inputs;\n          const outputIndices = inputsOutputsMapping?.outputs ?? [];\n          const createKernelOutput = (index, dataType, dims) => new TensorViewImpl(this.module, dataType, this.output(index, dims), dims);\n          const createTemporaryOutput = (dataType, dims) => {\n            const elementSize = getTensorElementSize(dataType);\n            if (!elementSize) {\n              throw new Error(`Unsupported data type: ${dataType}`);\n            }\n            const bufferSize = elementSize * ShapeUtil.size(dims);\n            const gpuDataId = bufferSize > 0 ? this.backend.gpuDataManager.create(bufferSize).id : 0;\n            return new TensorViewImpl(this.module, dataType, gpuDataId, dims);\n          };\n          return this.backend.run(\n            program,\n            mappedInputs,\n            outputIndices,\n            createKernelOutput,\n            createTemporaryOutput,\n            this.outputCount\n          );\n        }\n        output(index, dims) {\n          const stack = this.module.stackSave();\n          try {\n            const data = this.module.stackAlloc(\n              (1 + dims.length) * 4\n              /* sizeof(size_t) */\n            );\n            let offset = data >> 2;\n            this.module.HEAPU32[offset++] = dims.length;\n            for (let i = 0; i < dims.length; i++) {\n              this.module.HEAPU32[offset++] = dims[i];\n            }\n            return this.module._JsepOutput(this.opKernelContext, index, data);\n          } catch (e) {\n            throw new Error(\n              `Failed to generate kernel's output[${index}] with dims [${dims}]. If you are running with pre-allocated output, please make sure the output type/dims are correct. Error: ${e}`\n            );\n          } finally {\n            this.module.stackRestore(stack);\n          }\n        }\n      };\n      init = async (name, module, env3, gpuAdapter) => {\n        const jsepInit = module.jsepInit;\n        if (!jsepInit) {\n          throw new Error(\"Failed to initialize JSEP. The WebAssembly module is not built with JSEP support.\");\n        }\n        if (name === \"webgpu\") {\n          const backend = new WebGpuBackend();\n          await backend.initialize(env3, gpuAdapter);\n          jsepInit(\"webgpu\", [\n            // backend\n            backend,\n            // jsepAlloc()\n            (size) => backend.alloc(size),\n            // jsepFree()\n            (ptr) => backend.free(ptr),\n            // jsepCopy(src, dst, size, isSourceGpu)\n            (src, dst, size, isSourceGpu = false) => {\n              if (isSourceGpu) {\n                LOG_DEBUG(\"verbose\", () => `[WebGPU] jsepCopyGpuToGpu: src=${src}, dst=${dst}, size=${size}`);\n                backend.memcpy(src, dst);\n              } else {\n                LOG_DEBUG(\"verbose\", () => `[WebGPU] jsepCopyCpuToGpu: dataOffset=${src}, gpuDataId=${dst}, size=${size}`);\n                const data = module.HEAPU8.subarray(src >>> 0, (src >>> 0) + size);\n                backend.upload(dst, data);\n              }\n            },\n            // jsepCopyAsync(src, dst, size)\n            async (gpuDataId, dataOffset, size) => {\n              LOG_DEBUG(\n                \"verbose\",\n                () => `[WebGPU] jsepCopyGpuToCpu: gpuDataId=${gpuDataId}, dataOffset=${dataOffset}, size=${size}`\n              );\n              await backend.download(\n                gpuDataId,\n                () => module.HEAPU8.subarray(dataOffset >>> 0, (dataOffset >>> 0) + size)\n              );\n            },\n            // jsepCreateKernel\n            (kernelType, kernelId, attribute) => backend.createKernel(\n              kernelType,\n              kernelId,\n              attribute,\n              module.UTF8ToString(module._JsepGetNodeName(kernelId))\n            ),\n            // jsepReleaseKernel\n            (kernel) => backend.releaseKernel(kernel),\n            // jsepRun\n            (kernel, contextDataOffset, sessionHandle, errors) => {\n              LOG_DEBUG(\n                \"verbose\",\n                () => `[WebGPU] jsepRun: sessionHandle=${sessionHandle}, kernel=${kernel}, contextDataOffset=${contextDataOffset}`\n              );\n              const context = new ComputeContextImpl(module, backend, contextDataOffset);\n              return backend.computeKernel(kernel, context, errors);\n            },\n            // jsepCaptureBegin\n            () => backend.captureBegin(),\n            // jsepCaptureEnd\n            () => backend.captureEnd(),\n            // jsepReplay\n            () => backend.replay()\n          ]);\n        } else {\n          jsepInit(\"webnn\");\n        }\n      };\n    }\n  });\n\n  // nodejs-ignore:node:path\n  var join = void 0;\n\n  // web/lib/wasm/wasm-factory.ts\n  var ortWasmFactory;\n  if (false) {\n    ortWasmFactory = null;\n  } else {\n    ortWasmFactory = false ? null : require_ort_wasm_simd_jsep();\n  }\n  var ortWasmFactoryThreaded = true ? false ? null : require_ort_wasm_simd_threaded_jsep() : ortWasmFactory;\n  var wasm;\n  var initialized = false;\n  var initializing = false;\n  var aborted = false;\n  var isMultiThreadSupported = (numThreads) => {\n    if (numThreads === 1) {\n      return false;\n    }\n    if (typeof SharedArrayBuffer === \"undefined\") {\n      if (typeof self !== \"undefined\" && !self.crossOriginIsolated) {\n        console.warn(\n          \"env.wasm.numThreads is set to \" + numThreads + \", but this will not work unless you enable crossOriginIsolated mode. See https://web.dev/cross-origin-isolation-guide/ for more info.\"\n        );\n      }\n      return false;\n    }\n    if (typeof process !== \"undefined\" && process.versions && process.versions.node) {\n      console.warn(\n        \"env.wasm.numThreads is set to \" + numThreads + \", however, currently onnxruntime-web does not support multi-threads in Node.js. Please consider using onnxruntime-node for performance critical scenarios.\"\n      );\n    }\n    try {\n      if (typeof MessageChannel !== \"undefined\") {\n        new MessageChannel().port1.postMessage(new SharedArrayBuffer(1));\n      }\n      return WebAssembly.validate(new Uint8Array([\n        0,\n        97,\n        115,\n        109,\n        1,\n        0,\n        0,\n        0,\n        1,\n        4,\n        1,\n        96,\n        0,\n        0,\n        3,\n        2,\n        1,\n        0,\n        5,\n        4,\n        1,\n        3,\n        1,\n        1,\n        10,\n        11,\n        1,\n        9,\n        0,\n        65,\n        0,\n        254,\n        16,\n        2,\n        0,\n        26,\n        11\n      ]));\n    } catch (e) {\n      return false;\n    }\n  };\n  var isSimdSupported = () => {\n    try {\n      return WebAssembly.validate(new Uint8Array([\n        0,\n        97,\n        115,\n        109,\n        1,\n        0,\n        0,\n        0,\n        1,\n        4,\n        1,\n        96,\n        0,\n        0,\n        3,\n        2,\n        1,\n        0,\n        10,\n        30,\n        1,\n        28,\n        0,\n        65,\n        0,\n        253,\n        15,\n        253,\n        12,\n        0,\n        0,\n        0,\n        0,\n        0,\n        0,\n        0,\n        0,\n        0,\n        0,\n        0,\n        0,\n        0,\n        0,\n        0,\n        0,\n        253,\n        186,\n        1,\n        26,\n        11\n      ]));\n    } catch (e) {\n      return false;\n    }\n  };\n  var getWasmFileName = (useSimd, useThreads) => {\n    if (useSimd) {\n      if (false) {\n        return \"ort-training-wasm-simd.wasm\";\n      }\n      return useThreads ? \"ort-wasm-simd-threaded.wasm\" : \"ort-wasm-simd.wasm\";\n    } else {\n      return useThreads ? \"ort-wasm-threaded.wasm\" : \"ort-wasm.wasm\";\n    }\n  };\n  var initializeWebAssembly = async (flags) => {\n    if (initialized) {\n      return Promise.resolve();\n    }\n    if (initializing) {\n      throw new Error(\"multiple calls to 'initializeWebAssembly()' detected.\");\n    }\n    if (aborted) {\n      throw new Error(\"previous call to 'initializeWebAssembly()' failed.\");\n    }\n    initializing = true;\n    const timeout = flags.initTimeout;\n    const numThreads = flags.numThreads;\n    const simd = flags.simd;\n    const useThreads = isMultiThreadSupported(numThreads);\n    const useSimd = simd && isSimdSupported();\n    const wasmPaths = flags.wasmPaths;\n    const wasmPrefixOverride = typeof wasmPaths === \"string\" ? wasmPaths : void 0;\n    const wasmFileName = getWasmFileName(useSimd, useThreads);\n    const wasmPathOverride = typeof wasmPaths === \"object\" ? wasmPaths[wasmFileName] : void 0;\n    let isTimeout = false;\n    const tasks = [];\n    if (timeout > 0) {\n      tasks.push(new Promise((resolve) => {\n        setTimeout(() => {\n          isTimeout = true;\n          resolve();\n        }, timeout);\n      }));\n    }\n    tasks.push(new Promise((resolve, reject) => {\n      const factory = useThreads ? ortWasmFactoryThreaded : ortWasmFactory;\n      const config = {\n        locateFile: (fileName, scriptDirectory) => {\n          if (useThreads && fileName.endsWith(\".worker.js\") && typeof Blob !== \"undefined\") {\n            return URL.createObjectURL(new Blob(\n              [\n                // This require() function is handled by esbuild plugin to load file content as string.\n                // eslint-disable-next-line @typescript-eslint/no-require-imports\n                require_ort_wasm_threaded_worker()\n              ],\n              { type: \"text/javascript\" }\n            ));\n          }\n          if (fileName.endsWith(\".wasm\")) {\n            if (wasmPathOverride) {\n              return wasmPathOverride;\n            }\n            const prefix = wasmPrefixOverride ?? scriptDirectory;\n            if (true) {\n              if (wasmFileName === \"ort-wasm-simd.wasm\") {\n                return prefix + \"ort-wasm-simd.jsep.wasm\";\n              } else if (wasmFileName === \"ort-wasm-simd-threaded.wasm\") {\n                return prefix + \"ort-wasm-simd-threaded.jsep.wasm\";\n              }\n            }\n            return prefix + wasmFileName;\n          }\n          return scriptDirectory + fileName;\n        }\n      };\n      if (useThreads) {\n        config.numThreads = numThreads;\n        if (typeof Blob === \"undefined\") {\n          config.mainScriptUrlOrBlob = join(__dirname, \"ort-wasm-threaded.js\");\n        } else {\n          const scriptSourceCode = `var ortWasmThreaded=${factory.toString()};`;\n          config.mainScriptUrlOrBlob = new Blob([scriptSourceCode], { type: \"text/javascript\" });\n        }\n      }\n      factory(config).then(\n        // wasm module initialized successfully\n        (module) => {\n          initializing = false;\n          initialized = true;\n          wasm = module;\n          resolve();\n        },\n        // wasm module failed to initialize\n        (what) => {\n          initializing = false;\n          aborted = true;\n          reject(what);\n        }\n      );\n    }));\n    await Promise.race(tasks);\n    if (isTimeout) {\n      throw new Error(`WebAssembly backend initializing failed due to timeout: ${timeout}ms`);\n    }\n  };\n  var getInstance = () => {\n    if (initialized && wasm) {\n      return wasm;\n    }\n    throw new Error(\"WebAssembly is not initialized yet.\");\n  };\n\n  // web/lib/wasm/wasm-utils.ts\n  var allocWasmString = (data, allocs) => {\n    const wasm2 = getInstance();\n    const dataLength = wasm2.lengthBytesUTF8(data) + 1;\n    const dataOffset = wasm2._malloc(dataLength);\n    wasm2.stringToUTF8(data, dataOffset, dataLength);\n    allocs.push(dataOffset);\n    return dataOffset;\n  };\n  var iterateExtraOptions = (options, prefix, seen, handler) => {\n    if (typeof options == \"object\" && options !== null) {\n      if (seen.has(options)) {\n        throw new Error(\"Circular reference in options\");\n      } else {\n        seen.add(options);\n      }\n    }\n    Object.entries(options).forEach(([key, value]) => {\n      const name = prefix ? prefix + key : key;\n      if (typeof value === \"object\") {\n        iterateExtraOptions(value, name + \".\", seen, handler);\n      } else if (typeof value === \"string\" || typeof value === \"number\") {\n        handler(name, value.toString());\n      } else if (typeof value === \"boolean\") {\n        handler(name, value ? \"1\" : \"0\");\n      } else {\n        throw new Error(`Can't handle extra config type: ${typeof value}`);\n      }\n    });\n  };\n  var checkLastError = (message) => {\n    const wasm2 = getInstance();\n    const stack = wasm2.stackSave();\n    try {\n      const paramsOffset = wasm2.stackAlloc(8);\n      wasm2._OrtGetLastError(paramsOffset, paramsOffset + 4);\n      const errorCode = wasm2.HEAP32[paramsOffset / 4];\n      const errorMessagePointer = wasm2.HEAPU32[paramsOffset / 4 + 1];\n      const errorMessage = errorMessagePointer ? wasm2.UTF8ToString(errorMessagePointer) : \"\";\n      throw new Error(`${message} ERROR_CODE: ${errorCode}, ERROR_MESSAGE: ${errorMessage}`);\n    } finally {\n      wasm2.stackRestore(stack);\n    }\n  };\n\n  // web/lib/wasm/run-options.ts\n  var setRunOptions = (options) => {\n    const wasm2 = getInstance();\n    let runOptionsHandle = 0;\n    const allocs = [];\n    const runOptions = options || {};\n    try {\n      if (options?.logSeverityLevel === void 0) {\n        runOptions.logSeverityLevel = 2;\n      } else if (typeof options.logSeverityLevel !== \"number\" || !Number.isInteger(options.logSeverityLevel) || options.logSeverityLevel < 0 || options.logSeverityLevel > 4) {\n        throw new Error(`log serverity level is not valid: ${options.logSeverityLevel}`);\n      }\n      if (options?.logVerbosityLevel === void 0) {\n        runOptions.logVerbosityLevel = 0;\n      } else if (typeof options.logVerbosityLevel !== \"number\" || !Number.isInteger(options.logVerbosityLevel)) {\n        throw new Error(`log verbosity level is not valid: ${options.logVerbosityLevel}`);\n      }\n      if (options?.terminate === void 0) {\n        runOptions.terminate = false;\n      }\n      let tagDataOffset = 0;\n      if (options?.tag !== void 0) {\n        tagDataOffset = allocWasmString(options.tag, allocs);\n      }\n      runOptionsHandle = wasm2._OrtCreateRunOptions(\n        runOptions.logSeverityLevel,\n        runOptions.logVerbosityLevel,\n        !!runOptions.terminate,\n        tagDataOffset\n      );\n      if (runOptionsHandle === 0) {\n        checkLastError(\"Can't create run options.\");\n      }\n      if (options?.extra !== void 0) {\n        iterateExtraOptions(options.extra, \"\", /* @__PURE__ */ new WeakSet(), (key, value) => {\n          const keyDataOffset = allocWasmString(key, allocs);\n          const valueDataOffset = allocWasmString(value, allocs);\n          if (wasm2._OrtAddRunConfigEntry(runOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n            checkLastError(`Can't set a run config entry: ${key} - ${value}.`);\n          }\n        });\n      }\n      return [runOptionsHandle, allocs];\n    } catch (e) {\n      if (runOptionsHandle !== 0) {\n        wasm2._OrtReleaseRunOptions(runOptionsHandle);\n      }\n      allocs.forEach((alloc) => wasm2._free(alloc));\n      throw e;\n    }\n  };\n\n  // web/lib/wasm/session-options.ts\n  var getGraphOptimzationLevel = (graphOptimizationLevel) => {\n    switch (graphOptimizationLevel) {\n      case \"disabled\":\n        return 0;\n      case \"basic\":\n        return 1;\n      case \"extended\":\n        return 2;\n      case \"all\":\n        return 99;\n      default:\n        throw new Error(`unsupported graph optimization level: ${graphOptimizationLevel}`);\n    }\n  };\n  var getExecutionMode = (executionMode) => {\n    switch (executionMode) {\n      case \"sequential\":\n        return 0;\n      case \"parallel\":\n        return 1;\n      default:\n        throw new Error(`unsupported execution mode: ${executionMode}`);\n    }\n  };\n  var appendDefaultOptions = (options) => {\n    if (!options.extra) {\n      options.extra = {};\n    }\n    if (!options.extra.session) {\n      options.extra.session = {};\n    }\n    const session = options.extra.session;\n    if (!session.use_ort_model_bytes_directly) {\n      session.use_ort_model_bytes_directly = \"1\";\n    }\n    if (options.executionProviders && options.executionProviders.some((ep) => (typeof ep === \"string\" ? ep : ep.name) === \"webgpu\")) {\n      options.enableMemPattern = false;\n    }\n  };\n  var setExecutionProviders = (sessionOptionsHandle, executionProviders, allocs) => {\n    for (const ep of executionProviders) {\n      let epName = typeof ep === \"string\" ? ep : ep.name;\n      switch (epName) {\n        case \"webnn\":\n          epName = \"WEBNN\";\n          if (typeof ep !== \"string\") {\n            const webnnOptions = ep;\n            if (webnnOptions?.deviceType) {\n              const keyDataOffset = allocWasmString(\"deviceType\", allocs);\n              const valueDataOffset = allocWasmString(webnnOptions.deviceType, allocs);\n              if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n                checkLastError(`Can't set a session config entry: 'deviceType' - ${webnnOptions.deviceType}.`);\n              }\n            }\n            if (webnnOptions?.numThreads) {\n              let numThreads = webnnOptions.numThreads;\n              if (typeof numThreads != \"number\" || !Number.isInteger(numThreads) || numThreads < 0) {\n                numThreads = 0;\n              }\n              const keyDataOffset = allocWasmString(\"numThreads\", allocs);\n              const valueDataOffset = allocWasmString(numThreads.toString(), allocs);\n              if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n                checkLastError(`Can't set a session config entry: 'numThreads' - ${webnnOptions.numThreads}.`);\n              }\n            }\n            if (webnnOptions?.powerPreference) {\n              const keyDataOffset = allocWasmString(\"powerPreference\", allocs);\n              const valueDataOffset = allocWasmString(webnnOptions.powerPreference, allocs);\n              if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n                checkLastError(\n                  `Can't set a session config entry: 'powerPreference' - ${webnnOptions.powerPreference}.`\n                );\n              }\n            }\n          }\n          break;\n        case \"webgpu\":\n          epName = \"JS\";\n          if (typeof ep !== \"string\") {\n            const webgpuOptions = ep;\n            if (webgpuOptions?.preferredLayout) {\n              if (webgpuOptions.preferredLayout !== \"NCHW\" && webgpuOptions.preferredLayout !== \"NHWC\") {\n                throw new Error(`preferredLayout must be either 'NCHW' or 'NHWC': ${webgpuOptions.preferredLayout}`);\n              }\n              const keyDataOffset = allocWasmString(\"preferredLayout\", allocs);\n              const valueDataOffset = allocWasmString(webgpuOptions.preferredLayout, allocs);\n              if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n                checkLastError(\n                  `Can't set a session config entry: 'preferredLayout' - ${webgpuOptions.preferredLayout}.`\n                );\n              }\n            }\n          }\n          break;\n        case \"wasm\":\n        case \"cpu\":\n          continue;\n        default:\n          throw new Error(`not supported execution provider: ${epName}`);\n      }\n      const epNameDataOffset = allocWasmString(epName, allocs);\n      if (getInstance()._OrtAppendExecutionProvider(sessionOptionsHandle, epNameDataOffset) !== 0) {\n        checkLastError(`Can't append execution provider: ${epName}.`);\n      }\n    }\n  };\n  var setSessionOptions = (options) => {\n    const wasm2 = getInstance();\n    let sessionOptionsHandle = 0;\n    const allocs = [];\n    const sessionOptions = options || {};\n    appendDefaultOptions(sessionOptions);\n    try {\n      const graphOptimizationLevel = getGraphOptimzationLevel(sessionOptions.graphOptimizationLevel ?? \"all\");\n      const executionMode = getExecutionMode(sessionOptions.executionMode ?? \"sequential\");\n      const logIdDataOffset = typeof sessionOptions.logId === \"string\" ? allocWasmString(sessionOptions.logId, allocs) : 0;\n      const logSeverityLevel = sessionOptions.logSeverityLevel ?? 2;\n      if (!Number.isInteger(logSeverityLevel) || logSeverityLevel < 0 || logSeverityLevel > 4) {\n        throw new Error(`log serverity level is not valid: ${logSeverityLevel}`);\n      }\n      const logVerbosityLevel = sessionOptions.logVerbosityLevel ?? 0;\n      if (!Number.isInteger(logVerbosityLevel) || logVerbosityLevel < 0 || logVerbosityLevel > 4) {\n        throw new Error(`log verbosity level is not valid: ${logVerbosityLevel}`);\n      }\n      const optimizedModelFilePathOffset = typeof sessionOptions.optimizedModelFilePath === \"string\" ? allocWasmString(sessionOptions.optimizedModelFilePath, allocs) : 0;\n      sessionOptionsHandle = wasm2._OrtCreateSessionOptions(\n        graphOptimizationLevel,\n        !!sessionOptions.enableCpuMemArena,\n        !!sessionOptions.enableMemPattern,\n        executionMode,\n        !!sessionOptions.enableProfiling,\n        0,\n        logIdDataOffset,\n        logSeverityLevel,\n        logVerbosityLevel,\n        optimizedModelFilePathOffset\n      );\n      if (sessionOptionsHandle === 0) {\n        checkLastError(\"Can't create session options.\");\n      }\n      if (sessionOptions.executionProviders) {\n        setExecutionProviders(sessionOptionsHandle, sessionOptions.executionProviders, allocs);\n      }\n      if (sessionOptions.enableGraphCapture !== void 0) {\n        if (typeof sessionOptions.enableGraphCapture !== \"boolean\") {\n          throw new Error(`enableGraphCapture must be a boolean value: ${sessionOptions.enableGraphCapture}`);\n        }\n        const keyDataOffset = allocWasmString(\"enableGraphCapture\", allocs);\n        const valueDataOffset = allocWasmString(sessionOptions.enableGraphCapture.toString(), allocs);\n        if (wasm2._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n          checkLastError(\n            `Can't set a session config entry: 'enableGraphCapture' - ${sessionOptions.enableGraphCapture}.`\n          );\n        }\n      }\n      if (sessionOptions.freeDimensionOverrides) {\n        for (const [name, value] of Object.entries(sessionOptions.freeDimensionOverrides)) {\n          if (typeof name !== \"string\") {\n            throw new Error(`free dimension override name must be a string: ${name}`);\n          }\n          if (typeof value !== \"number\" || !Number.isInteger(value) || value < 0) {\n            throw new Error(`free dimension override value must be a non-negative integer: ${value}`);\n          }\n          const nameOffset = allocWasmString(name, allocs);\n          if (wasm2._OrtAddFreeDimensionOverride(sessionOptionsHandle, nameOffset, value) !== 0) {\n            checkLastError(`Can't set a free dimension override: ${name} - ${value}.`);\n          }\n        }\n      }\n      if (sessionOptions.extra !== void 0) {\n        iterateExtraOptions(sessionOptions.extra, \"\", /* @__PURE__ */ new WeakSet(), (key, value) => {\n          const keyDataOffset = allocWasmString(key, allocs);\n          const valueDataOffset = allocWasmString(value, allocs);\n          if (wasm2._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n            checkLastError(`Can't set a session config entry: ${key} - ${value}.`);\n          }\n        });\n      }\n      return [sessionOptionsHandle, allocs];\n    } catch (e) {\n      if (sessionOptionsHandle !== 0) {\n        wasm2._OrtReleaseSessionOptions(sessionOptionsHandle);\n      }\n      allocs.forEach((alloc) => wasm2._free(alloc));\n      throw e;\n    }\n  };\n\n  // web/lib/wasm/wasm-core-impl.ts\n  init_wasm_common();\n\n  // web/lib/wasm/wasm-utils-load-file.ts\n  init_fs();\n\n  // nodejs-ignore:node:fs/promises\n  var readFile2 = void 0;\n\n  // web/lib/wasm/wasm-utils-load-file.ts\n  var loadFile = async (file) => {\n    if (typeof file === \"string\") {\n      if (typeof process !== \"undefined\" && process.versions && process.versions.node) {\n        try {\n          return new Uint8Array(await readFile2(file));\n        } catch (e) {\n          if (e.code === \"ERR_FS_FILE_TOO_LARGE\") {\n            const stream = createReadStream(file);\n            const chunks = [];\n            for await (const chunk of stream) {\n              chunks.push(chunk);\n            }\n            return new Uint8Array(Buffer.concat(chunks));\n          }\n          throw e;\n        }\n      } else {\n        const response = await fetch(file);\n        if (!response.ok) {\n          throw new Error(`failed to load external data file: ${file}`);\n        }\n        const contentLengthHeader = response.headers.get(\"Content-Length\");\n        const fileSize = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;\n        if (fileSize < 1073741824) {\n          return new Uint8Array(await response.arrayBuffer());\n        } else {\n          if (!response.body) {\n            throw new Error(`failed to load external data file: ${file}, no response body.`);\n          }\n          const reader = response.body.getReader();\n          let buffer;\n          try {\n            buffer = new ArrayBuffer(fileSize);\n          } catch (e) {\n            if (e instanceof RangeError) {\n              const pages = Math.ceil(fileSize / 65536);\n              buffer = new WebAssembly.Memory({ initial: pages, maximum: pages }).buffer;\n            } else {\n              throw e;\n            }\n          }\n          let offset = 0;\n          while (true) {\n            const { done, value } = await reader.read();\n            if (done) {\n              break;\n            }\n            const chunkSize = value.byteLength;\n            const chunk = new Uint8Array(buffer, offset, chunkSize);\n            chunk.set(value);\n            offset += chunkSize;\n          }\n          return new Uint8Array(buffer, 0, fileSize);\n        }\n      }\n    } else if (file instanceof Blob) {\n      return new Uint8Array(await file.arrayBuffer());\n    } else if (file instanceof Uint8Array) {\n      return file;\n    } else {\n      return new Uint8Array(file);\n    }\n  };\n\n  // web/lib/wasm/wasm-core-impl.ts\n  var initOrt = (numThreads, loggingLevel) => {\n    const errorCode = getInstance()._OrtInit(numThreads, loggingLevel);\n    if (errorCode !== 0) {\n      checkLastError(\"Can't initialize onnxruntime.\");\n    }\n  };\n  var initRuntime = async (env3) => {\n    initOrt(env3.wasm.numThreads, logLevelStringToEnum(env3.logLevel));\n  };\n  var initEp = async (env3, epName) => {\n    if (true) {\n      const initJsep = (init_init(), __toCommonJS(init_exports)).init;\n      if (epName === \"webgpu\") {\n        if (typeof navigator === \"undefined\" || !navigator.gpu) {\n          throw new Error(\"WebGPU is not supported in current environment\");\n        }\n        let adapter = env3.webgpu.adapter;\n        if (!adapter) {\n          const powerPreference = env3.webgpu.powerPreference;\n          if (powerPreference !== void 0 && powerPreference !== \"low-power\" && powerPreference !== \"high-performance\") {\n            throw new Error(`Invalid powerPreference setting: \"${powerPreference}\"`);\n          }\n          const forceFallbackAdapter = env3.webgpu.forceFallbackAdapter;\n          if (forceFallbackAdapter !== void 0 && typeof forceFallbackAdapter !== \"boolean\") {\n            throw new Error(`Invalid forceFallbackAdapter setting: \"${forceFallbackAdapter}\"`);\n          }\n          adapter = await navigator.gpu.requestAdapter({ powerPreference, forceFallbackAdapter });\n          if (!adapter) {\n            throw new Error(\n              'Failed to get GPU adapter. You may need to enable flag \"--enable-unsafe-webgpu\" if you are using Chrome.'\n            );\n          }\n        } else {\n          if (typeof adapter.limits !== \"object\" || typeof adapter.features !== \"object\" || typeof adapter.requestDevice !== \"function\") {\n            throw new Error(\"Invalid GPU adapter set in `env.webgpu.adapter`. It must be a GPUAdapter object.\");\n          }\n        }\n        if (!env3.wasm.simd) {\n          throw new Error(\n            \"Not supported for WebGPU=ON and SIMD=OFF. Please set `env.wasm.simd` to true when using `webgpu` EP\"\n          );\n        }\n        await initJsep(\"webgpu\", getInstance(), env3, adapter);\n      }\n      if (epName === \"webnn\") {\n        if (typeof navigator === \"undefined\" || !navigator.ml) {\n          throw new Error(\"WebNN is not supported in current environment\");\n        }\n        await initJsep(\"webnn\", getInstance(), env3);\n      }\n    }\n  };\n  var activeSessions = /* @__PURE__ */ new Map();\n  var getSessionInputOutputCount = (sessionHandle) => {\n    const wasm2 = getInstance();\n    const stack = wasm2.stackSave();\n    try {\n      const dataOffset = wasm2.stackAlloc(8);\n      const errorCode = wasm2._OrtGetInputOutputCount(sessionHandle, dataOffset, dataOffset + 4);\n      if (errorCode !== 0) {\n        checkLastError(\"Can't get session input/output count.\");\n      }\n      return [wasm2.HEAP32[dataOffset / 4], wasm2.HEAP32[dataOffset / 4 + 1]];\n    } finally {\n      wasm2.stackRestore(stack);\n    }\n  };\n  var copyFromExternalBuffer = (model) => {\n    const wasm2 = getInstance();\n    const modelDataOffset = wasm2._malloc(model.byteLength);\n    if (modelDataOffset === 0) {\n      throw new Error(`Can't create a session. failed to allocate a buffer of size ${model.byteLength}.`);\n    }\n    wasm2.HEAPU8.set(model, modelDataOffset);\n    return [modelDataOffset, model.byteLength];\n  };\n  var createSession = async (modelData, options) => {\n    let modelDataOffset, modelDataLength;\n    const wasm2 = getInstance();\n    if (Array.isArray(modelData)) {\n      [modelDataOffset, modelDataLength] = modelData;\n    } else if (modelData.buffer === wasm2.HEAPU8.buffer) {\n      [modelDataOffset, modelDataLength] = [modelData.byteOffset, modelData.byteLength];\n    } else {\n      [modelDataOffset, modelDataLength] = copyFromExternalBuffer(modelData);\n    }\n    let sessionHandle = 0;\n    let sessionOptionsHandle = 0;\n    let ioBindingHandle = 0;\n    let allocs = [];\n    const inputNamesUTF8Encoded = [];\n    const outputNamesUTF8Encoded = [];\n    try {\n      [sessionOptionsHandle, allocs] = setSessionOptions(options);\n      if (options?.externalData && wasm2.mountExternalData) {\n        const loadingPromises = [];\n        for (const file of options.externalData) {\n          const path = typeof file === \"string\" ? file : file.path;\n          loadingPromises.push(loadFile(typeof file === \"string\" ? file : file.data).then((data) => {\n            wasm2.mountExternalData(path, data);\n          }));\n        }\n        await Promise.all(loadingPromises);\n      }\n      sessionHandle = await wasm2._OrtCreateSession(modelDataOffset, modelDataLength, sessionOptionsHandle);\n      if (sessionHandle === 0) {\n        checkLastError(\"Can't create a session.\");\n      }\n      const [inputCount, outputCount] = getSessionInputOutputCount(sessionHandle);\n      const enableGraphCapture = !!options?.enableGraphCapture;\n      const inputNames = [];\n      const outputNames = [];\n      const outputPreferredLocations = [];\n      for (let i = 0; i < inputCount; i++) {\n        const name = wasm2._OrtGetInputName(sessionHandle, i);\n        if (name === 0) {\n          checkLastError(\"Can't get an input name.\");\n        }\n        inputNamesUTF8Encoded.push(name);\n        inputNames.push(wasm2.UTF8ToString(name));\n      }\n      for (let i = 0; i < outputCount; i++) {\n        const name = wasm2._OrtGetOutputName(sessionHandle, i);\n        if (name === 0) {\n          checkLastError(\"Can't get an output name.\");\n        }\n        outputNamesUTF8Encoded.push(name);\n        const nameString = wasm2.UTF8ToString(name);\n        outputNames.push(nameString);\n        if (true) {\n          if (enableGraphCapture && options?.preferredOutputLocation === void 0) {\n            outputPreferredLocations.push(\"gpu-buffer\");\n            continue;\n          }\n          const location = typeof options?.preferredOutputLocation === \"string\" ? options.preferredOutputLocation : options?.preferredOutputLocation?.[nameString] ?? \"cpu\";\n          if (location !== \"cpu\" && location !== \"cpu-pinned\" && location !== \"gpu-buffer\") {\n            throw new Error(`Not supported preferred output location: ${location}.`);\n          }\n          if (enableGraphCapture && location !== \"gpu-buffer\") {\n            throw new Error(`Not supported preferred output location: ${location}. Only 'gpu-buffer' location is supported when enableGraphCapture is true.`);\n          }\n          outputPreferredLocations.push(location);\n        }\n      }\n      let bindingState = null;\n      if (outputPreferredLocations.some((l) => l === \"gpu-buffer\")) {\n        ioBindingHandle = wasm2._OrtCreateBinding(sessionHandle);\n        if (ioBindingHandle === 0) {\n          checkLastError(\"Can't create IO binding.\");\n        }\n        bindingState = {\n          handle: ioBindingHandle,\n          outputPreferredLocations,\n          outputPreferredLocationsEncoded: outputPreferredLocations.map((l) => dataLocationStringToEnum(l))\n        };\n      }\n      activeSessions.set(\n        sessionHandle,\n        [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, bindingState, enableGraphCapture, false]\n      );\n      return [sessionHandle, inputNames, outputNames];\n    } catch (e) {\n      inputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf));\n      outputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf));\n      if (ioBindingHandle !== 0) {\n        wasm2._OrtReleaseBinding(ioBindingHandle);\n      }\n      if (sessionHandle !== 0) {\n        wasm2._OrtReleaseSession(sessionHandle);\n      }\n      throw e;\n    } finally {\n      wasm2._free(modelDataOffset);\n      if (sessionOptionsHandle !== 0) {\n        wasm2._OrtReleaseSessionOptions(sessionOptionsHandle);\n      }\n      allocs.forEach((alloc) => wasm2._free(alloc));\n      wasm2.unmountExternalData?.();\n    }\n  };\n  var releaseSession = (sessionId) => {\n    const wasm2 = getInstance();\n    const session = activeSessions.get(sessionId);\n    if (!session) {\n      throw new Error(`cannot release session. invalid session id: ${sessionId}`);\n    }\n    const [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture] = session;\n    if (ioBindingState) {\n      if (enableGraphCapture) {\n        wasm2._OrtClearBoundOutputs(ioBindingState.handle);\n      }\n      wasm2._OrtReleaseBinding(ioBindingState.handle);\n    }\n    wasm2.jsepOnReleaseSession?.(sessionId);\n    inputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf));\n    outputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf));\n    wasm2._OrtReleaseSession(sessionHandle);\n    activeSessions.delete(sessionId);\n  };\n  var prepareInputOutputTensor = (tensor, tensorHandles, allocs, sessionId, index, enableGraphCapture = false) => {\n    if (!tensor) {\n      tensorHandles.push(0);\n      return;\n    }\n    const wasm2 = getInstance();\n    const dataType = tensor[0];\n    const dims = tensor[1];\n    const location = tensor[3];\n    let rawData;\n    let dataByteLength;\n    if (dataType === \"string\" && location === \"gpu-buffer\") {\n      throw new Error(\"String tensor is not supported on GPU.\");\n    }\n    if (enableGraphCapture && location !== \"gpu-buffer\") {\n      throw new Error(\n        `External buffer must be provided for input/output index ${index} when enableGraphCapture is true.`\n      );\n    }\n    if (location === \"gpu-buffer\") {\n      const gpuBuffer = tensor[2].gpuBuffer;\n      const elementSizeInBytes = getTensorElementSize(tensorDataTypeStringToEnum(dataType));\n      dataByteLength = dims.reduce((a, b) => a * b, 1) * elementSizeInBytes;\n      const registerBuffer = wasm2.jsepRegisterBuffer;\n      if (!registerBuffer) {\n        throw new Error('Tensor location \"gpu-buffer\" is not supported without using WebGPU.');\n      }\n      rawData = registerBuffer(sessionId, index, gpuBuffer, dataByteLength);\n    } else {\n      const data = tensor[2];\n      if (Array.isArray(data)) {\n        dataByteLength = 4 * data.length;\n        rawData = wasm2._malloc(dataByteLength);\n        allocs.push(rawData);\n        let dataIndex = rawData / 4;\n        for (let i = 0; i < data.length; i++) {\n          if (typeof data[i] !== \"string\") {\n            throw new TypeError(`tensor data at index ${i} is not a string`);\n          }\n          wasm2.HEAPU32[dataIndex++] = allocWasmString(data[i], allocs);\n        }\n      } else {\n        dataByteLength = data.byteLength;\n        rawData = wasm2._malloc(dataByteLength);\n        allocs.push(rawData);\n        wasm2.HEAPU8.set(new Uint8Array(data.buffer, data.byteOffset, dataByteLength), rawData);\n      }\n    }\n    const stack = wasm2.stackSave();\n    const dimsOffset = wasm2.stackAlloc(4 * dims.length);\n    try {\n      let dimIndex = dimsOffset / 4;\n      dims.forEach((d) => wasm2.HEAP32[dimIndex++] = d);\n      const tensor2 = wasm2._OrtCreateTensor(\n        tensorDataTypeStringToEnum(dataType),\n        rawData,\n        dataByteLength,\n        dimsOffset,\n        dims.length,\n        dataLocationStringToEnum(location)\n      );\n      if (tensor2 === 0) {\n        checkLastError(`Can't create tensor for input/output. session=${sessionId}, index=${index}.`);\n      }\n      tensorHandles.push(tensor2);\n    } finally {\n      wasm2.stackRestore(stack);\n    }\n  };\n  var run = async (sessionId, inputIndices, inputTensors, outputIndices, outputTensors, options) => {\n    const wasm2 = getInstance();\n    const session = activeSessions.get(sessionId);\n    if (!session) {\n      throw new Error(`cannot run inference. invalid session id: ${sessionId}`);\n    }\n    const sessionHandle = session[0];\n    const inputNamesUTF8Encoded = session[1];\n    const outputNamesUTF8Encoded = session[2];\n    const ioBindingState = session[3];\n    const enableGraphCapture = session[4];\n    const inputOutputBound = session[5];\n    const inputCount = inputIndices.length;\n    const outputCount = outputIndices.length;\n    let runOptionsHandle = 0;\n    let runOptionsAllocs = [];\n    const inputTensorHandles = [];\n    const outputTensorHandles = [];\n    const inputOutputAllocs = [];\n    const beforeRunStack = wasm2.stackSave();\n    const inputValuesOffset = wasm2.stackAlloc(inputCount * 4);\n    const inputNamesOffset = wasm2.stackAlloc(inputCount * 4);\n    const outputValuesOffset = wasm2.stackAlloc(outputCount * 4);\n    const outputNamesOffset = wasm2.stackAlloc(outputCount * 4);\n    try {\n      [runOptionsHandle, runOptionsAllocs] = setRunOptions(options);\n      for (let i = 0; i < inputCount; i++) {\n        prepareInputOutputTensor(\n          inputTensors[i],\n          inputTensorHandles,\n          inputOutputAllocs,\n          sessionId,\n          inputIndices[i],\n          enableGraphCapture\n        );\n      }\n      for (let i = 0; i < outputCount; i++) {\n        prepareInputOutputTensor(\n          outputTensors[i],\n          outputTensorHandles,\n          inputOutputAllocs,\n          sessionId,\n          inputCount + outputIndices[i],\n          enableGraphCapture\n        );\n      }\n      let inputValuesIndex = inputValuesOffset / 4;\n      let inputNamesIndex = inputNamesOffset / 4;\n      let outputValuesIndex = outputValuesOffset / 4;\n      let outputNamesIndex = outputNamesOffset / 4;\n      for (let i = 0; i < inputCount; i++) {\n        wasm2.HEAPU32[inputValuesIndex++] = inputTensorHandles[i];\n        wasm2.HEAPU32[inputNamesIndex++] = inputNamesUTF8Encoded[inputIndices[i]];\n      }\n      for (let i = 0; i < outputCount; i++) {\n        wasm2.HEAPU32[outputValuesIndex++] = outputTensorHandles[i];\n        wasm2.HEAPU32[outputNamesIndex++] = outputNamesUTF8Encoded[outputIndices[i]];\n      }\n      if (ioBindingState && !inputOutputBound) {\n        const { handle, outputPreferredLocations, outputPreferredLocationsEncoded } = ioBindingState;\n        if (inputNamesUTF8Encoded.length !== inputCount) {\n          throw new Error(`input count from feeds (${inputCount}) is expected to be always equal to model's input count (${inputNamesUTF8Encoded.length}).`);\n        }\n        for (let i = 0; i < inputCount; i++) {\n          const index = inputIndices[i];\n          const errorCode2 = await wasm2._OrtBindInput(handle, inputNamesUTF8Encoded[index], inputTensorHandles[i]);\n          if (errorCode2 !== 0) {\n            checkLastError(`Can't bind input[${i}] for session=${sessionId}.`);\n          }\n        }\n        for (let i = 0; i < outputCount; i++) {\n          const index = outputIndices[i];\n          const location = outputTensors[i]?.[3];\n          if (location) {\n            const errorCode2 = wasm2._OrtBindOutput(handle, outputNamesUTF8Encoded[index], outputTensorHandles[i], 0);\n            if (errorCode2 !== 0) {\n              checkLastError(`Can't bind pre-allocated output[${i}] for session=${sessionId}.`);\n            }\n          } else {\n            const errorCode2 = wasm2._OrtBindOutput(handle, outputNamesUTF8Encoded[index], 0, outputPreferredLocationsEncoded[index]);\n            if (errorCode2 !== 0) {\n              checkLastError(`Can't bind output[${i}] to ${outputPreferredLocations[i]} for session=${sessionId}.`);\n            }\n          }\n        }\n        activeSessions.set(\n          sessionId,\n          [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture, true]\n        );\n      }\n      wasm2.jsepOnRunStart?.(sessionHandle);\n      let errorCode;\n      if (ioBindingState) {\n        errorCode = await wasm2._OrtRunWithBinding(\n          sessionHandle,\n          ioBindingState.handle,\n          outputCount,\n          outputValuesOffset,\n          runOptionsHandle\n        );\n      } else {\n        errorCode = await wasm2._OrtRun(\n          sessionHandle,\n          inputNamesOffset,\n          inputValuesOffset,\n          inputCount,\n          outputNamesOffset,\n          outputCount,\n          outputValuesOffset,\n          runOptionsHandle\n        );\n      }\n      if (errorCode !== 0) {\n        checkLastError(\"failed to call OrtRun().\");\n      }\n      const output = [];\n      for (let i = 0; i < outputCount; i++) {\n        const tensor = wasm2.HEAPU32[outputValuesOffset / 4 + i];\n        if (tensor === outputTensorHandles[i]) {\n          output.push(outputTensors[i]);\n          continue;\n        }\n        const beforeGetTensorDataStack = wasm2.stackSave();\n        const tensorDataOffset = wasm2.stackAlloc(4 * 4);\n        let keepOutputTensor = false;\n        let type, dataOffset = 0;\n        try {\n          const errorCode2 = wasm2._OrtGetTensorData(\n            tensor,\n            tensorDataOffset,\n            tensorDataOffset + 4,\n            tensorDataOffset + 8,\n            tensorDataOffset + 12\n          );\n          if (errorCode2 !== 0) {\n            checkLastError(`Can't access output tensor data on index ${i}.`);\n          }\n          let tensorDataIndex = tensorDataOffset / 4;\n          const dataType = wasm2.HEAPU32[tensorDataIndex++];\n          dataOffset = wasm2.HEAPU32[tensorDataIndex++];\n          const dimsOffset = wasm2.HEAPU32[tensorDataIndex++];\n          const dimsLength = wasm2.HEAPU32[tensorDataIndex++];\n          const dims = [];\n          for (let i2 = 0; i2 < dimsLength; i2++) {\n            dims.push(wasm2.HEAPU32[dimsOffset / 4 + i2]);\n          }\n          wasm2._OrtFree(dimsOffset);\n          const size = dims.reduce((a, b) => a * b, 1);\n          type = tensorDataTypeEnumToString(dataType);\n          const preferredLocation = ioBindingState?.outputPreferredLocations[outputIndices[i]];\n          if (type === \"string\") {\n            if (preferredLocation === \"gpu-buffer\") {\n              throw new Error(\"String tensor is not supported on GPU.\");\n            }\n            const stringData = [];\n            let dataIndex = dataOffset / 4;\n            for (let i2 = 0; i2 < size; i2++) {\n              const offset = wasm2.HEAPU32[dataIndex++];\n              const maxBytesToRead = i2 === size - 1 ? void 0 : wasm2.HEAPU32[dataIndex] - offset;\n              stringData.push(wasm2.UTF8ToString(offset, maxBytesToRead));\n            }\n            output.push([type, dims, stringData, \"cpu\"]);\n          } else {\n            if (preferredLocation === \"gpu-buffer\" && size > 0) {\n              const getBuffer = wasm2.jsepGetBuffer;\n              if (!getBuffer) {\n                throw new Error('preferredLocation \"gpu-buffer\" is not supported without using WebGPU.');\n              }\n              const gpuBuffer = getBuffer(dataOffset);\n              const elementSize = getTensorElementSize(dataType);\n              if (elementSize === void 0 || !isGpuBufferSupportedType(type)) {\n                throw new Error(`Unsupported data type: ${type}`);\n              }\n              keepOutputTensor = true;\n              output.push([\n                type,\n                dims,\n                {\n                  gpuBuffer,\n                  download: wasm2.jsepCreateDownloader(gpuBuffer, size * elementSize, type),\n                  dispose: () => {\n                    wasm2._OrtReleaseTensor(tensor);\n                  }\n                },\n                \"gpu-buffer\"\n              ]);\n            } else {\n              const typedArrayConstructor = tensorTypeToTypedArrayConstructor(type);\n              const data = new typedArrayConstructor(size);\n              new Uint8Array(data.buffer, data.byteOffset, data.byteLength).set(wasm2.HEAPU8.subarray(dataOffset, dataOffset + data.byteLength));\n              output.push([type, dims, data, \"cpu\"]);\n            }\n          }\n        } finally {\n          wasm2.stackRestore(beforeGetTensorDataStack);\n          if (type === \"string\" && dataOffset) {\n            wasm2._free(dataOffset);\n          }\n          if (!keepOutputTensor) {\n            wasm2._OrtReleaseTensor(tensor);\n          }\n        }\n      }\n      if (ioBindingState && !enableGraphCapture) {\n        wasm2._OrtClearBoundOutputs(ioBindingState.handle);\n        activeSessions.set(\n          sessionId,\n          [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture, false]\n        );\n      }\n      return output;\n    } finally {\n      wasm2.stackRestore(beforeRunStack);\n      inputTensorHandles.forEach((v) => wasm2._OrtReleaseTensor(v));\n      outputTensorHandles.forEach((v) => wasm2._OrtReleaseTensor(v));\n      inputOutputAllocs.forEach((p) => wasm2._free(p));\n      if (runOptionsHandle !== 0) {\n        wasm2._OrtReleaseRunOptions(runOptionsHandle);\n      }\n      runOptionsAllocs.forEach((p) => wasm2._free(p));\n    }\n  };\n  var endProfiling = (sessionId) => {\n    const wasm2 = getInstance();\n    const session = activeSessions.get(sessionId);\n    if (!session) {\n      throw new Error(\"invalid session id\");\n    }\n    const sessionHandle = session[0];\n    const profileFileName = wasm2._OrtEndProfiling(sessionHandle);\n    if (profileFileName === 0) {\n      checkLastError(\"Can't get an profile file name.\");\n    }\n    wasm2._OrtFree(profileFileName);\n  };\n  var extractTransferableBuffers = (tensors) => {\n    const buffers = [];\n    for (const tensor of tensors) {\n      const data = tensor[2];\n      if (!Array.isArray(data) && \"buffer\" in data) {\n        buffers.push(data.buffer);\n      }\n    }\n    return buffers;\n  };\n\n  // web/lib/wasm/proxy-worker/main.ts\n  self.onmessage = (ev) => {\n    const { type, in: message } = ev.data;\n    try {\n      switch (type) {\n        case \"init-wasm\":\n          initializeWebAssembly(message.wasm).then(\n            () => {\n              initRuntime(message).then(\n                () => {\n                  postMessage({ type });\n                },\n                (err) => {\n                  postMessage({ type, err });\n                }\n              );\n            },\n            (err) => {\n              postMessage({ type, err });\n            }\n          );\n          break;\n        case \"init-ep\": {\n          const { epName, env: env3 } = message;\n          initEp(env3, epName).then(\n            () => {\n              postMessage({ type });\n            },\n            (err) => {\n              postMessage({ type, err });\n            }\n          );\n          break;\n        }\n        case \"copy-from\": {\n          const { buffer } = message;\n          const bufferData = copyFromExternalBuffer(buffer);\n          postMessage({ type, out: bufferData });\n          break;\n        }\n        case \"create\": {\n          const { model, options } = message;\n          createSession(model, options).then(\n            (sessionMetadata) => {\n              postMessage({ type, out: sessionMetadata });\n            },\n            (err) => {\n              postMessage({ type, err });\n            }\n          );\n          break;\n        }\n        case \"release\":\n          releaseSession(message);\n          postMessage({ type });\n          break;\n        case \"run\": {\n          const { sessionId, inputIndices, inputs, outputIndices, options } = message;\n          run(sessionId, inputIndices, inputs, outputIndices, new Array(outputIndices.length).fill(null), options).then(\n            (outputs) => {\n              if (outputs.some((o) => o[3] !== \"cpu\")) {\n                postMessage({ type, err: \"Proxy does not support non-cpu tensor location.\" });\n              } else {\n                postMessage(\n                  { type, out: outputs },\n                  extractTransferableBuffers([...inputs, ...outputs])\n                );\n              }\n            },\n            (err) => {\n              postMessage({ type, err });\n            }\n          );\n          break;\n        }\n        case \"end-profiling\":\n          endProfiling(message);\n          postMessage({ type });\n          break;\n        default:\n      }\n    } catch (err) {\n      postMessage({ type, err });\n    }\n  };\n})();\n/**\n * @license\n * Copyright 2021 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n/**\n * @license\n * Copyright 2020 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n/**\n * @license\n * Copyright 2019 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["nodejs-ignore:fs", "nodejs-ignore:path", "../../lib/wasm/binding/ort-wasm-simd.jsep.js", "nodejs-ignore:worker_threads", "nodejs-ignore:perf_hooks", "nodejs-ignore:os", "../../lib/wasm/binding/ort-wasm-simd-threaded.jsep.js", "../../lib/wasm/binding/ort-wasm-threaded.worker.js", "../../lib/wasm/wasm-common.ts", "../../../common/lib/backend-impl.ts", "../../../common/lib/backend.ts", "../../../common/lib/version.ts", "../../../common/lib/env-impl.ts", "../../../common/lib/env.ts", "../../../common/lib/tensor-conversion-impl.ts", "../../../common/lib/tensor-factory-impl.ts", "../../../common/lib/tensor-impl-type-mapping.ts", "../../../common/lib/tensor-utils-impl.ts", "../../../common/lib/tensor-impl.ts", "../../../common/lib/tensor.ts", "../../../common/lib/trace.ts", "../../../common/lib/inference-session-impl.ts", "../../../common/lib/inference-session.ts", "../../../common/lib/tensor-conversion.ts", "../../../common/lib/tensor-factory.ts", "../../../common/lib/onnx-model.ts", "../../../common/lib/onnx-value.ts", "../../../common/lib/training-session-impl.ts", "../../../common/lib/training-session.ts", "../../../common/lib/index.ts", "../../lib/wasm/jsep/log.ts", "../../lib/wasm/jsep/tensor-view.ts", "../../lib/wasm/jsep/webgpu/types.ts", "../../lib/wasm/jsep/webgpu/gpu-data-manager.ts", "../../lib/wasm/jsep/webgpu/attribute-with-cache-key.ts", "../../lib/wasm/jsep/util.ts", "../../lib/wasm/jsep/webgpu/ops/common.ts", "../../lib/wasm/jsep/webgpu/ops/transpose.ts", "../../lib/wasm/jsep/webgpu/ops/reduce-shared.ts", "../../lib/wasm/jsep/webgpu/ops/reduce.ts", "../../lib/wasm/jsep/webgpu/ops/argminmax.ts", "../../lib/wasm/jsep/webgpu/ops/concat.ts", "../../lib/wasm/jsep/webgpu/ops/attention.ts", "../../lib/wasm/jsep/webgpu/ops/batch-norm.ts", "../../lib/wasm/jsep/webgpu/ops/bias-add.ts", "../../lib/wasm/jsep/webgpu/ops/unary-op.ts", "../../lib/wasm/jsep/webgpu/ops/bias-split-gelu.ts", "../../lib/wasm/jsep/webgpu/ops/binary-op.ts", "../../lib/wasm/jsep/webgpu/ops/fuse-utils.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/activation_util.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/conv_util.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/matmul_packed_webgpu.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/conv2d_mm_webgpu.ts", "../../lib/wasm/jsep/webgpu/ops/conv-grouped.ts", "../../lib/wasm/jsep/webgpu/ops/matmul.ts", "../../lib/wasm/jsep/webgpu/ops/conv.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_mm_webgpu.ts", "../../lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_webgpu.ts", "../../lib/wasm/jsep/webgpu/ops/conv-transpose.ts", "../../lib/wasm/jsep/webgpu/ops/cumsum.ts", "../../lib/wasm/jsep/webgpu/ops/depth-to-space.ts", "../../lib/wasm/jsep/webgpu/ops/einsum.ts", "../../lib/wasm/jsep/webgpu/ops/expand.ts", "../../lib/wasm/jsep/webgpu/ops/fast-gelu.ts", "../../lib/wasm/jsep/webgpu/ops/gather.ts", "../../lib/wasm/jsep/webgpu/ops/gather-elements.ts", "../../lib/wasm/jsep/webgpu/ops/gemm.ts", "../../lib/wasm/jsep/webgpu/ops/instance-norm.ts", "../../lib/wasm/jsep/webgpu/ops/layer-norm.ts", "../../lib/wasm/jsep/webgpu/ops/matmulnbits.ts", "../../lib/wasm/jsep/webgpu/ops/multihead-attentiion.ts", "../../lib/wasm/jsep/webgpu/ops/pad.ts", "../../lib/wasm/jsep/webgpu/ops/pool.ts", "../../lib/wasm/jsep/webgpu/ops/range.ts", "../../lib/wasm/jsep/webgpu/ops/resize.ts", "../../lib/wasm/jsep/webgpu/ops/rotary-embedding.ts", "../../lib/wasm/jsep/webgpu/ops/skip-layer-norm.ts", "../../lib/wasm/jsep/webgpu/ops/slice.ts", "../../lib/wasm/jsep/webgpu/ops/softmax.ts", "../../lib/wasm/jsep/webgpu/ops/split.ts", "../../lib/wasm/jsep/webgpu/ops/tile.ts", "../../lib/wasm/jsep/webgpu/ops/where.ts", "../../lib/wasm/jsep/webgpu/op-resolve-rules.ts", "../../lib/wasm/jsep/webgpu/program-manager.ts", "../../lib/wasm/jsep/backend-webgpu.ts", "../../lib/wasm/jsep/init.ts", "nodejs-ignore:node:path", "../../lib/wasm/wasm-factory.ts", "../../lib/wasm/wasm-utils.ts", "../../lib/wasm/run-options.ts", "../../lib/wasm/session-options.ts", "../../lib/wasm/wasm-core-impl.ts", "../../lib/wasm/wasm-utils-load-file.ts", "nodejs-ignore:node:fs/promises", "../../lib/wasm/proxy-worker/main.ts"],
  "sourcesContent": ["export const readFile = undefined;export const readFileSync = undefined;export const createReadStream = undefined;", "export const join = undefined;", "\nvar ortWasm = (() => {\n  var _scriptDir = typeof document != 'undefined' ? document.currentScript?.src : undefined;\n  if (typeof __filename != 'undefined') _scriptDir ||= __filename;\n  return (\nfunction(moduleArg = {}) {\n\nvar g=moduleArg,aa,ba,readyPromise=new Promise((a,b)=>{aa=a;ba=b});\"use strict\";g.mountExternalData=(a,b)=>{(g.Ph||(g.Ph=new Map)).set(a,b)};g.unmountExternalData=()=>{delete g.Ph};\nlet da=()=>{const a=(c,d,e)=>(...f)=>{const h=t,k=d?.();f=c(...f);const l=d?.();k!==l&&(c=l,e(k),d=e=null);return t!=h?ca():f},b=c=>async(...d)=>{try{if(g.Oh)throw Error(\"Session already started\");const e=g.Oh={gi:d[0],errors:[]},f=await c(...d);if(g.Oh!==e)throw Error(\"Session mismatch\");g.Uh?.flush();const h=e.errors;if(0<h.length){let k=await Promise.all(h);k=k.filter(l=>l);if(0<k.length)throw Error(k.join(\"\\n\"));}return f}finally{g.Oh=null}};g._OrtCreateSession=a(g._OrtCreateSession,()=>g._OrtCreateSession,\nc=>g._OrtCreateSession=c);g._OrtRun=b(a(g._OrtRun,()=>g._OrtRun,c=>g._OrtRun=c));g._OrtRunWithBinding=b(a(g._OrtRunWithBinding,()=>g._OrtRunWithBinding,c=>g._OrtRunWithBinding=c));g._OrtBindInput=a(g._OrtBindInput,()=>g._OrtBindInput,c=>g._OrtBindInput=c);da=void 0};\ng.jsepInit=(a,b)=>{da?.();if(\"webgpu\"===a){[g.Uh,g.Zh,g.ci,g.Vh,g.bi,g.je,g.di,g.fi,g.$h,g.ai,g.ei]=b;const c=g.Uh;g.jsepRegisterBuffer=(d,e,f,h)=>c.registerBuffer(d,e,f,h);g.jsepGetBuffer=d=>c.getBuffer(d);g.jsepCreateDownloader=(d,e,f)=>c.createDownloader(d,e,f);g.jsepOnReleaseSession=d=>{c.onReleaseSession(d)};g.jsepOnRunStart=d=>c.onRunStart(d)}};\nvar ea=Object.assign({},g),fa=\"./this.program\",ha=(a,b)=>{throw b;},ia=\"object\"==typeof window,ja=\"function\"==typeof importScripts,ka=\"object\"==typeof process&&\"object\"==typeof process.versions&&\"string\"==typeof process.versions.node,v=\"\",la,ma,na;\nif(ka){var fs=require(\"fs\"),oa=require(\"path\");v=ja?oa.dirname(v)+\"/\":__dirname+\"/\";la=(a,b)=>{a=pa(a)?new URL(a):oa.normalize(a);return fs.readFileSync(a,b?void 0:\"utf8\")};na=a=>{a=la(a,!0);a.buffer||(a=new Uint8Array(a));return a};ma=(a,b,c,d=!0)=>{a=pa(a)?new URL(a):oa.normalize(a);fs.readFile(a,d?void 0:\"utf8\",(e,f)=>{e?c(e):b(d?f.buffer:f)})};!g.thisProgram&&1<process.argv.length&&(fa=process.argv[1].replace(/\\\\/g,\"/\"));process.argv.slice(2);ha=(a,b)=>{process.exitCode=a;throw b;}}else if(ia||\nja)ja?v=self.location.href:\"undefined\"!=typeof document&&document.currentScript&&(v=document.currentScript.src),_scriptDir&&(v=_scriptDir),v.startsWith(\"blob:\")?v=\"\":v=v.substr(0,v.replace(/[?#].*/,\"\").lastIndexOf(\"/\")+1),la=a=>{var b=new XMLHttpRequest;b.open(\"GET\",a,!1);b.send(null);return b.responseText},ja&&(na=a=>{var b=new XMLHttpRequest;b.open(\"GET\",a,!1);b.responseType=\"arraybuffer\";b.send(null);return new Uint8Array(b.response)}),ma=(a,b,c)=>{var d=new XMLHttpRequest;d.open(\"GET\",a,!0);d.responseType=\n\"arraybuffer\";d.onload=()=>{200==d.status||0==d.status&&d.response?b(d.response):c()};d.onerror=c;d.send(null)};var qa=console.log.bind(console),w=console.error.bind(console);Object.assign(g,ea);ea=null;var ra,x=!1,sa,z,E,ta,ua,G,I,va,wa,xa,ya;\nfunction za(){var a=ra.buffer;g.HEAP8=z=new Int8Array(a);g.HEAP16=ta=new Int16Array(a);g.HEAPU8=E=new Uint8Array(a);g.HEAPU16=ua=new Uint16Array(a);g.HEAP32=G=new Int32Array(a);g.HEAPU32=I=new Uint32Array(a);g.HEAPF32=va=new Float32Array(a);g.HEAPF64=ya=new Float64Array(a);g.HEAP64=wa=new BigInt64Array(a);g.HEAPU64=xa=new BigUint64Array(a)}var Aa=[],Ba=[],Ca=[],Da=0,Ea=null,Fa=null;\nfunction Ga(a){a=\"Aborted(\"+a+\")\";w(a);x=!0;sa=1;a=new WebAssembly.RuntimeError(a+\". Build with -sASSERTIONS for more info.\");ba(a);throw a;}var Ha=a=>a.startsWith(\"data:application/octet-stream;base64,\"),pa=a=>a.startsWith(\"file://\"),Ia;Ia=\"ort-wasm-simd.wasm\";if(!Ha(Ia)){var Ja=Ia;Ia=g.locateFile?g.locateFile(Ja,v):v+Ja}function Ka(a){if(na)return na(a);throw\"both async and sync fetching of the wasm failed\";}\nfunction La(a){if(ia||ja){if(\"function\"==typeof fetch&&!pa(a))return fetch(a,{credentials:\"same-origin\"}).then(b=>{if(!b.ok)throw`failed to load wasm binary file at '${a}'`;return b.arrayBuffer()}).catch(()=>Ka(a));if(ma)return new Promise((b,c)=>{ma(a,d=>b(new Uint8Array(d)),c)})}return Promise.resolve().then(()=>Ka(a))}function Ma(a,b,c){return La(a).then(d=>WebAssembly.instantiate(d,b)).then(c,d=>{w(`failed to asynchronously prepare wasm: ${d}`);Ga(d)})}\nfunction Na(a,b){var c=Ia;return\"function\"!=typeof WebAssembly.instantiateStreaming||Ha(c)||pa(c)||ka||\"function\"!=typeof fetch?Ma(c,a,b):fetch(c,{credentials:\"same-origin\"}).then(d=>WebAssembly.instantiateStreaming(d,a).then(b,function(e){w(`wasm streaming compile failed: ${e}`);w(\"falling back to ArrayBuffer instantiation\");return Ma(c,a,b)}))}\nvar Oa={1261504:(a,b,c,d)=>{if(\"undefined\"==typeof g||!g.Ph)return 1;a=J(a>>>0);a.startsWith(\"./\")&&(a=a.substring(2));a=g.Ph.get(a);if(!a)return 2;b>>>=0;c>>>=0;if(b+c>a.byteLength)return 3;try{return E.set(a.subarray(b,b+c),d>>>0>>>0),0}catch{return 4}},1262005:(a,b,c)=>{c=J(c);const d=new Uint8Array(b);d.set(E.subarray(a>>>0,a+b>>>0));\"object\"==typeof process&&\"object\"==typeof process.versions&&\"string\"==typeof process.versions.node?require(\"fs\").writeFileSync(c,d):(a=new File([d],c,{type:\"application/octet-stream\"}),\na=URL.createObjectURL(a),window.open(a,\"_blank\"))},1262513:()=>{g.$h()},1262544:()=>{g.ai()},1262573:()=>{g.ei()},1262598:a=>g.Zh(a),1262631:a=>g.ci(a),1262663:(a,b,c)=>{g.Vh(a,b,c,!0)},1262702:(a,b,c)=>{g.Vh(a,b,c)},1262735:a=>{g.je(\"Abs\",a,void 0)},1262786:a=>{g.je(\"Neg\",a,void 0)},1262837:a=>{g.je(\"Floor\",a,void 0)},1262890:a=>{g.je(\"Ceil\",a,void 0)},1262942:a=>{g.je(\"Reciprocal\",a,void 0)},1263E3:a=>{g.je(\"Sqrt\",a,void 0)},1263052:a=>{g.je(\"Exp\",a,void 0)},1263103:a=>{g.je(\"Erf\",a,void 0)},1263154:a=>\n{g.je(\"Sigmoid\",a,void 0)},1263209:(a,b,c)=>{g.je(\"HardSigmoid\",a,{alpha:b,beta:c})},1263288:a=>{g.je(\"Log\",a,void 0)},1263339:a=>{g.je(\"Sin\",a,void 0)},1263390:a=>{g.je(\"Cos\",a,void 0)},1263441:a=>{g.je(\"Tan\",a,void 0)},1263492:a=>{g.je(\"Asin\",a,void 0)},1263544:a=>{g.je(\"Acos\",a,void 0)},1263596:a=>{g.je(\"Atan\",a,void 0)},1263648:a=>{g.je(\"Sinh\",a,void 0)},1263700:a=>{g.je(\"Cosh\",a,void 0)},1263752:a=>{g.je(\"Asinh\",a,void 0)},1263805:a=>{g.je(\"Acosh\",a,void 0)},1263858:a=>{g.je(\"Atanh\",a,void 0)},\n1263911:a=>{g.je(\"Tanh\",a,void 0)},1263963:a=>{g.je(\"Not\",a,void 0)},1264014:(a,b,c)=>{g.je(\"Clip\",a,{min:b,max:c})},1264083:a=>{g.je(\"Clip\",a,void 0)},1264135:(a,b)=>{g.je(\"Elu\",a,{alpha:b})},1264193:a=>{g.je(\"Relu\",a,void 0)},1264245:(a,b)=>{g.je(\"LeakyRelu\",a,{alpha:b})},1264309:(a,b)=>{g.je(\"ThresholdedRelu\",a,{alpha:b})},1264379:(a,b)=>{g.je(\"Cast\",a,{to:b})},1264437:a=>{g.je(\"Add\",a,void 0)},1264488:a=>{g.je(\"Sub\",a,void 0)},1264539:a=>{g.je(\"Mul\",a,void 0)},1264590:a=>{g.je(\"Div\",a,void 0)},\n1264641:a=>{g.je(\"Pow\",a,void 0)},1264692:a=>{g.je(\"Equal\",a,void 0)},1264745:a=>{g.je(\"Greater\",a,void 0)},1264800:a=>{g.je(\"GreaterOrEqual\",a,void 0)},1264862:a=>{g.je(\"Less\",a,void 0)},1264914:a=>{g.je(\"LessOrEqual\",a,void 0)},1264973:(a,b,c,d,e)=>{g.je(\"ReduceMean\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265132:(a,b,c,d,e)=>{g.je(\"ReduceMax\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265290:(a,b,c,d,e)=>\n{g.je(\"ReduceMin\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265448:(a,b,c,d,e)=>{g.je(\"ReduceProd\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265607:(a,b,c,d,e)=>{g.je(\"ReduceSum\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265765:(a,b,c,d,e)=>{g.je(\"ReduceL1\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1265922:(a,b,c,d,e)=>\n{g.je(\"ReduceL2\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1266079:(a,b,c,d,e)=>{g.je(\"ReduceLogSum\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1266240:(a,b,c,d,e)=>{g.je(\"ReduceSumSquare\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1266404:(a,b,c,d,e)=>{g.je(\"ReduceLogSumExp\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1266568:a=>\n{g.je(\"Where\",a,void 0)},1266621:(a,b,c)=>{g.je(\"Transpose\",a,{perm:b?Array.from(G.subarray(b>>>0,c>>>0)):[]})},1266729:(a,b,c,d)=>{g.je(\"DepthToSpace\",a,{blocksize:b,mode:J(c),format:d?\"NHWC\":\"NCHW\"})},1266862:(a,b,c,d)=>{g.je(\"DepthToSpace\",a,{blocksize:b,mode:J(c),format:d?\"NHWC\":\"NCHW\"})},1266995:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>{g.je(\"ConvTranspose\",a,{format:l?\"NHWC\":\"NCHW\",autoPad:b,dilations:[c],group:d,kernelShape:[e],pads:[f,h],strides:[k],wIsConst:()=>!!z[m>>>0],outputPadding:n?Array.from(G.subarray(n>>>\n0,q>>>0)):[],outputShape:r?Array.from(G.subarray(r>>>0,p>>>0)):[],activation:J(u)})},1267396:(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>{g.je(\"ConvTranspose\",a,{format:k?\"NHWC\":\"NCHW\",autoPad:b,dilations:Array.from(G.subarray(c>>>0,(c>>>0)+2>>>0)),group:d,kernelShape:Array.from(G.subarray(e>>>0,(e>>>0)+2>>>0)),pads:Array.from(G.subarray(f>>>0,(f>>>0)+4>>>0)),strides:Array.from(G.subarray(h>>>0,(h>>>0)+2>>>0)),wIsConst:()=>!!z[l>>>0],outputPadding:m?Array.from(G.subarray(m>>>0,n>>>0)):[],outputShape:q?Array.from(G.subarray(q>>>\n0,r>>>0)):[],activation:J(p)})},1267961:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>{g.je(\"ConvTranspose\",a,{format:l?\"NHWC\":\"NCHW\",autoPad:b,dilations:[c],group:d,kernelShape:[e],pads:[f,h],strides:[k],wIsConst:()=>!!z[m>>>0],outputPadding:n?Array.from(G.subarray(n>>>0,q>>>0)):[],outputShape:r?Array.from(G.subarray(r>>>0,p>>>0)):[],activation:J(u)})},1268362:(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>{g.je(\"ConvTranspose\",a,{format:k?\"NHWC\":\"NCHW\",autoPad:b,dilations:Array.from(G.subarray(c>>>0,(c>>>0)+2>>>0)),group:d,\nkernelShape:Array.from(G.subarray(e>>>0,(e>>>0)+2>>>0)),pads:Array.from(G.subarray(f>>>0,(f>>>0)+4>>>0)),strides:Array.from(G.subarray(h>>>0,(h>>>0)+2>>>0)),wIsConst:()=>!!z[l>>>0],outputPadding:m?Array.from(G.subarray(m>>>0,n>>>0)):[],outputShape:q?Array.from(G.subarray(q>>>0,r>>>0)):[],activation:J(p)})},1268927:(a,b)=>{g.je(\"GlobalAveragePool\",a,{format:b?\"NHWC\":\"NCHW\"})},1269018:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>{g.je(\"AveragePool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:d,\nstorage_order:e,dilations:[f,h],kernel_shape:[k,l],pads:[m,n,q,r],strides:[p,u]})},1269302:(a,b)=>{g.je(\"GlobalAveragePool\",a,{format:b?\"NHWC\":\"NCHW\"})},1269393:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>{g.je(\"AveragePool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:e,dilations:[f,h],kernel_shape:[k,l],pads:[m,n,q,r],strides:[p,u]})},1269677:(a,b)=>{g.je(\"GlobalMaxPool\",a,{format:b?\"NHWC\":\"NCHW\"})},1269764:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>{g.je(\"MaxPool\",a,{format:y?\n\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:e,dilations:[f,h],kernel_shape:[k,l],pads:[m,n,q,r],strides:[p,u]})},1270044:(a,b)=>{g.je(\"GlobalMaxPool\",a,{format:b?\"NHWC\":\"NCHW\"})},1270131:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>{g.je(\"MaxPool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:d,storage_order:e,dilations:[f,h],kernel_shape:[k,l],pads:[m,n,q,r],strides:[p,u]})},1270411:(a,b,c,d,e)=>{g.je(\"Gemm\",a,{alpha:b,beta:c,transA:d,transB:e})},1270515:a=>\n{g.je(\"MatMul\",a,void 0)},1270569:(a,b,c,d)=>{g.je(\"ArgMax\",a,{keepDims:!!b,selectLastIndex:!!c,axis:d})},1270677:(a,b,c,d)=>{g.je(\"ArgMin\",a,{keepDims:!!b,selectLastIndex:!!c,axis:d})},1270785:(a,b)=>{g.je(\"Softmax\",a,{axis:b})},1270848:(a,b)=>{g.je(\"Concat\",a,{axis:b})},1270908:(a,b,c,d,e)=>{g.je(\"Split\",a,{axis:b,numOutputs:c,splitSizes:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1271048:a=>{g.je(\"Expand\",a,void 0)},1271102:(a,b)=>{g.je(\"Gather\",a,{axis:Number(b)})},1271173:(a,b)=>{g.je(\"GatherElements\",\na,{axis:Number(b)})},1271252:(a,b,c,d,e,f,h,k,l,m,n)=>{g.je(\"Resize\",a,{antialias:b,axes:c?Array.from(G.subarray(c>>>0,d>>>0)):[],coordinateTransformMode:J(e),cubicCoeffA:f,excludeOutside:h,extrapolationValue:k,keepAspectRatioPolicy:J(l),mode:J(m),nearestMode:J(n)})},1271598:(a,b,c,d,e,f,h)=>{g.je(\"Slice\",a,{starts:b?Array.from(G.subarray(b>>>0,c>>>0)):[],ends:d?Array.from(G.subarray(d>>>0,e>>>0)):[],axes:f?Array.from(G.subarray(f>>>0,h>>>0)):[]})},1271814:a=>{g.je(\"Tile\",a,void 0)},1271866:(a,b,\nc,d)=>{g.je(\"LayerNormalization\",a,{axis:b,epsilon:c,simplified:!!d})},1271977:(a,b,c)=>{g.je(\"InstanceNormalization\",a,{epsilon:b,format:c?\"NHWC\":\"NCHW\"})},1272091:(a,b,c)=>{g.je(\"InstanceNormalization\",a,{epsilon:b,format:c?\"NHWC\":\"NCHW\"})},1272205:a=>{g.je(\"Range\",a,void 0)},1272258:(a,b)=>{g.je(\"Einsum\",a,{equation:J(b)})},1272339:(a,b,c,d,e)=>{g.je(\"Pad\",a,{mode:b,value:c,pads:d?Array.from(G.subarray(d>>>0,e>>>0)):[]})},1272466:(a,b,c,d,e,f)=>{g.je(\"BatchNormalization\",a,{epsilon:b,momentum:c,\nspatial:!!e,trainingMode:!!d,format:f?\"NHWC\":\"NCHW\"})},1272635:(a,b,c,d,e,f)=>{g.je(\"BatchNormalization\",a,{epsilon:b,momentum:c,spatial:!!e,trainingMode:!!d,format:f?\"NHWC\":\"NCHW\"})},1272804:(a,b,c)=>{g.je(\"CumSum\",a,{exclusive:Number(b),reverse:Number(c)})},1272901:(a,b,c,d,e,f,h,k,l)=>{g.je(\"Attention\",a,{numHeads:b,isUnidirectional:c,maskFilterValue:d,scale:e,doRotary:f,qkvHiddenSizes:h?Array.from(G.subarray(Number(k)>>>0,Number(k)+h>>>0)):[],pastPresentShareBuffer:!!l})},1273173:a=>{g.je(\"BiasAdd\",\na,void 0)},1273228:a=>{g.je(\"BiasSplitGelu\",a,void 0)},1273289:a=>{g.je(\"FastGelu\",a,void 0)},1273345:(a,b,c,d,e,f,h,k,l,m,n,q,r)=>{g.je(\"Conv\",a,{format:l?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c],group:d,kernel_shape:[e],pads:f?Array.from(G.subarray(f>>>0,h>>>0)):[],strides:[k],w_is_const:()=>!!z[m>>>0],activation:J(n),activation_params:q?Array.from(va.subarray(q>>>0,r>>>0)):[]})},1273715:(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>{g.je(\"Conv\",a,{format:q?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c,d],group:e,kernel_shape:[f,\nh],pads:k?Array.from(G.subarray(k>>>0,l>>>0)):[],strides:[m,n],w_is_const:()=>!!z[r>>>0],activation:J(p),activation_params:u?Array.from(va.subarray(u>>>0,y>>>0)):[]})},1274106:a=>{g.je(\"Gelu\",a,void 0)},1274158:(a,b,c,d,e,f)=>{g.je(\"MatMulNBits\",a,{k:b,n:c,accuracyLevel:d,bits:e,blockSize:f})},1274285:(a,b,c,d,e,f)=>{g.je(\"MultiHeadAttention\",a,{numHeads:b,isUnidirectional:c,maskFilterValue:d,scale:e,doRotary:f})},1274444:(a,b,c,d,e)=>{g.je(\"RotaryEmbedding\",a,{interleaved:!!b,numHeads:c,rotaryEmbeddingDim:d,\nscale:e})},1274583:(a,b,c)=>{g.je(\"SkipLayerNormalization\",a,{epsilon:b,simplified:!!c})},1274685:(a,b,c)=>{g.je(\"SkipLayerNormalization\",a,{epsilon:b,simplified:!!c})},1274787:(a,b,c,d)=>{g.je(\"LayerNormalization\",a,{axis:b,epsilon:c,simplified:!!d})},1274898:a=>{g.di(a)},1274932:(a,b)=>g.fi(a,b,g.Oh.gi,g.Oh.errors)};function Pa(a){this.name=\"ExitStatus\";this.message=`Program terminated with exit(${a})`;this.status=a}var Qa=[],Ra=0,L=0;class Sa{constructor(a){this.Nh=a;this.Ih=a-24}}\nvar Za=a=>{var b=L;if(!b)return Ta(0),0;var c=new Sa(b);I[c.Ih+16>>>2>>>0]=b;var d=I[c.Ih+4>>>2>>>0];if(!d)return Ta(0),b;for(var e in a){var f=a[e];if(0===f||f===d)break;if(Ua(f,d,c.Ih+16))return Ta(f),b}Ta(d);return b},$a=\"undefined\"!=typeof TextDecoder?new TextDecoder(\"utf8\"):void 0,ab=(a,b,c)=>{b>>>=0;var d=b+c;for(c=b;a[c]&&!(c>=d);)++c;if(16<c-b&&a.buffer&&$a)return $a.decode(a.subarray(b,c));for(d=\"\";b<c;){var e=a[b++];if(e&128){var f=a[b++]&63;if(192==(e&224))d+=String.fromCharCode((e&31)<<\n6|f);else{var h=a[b++]&63;e=224==(e&240)?(e&15)<<12|f<<6|h:(e&7)<<18|f<<12|h<<6|a[b++]&63;65536>e?d+=String.fromCharCode(e):(e-=65536,d+=String.fromCharCode(55296|e>>10,56320|e&1023))}}else d+=String.fromCharCode(e)}return d},J=(a,b)=>(a>>>=0)?ab(E,a,b):\"\",bb=a=>{for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);127>=d?b++:2047>=d?b+=2:55296<=d&&57343>=d?(b+=4,++c):b+=3}return b},M=(a,b,c,d)=>{c>>>=0;if(!(0<d))return 0;var e=c;d=c+d-1;for(var f=0;f<a.length;++f){var h=a.charCodeAt(f);if(55296<=\nh&&57343>=h){var k=a.charCodeAt(++f);h=65536+((h&1023)<<10)|k&1023}if(127>=h){if(c>=d)break;b[c++>>>0]=h}else{if(2047>=h){if(c+1>=d)break;b[c++>>>0]=192|h>>6}else{if(65535>=h){if(c+2>=d)break;b[c++>>>0]=224|h>>12}else{if(c+3>=d)break;b[c++>>>0]=240|h>>18;b[c++>>>0]=128|h>>12&63}b[c++>>>0]=128|h>>6&63}b[c++>>>0]=128|h&63}}b[c>>>0]=0;return c-e},cb,N=a=>{for(var b=\"\";E[a>>>0];)b+=cb[E[a++>>>0]];return b},db={},eb={},fb={},O;\nfunction gb(a,b,c={}){var d=b.name;if(!a)throw new O(`type \"${d}\" must have a positive integer typeid pointer`);if(eb.hasOwnProperty(a)){if(c.Xh)return;throw new O(`Cannot register type '${d}' twice`);}eb[a]=b;delete fb[a];db.hasOwnProperty(a)&&(b=db[a],delete db[a],b.forEach(e=>e()))}function P(a,b,c={}){if(!(\"argPackAdvance\"in b))throw new TypeError(\"registerType registeredInstance requires argPackAdvance\");return gb(a,b,c)}\nvar hb=(a,b,c)=>{switch(b){case 1:return c?d=>z[d>>>0]:d=>E[d>>>0];case 2:return c?d=>ta[d>>>1>>>0]:d=>ua[d>>>1>>>0];case 4:return c?d=>G[d>>>2>>>0]:d=>I[d>>>2>>>0];case 8:return c?d=>wa[d>>>3]:d=>xa[d>>>3];default:throw new TypeError(`invalid integer width (${b}): ${a}`);}},ib=[],Q=[];function jb(a){a>>>=0;9<a&&0===--Q[a+1]&&(Q[a]=void 0,ib.push(a))}\nvar R=a=>{if(!a)throw new O(\"Cannot use deleted val. handle = \"+a);return Q[a]},S=a=>{switch(a){case void 0:return 2;case null:return 4;case !0:return 6;case !1:return 8;default:const b=ib.pop()||Q.length;Q[b]=a;Q[b+1]=1;return b}};function kb(a){return this.fromWireType(I[a>>>2>>>0])}\nvar lb={name:\"emscripten::val\",fromWireType:a=>{var b=R(a);jb(a);return b},toWireType:(a,b)=>S(b),argPackAdvance:8,readValueFromPointer:kb,Mh:null},mb=(a,b)=>{switch(b){case 4:return function(c){return this.fromWireType(va[c>>>2>>>0])};case 8:return function(c){return this.fromWireType(ya[c>>>3>>>0])};default:throw new TypeError(`invalid float width (${b}): ${a}`);}},nb=\"undefined\"!=typeof TextDecoder?new TextDecoder(\"utf-16le\"):void 0,ob=(a,b)=>{var c=a>>1;for(var d=c+b/2;!(c>=d)&&ua[c>>>0];)++c;\nc<<=1;if(32<c-a&&nb)return nb.decode(E.subarray(a>>>0,c>>>0));c=\"\";for(d=0;!(d>=b/2);++d){var e=ta[a+2*d>>>1>>>0];if(0==e)break;c+=String.fromCharCode(e)}return c},pb=(a,b,c)=>{c??=2147483647;if(2>c)return 0;c-=2;var d=b;c=c<2*a.length?c/2:a.length;for(var e=0;e<c;++e)ta[b>>>1>>>0]=a.charCodeAt(e),b+=2;ta[b>>>1>>>0]=0;return b-d},qb=a=>2*a.length,rb=(a,b)=>{for(var c=0,d=\"\";!(c>=b/4);){var e=G[a+4*c>>>2>>>0];if(0==e)break;++c;65536<=e?(e-=65536,d+=String.fromCharCode(55296|e>>10,56320|e&1023)):d+=\nString.fromCharCode(e)}return d},sb=(a,b,c)=>{b>>>=0;c??=2147483647;if(4>c)return 0;var d=b;c=d+c-4;for(var e=0;e<a.length;++e){var f=a.charCodeAt(e);if(55296<=f&&57343>=f){var h=a.charCodeAt(++e);f=65536+((f&1023)<<10)|h&1023}G[b>>>2>>>0]=f;b+=4;if(b+4>c)break}G[b>>>2>>>0]=0;return b-d},tb=a=>{for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);55296<=d&&57343>=d&&++c;b+=4}return b},vb=(a,b)=>{var c=eb[a];if(void 0===c)throw a=ub(a),c=N(a),T(a),new O(`${b} has unknown type ${c}`);return c},wb=\n(a,b,c)=>{var d=[];a=a.toWireType(d,c);d.length&&(I[b>>>2>>>0]=S(d));return a},xb=a=>{try{a()}catch(b){Ga(b)}},yb=a=>{if(!x)try{a();try{sa=sa=a=sa,g.onExit?.(a),x=!0,ha(a,new Pa(a))}catch(b){b instanceof Pa||\"unwind\"==b||ha(1,b)}}catch(b){b instanceof Pa||\"unwind\"==b||ha(1,b)}};\nfunction zb(){var a=U,b={};for(let [c,d]of Object.entries(a))b[c]=\"function\"==typeof d?(...e)=>{Ab.push(c);try{return d(...e)}finally{x||(Ab.pop(),t&&1===V&&0===Ab.length&&(V=0,xb(Bb),\"undefined\"!=typeof Fibers&&Fibers.mi()))}}:d;return b}var V=0,t=null,Cb=0,Ab=[],Db={},Eb={},Fb=0,Gb=null,Hb=[];function ca(){return new Promise((a,b)=>{Gb={resolve:a,reject:b}})}\nfunction Ib(){var a=Jb(65548),b=a+12;I[a>>>2>>>0]=b;I[a+4>>>2>>>0]=b+65536;b=Ab[0];var c=Db[b];void 0===c&&(c=Fb++,Db[b]=c,Eb[c]=b);G[a+8>>>2>>>0]=c;return a}\nfunction Kb(a){if(!x){if(0===V){var b=!1,c=!1;a((d=0)=>{if(!x&&(Cb=d,b=!0,c)){V=2;xb(()=>Lb(t));\"undefined\"!=typeof Browser&&Browser.Sh.Wh&&Browser.Sh.resume();d=!1;try{var e=(0,U[Eb[G[t+8>>>2>>>0]]])()}catch(k){e=k,d=!0}var f=!1;if(!t){var h=Gb;h&&(Gb=null,(d?h.reject:h.resolve)(e),f=!0)}if(d&&!f)throw e;}});c=!0;b||(V=1,t=Ib(),\"undefined\"!=typeof Browser&&Browser.Sh.Wh&&Browser.Sh.pause(),xb(()=>Mb(t)))}else 2===V?(V=0,xb(Nb),T(t),t=null,Hb.forEach(yb)):Ga(`invalid state: ${V}`);return Cb}}\nfunction Ob(a){return Kb(b=>{a().then(b)})}var Pb=[],Qb={},Rb=a=>{var b=Qb[a];return void 0===b?N(a):b},Sb=()=>\"object\"==typeof globalThis?globalThis:Function(\"return this\")(),Tb=a=>{var b=Pb.length;Pb.push(a);return b},Ub=(a,b)=>{for(var c=Array(a),d=0;d<a;++d)c[d]=vb(I[b+4*d>>>2>>>0],\"parameter \"+d);return c},Vb=(a,b)=>Object.defineProperty(b,\"name\",{value:a});\nfunction Wb(a){var b=Function;if(!(b instanceof Function))throw new TypeError(`new_ called with constructor type ${typeof b} which is not a function`);var c=Vb(b.name||\"unknownFunctionName\",function(){});c.prototype=b.prototype;c=new c;a=b.apply(c,a);return a instanceof Object?a:c}\nvar W=a=>0===a%4&&(0!==a%100||0===a%400),Xb=[0,31,60,91,121,152,182,213,244,274,305,335],Yb=[0,31,59,90,120,151,181,212,243,273,304,334],Zb=[],$b=(a,b)=>{Zb.length=0;for(var c;c=E[a++>>>0];){var d=105!=c;d&=112!=c;b+=d&&b%8?4:0;Zb.push(112==c?I[b>>>2>>>0]:106==c?wa[b>>>3]:105==c?G[b>>>2>>>0]:ya[b>>>3>>>0]);b+=d?8:4}return Zb},ac={},cc=()=>{if(!bc){var a={USER:\"web_user\",LOGNAME:\"web_user\",PATH:\"/\",PWD:\"/\",HOME:\"/home/web_user\",LANG:(\"object\"==typeof navigator&&navigator.languages&&navigator.languages[0]||\n\"C\").replace(\"-\",\"_\")+\".UTF-8\",_:fa||\"./this.program\"},b;for(b in ac)void 0===ac[b]?delete a[b]:a[b]=ac[b];var c=[];for(b in a)c.push(`${b}=${a[b]}`);bc=c}return bc},bc,dc=[null,[],[]],ec=[31,29,31,30,31,30,31,31,30,31,30,31],fc=[31,28,31,30,31,30,31,31,30,31,30,31];function gc(a){var b=Array(bb(a)+1);M(a,b,0,b.length);return b}\nfunction hc(a,b,c,d){function e(p,u,y){for(p=\"number\"==typeof p?p.toString():p||\"\";p.length<u;)p=y[0]+p;return p}function f(p,u){return e(p,u,\"0\")}function h(p,u){function y(B){return 0>B?-1:0<B?1:0}var A;0===(A=y(p.getFullYear()-u.getFullYear()))&&0===(A=y(p.getMonth()-u.getMonth()))&&(A=y(p.getDate()-u.getDate()));return A}function k(p){switch(p.getDay()){case 0:return new Date(p.getFullYear()-1,11,29);case 1:return p;case 2:return new Date(p.getFullYear(),0,3);case 3:return new Date(p.getFullYear(),\n0,2);case 4:return new Date(p.getFullYear(),0,1);case 5:return new Date(p.getFullYear()-1,11,31);case 6:return new Date(p.getFullYear()-1,11,30)}}function l(p){var u=p.Kh;for(p=new Date((new Date(p.Lh+1900,0,1)).getTime());0<u;){var y=p.getMonth(),A=(W(p.getFullYear())?ec:fc)[y];if(u>A-p.getDate())u-=A-p.getDate()+1,p.setDate(1),11>y?p.setMonth(y+1):(p.setMonth(0),p.setFullYear(p.getFullYear()+1));else{p.setDate(p.getDate()+u);break}}y=new Date(p.getFullYear()+1,0,4);u=k(new Date(p.getFullYear(),\n0,4));y=k(y);return 0>=h(u,p)?0>=h(y,p)?p.getFullYear()+1:p.getFullYear():p.getFullYear()-1}a>>>=0;b>>>=0;c>>>=0;d>>>=0;var m=I[d+40>>>2>>>0];d={ji:G[d>>>2>>>0],ii:G[d+4>>>2>>>0],Qh:G[d+8>>>2>>>0],Th:G[d+12>>>2>>>0],Rh:G[d+16>>>2>>>0],Lh:G[d+20>>>2>>>0],Jh:G[d+24>>>2>>>0],Kh:G[d+28>>>2>>>0],li:G[d+32>>>2>>>0],hi:G[d+36>>>2>>>0],ki:m?J(m):\"\"};c=J(c);m={\"%c\":\"%a %b %d %H:%M:%S %Y\",\"%D\":\"%m/%d/%y\",\"%F\":\"%Y-%m-%d\",\"%h\":\"%b\",\"%r\":\"%I:%M:%S %p\",\"%R\":\"%H:%M\",\"%T\":\"%H:%M:%S\",\"%x\":\"%m/%d/%y\",\"%X\":\"%H:%M:%S\",\n\"%Ec\":\"%c\",\"%EC\":\"%C\",\"%Ex\":\"%m/%d/%y\",\"%EX\":\"%H:%M:%S\",\"%Ey\":\"%y\",\"%EY\":\"%Y\",\"%Od\":\"%d\",\"%Oe\":\"%e\",\"%OH\":\"%H\",\"%OI\":\"%I\",\"%Om\":\"%m\",\"%OM\":\"%M\",\"%OS\":\"%S\",\"%Ou\":\"%u\",\"%OU\":\"%U\",\"%OV\":\"%V\",\"%Ow\":\"%w\",\"%OW\":\"%W\",\"%Oy\":\"%y\"};for(var n in m)c=c.replace(new RegExp(n,\"g\"),m[n]);var q=\"Sunday Monday Tuesday Wednesday Thursday Friday Saturday\".split(\" \"),r=\"January February March April May June July August September October November December\".split(\" \");m={\"%a\":p=>q[p.Jh].substring(0,3),\"%A\":p=>q[p.Jh],\"%b\":p=>\nr[p.Rh].substring(0,3),\"%B\":p=>r[p.Rh],\"%C\":p=>f((p.Lh+1900)/100|0,2),\"%d\":p=>f(p.Th,2),\"%e\":p=>e(p.Th,2,\" \"),\"%g\":p=>l(p).toString().substring(2),\"%G\":l,\"%H\":p=>f(p.Qh,2),\"%I\":p=>{p=p.Qh;0==p?p=12:12<p&&(p-=12);return f(p,2)},\"%j\":p=>{for(var u=0,y=0;y<=p.Rh-1;u+=(W(p.Lh+1900)?ec:fc)[y++]);return f(p.Th+u,3)},\"%m\":p=>f(p.Rh+1,2),\"%M\":p=>f(p.ii,2),\"%n\":()=>\"\\n\",\"%p\":p=>0<=p.Qh&&12>p.Qh?\"AM\":\"PM\",\"%S\":p=>f(p.ji,2),\"%t\":()=>\"\\t\",\"%u\":p=>p.Jh||7,\"%U\":p=>f(Math.floor((p.Kh+7-p.Jh)/7),2),\"%V\":p=>{var u=\nMath.floor((p.Kh+7-(p.Jh+6)%7)/7);2>=(p.Jh+371-p.Kh-2)%7&&u++;if(u)53==u&&(y=(p.Jh+371-p.Kh)%7,4==y||3==y&&W(p.Lh)||(u=1));else{u=52;var y=(p.Jh+7-p.Kh-1)%7;(4==y||5==y&&W(p.Lh%400-1))&&u++}return f(u,2)},\"%w\":p=>p.Jh,\"%W\":p=>f(Math.floor((p.Kh+7-(p.Jh+6)%7)/7),2),\"%y\":p=>(p.Lh+1900).toString().substring(2),\"%Y\":p=>p.Lh+1900,\"%z\":p=>{p=p.hi;var u=0<=p;p=Math.abs(p)/60;return(u?\"+\":\"-\")+String(\"0000\"+(p/60*100+p%60)).slice(-4)},\"%Z\":p=>p.ki,\"%%\":()=>\"%\"};c=c.replace(/%%/g,\"\\x00\\x00\");for(n in m)c.includes(n)&&\n(c=c.replace(new RegExp(n,\"g\"),m[n](d)));c=c.replace(/\\0\\0/g,\"%\");n=gc(c);if(n.length>b)return 0;z.set(n,a>>>0);return n.length-1}for(var ic=Array(256),jc=0;256>jc;++jc)ic[jc]=String.fromCharCode(jc);cb=ic;O=g.BindingError=class extends Error{constructor(a){super(a);this.name=\"BindingError\"}};g.InternalError=class extends Error{constructor(a){super(a);this.name=\"InternalError\"}};Q.push(0,1,void 0,1,null,1,!0,1,!1,1);g.count_emval_handles=()=>Q.length/2-5-ib.length;\nvar Cf={bd:function(a,b,c){return Ob(async()=>{await g.bi(a,b,c)})},v:function(a){a=new Sa(a>>>0);0==z[a.Ih+12>>>0]&&(z[a.Ih+12>>>0]=1,Ra--);z[a.Ih+13>>>0]=0;Qa.push(a);kc(a.Nh);if(lc(I[a.Ih+4>>>2>>>0]))a=I[a.Nh>>>2>>>0];else{var b=I[a.Ih+16>>>2>>>0];a=0!==b?b:a.Nh}return a},N:()=>{X(0,0);var a=Qa.pop();mc(a.Nh);L=0},a:function(){return Za([])},m:function(a){return Za([a>>>0])},x:function(a,b){return Za([a>>>0,b>>>0])},q:function(a,b,c){return Za([a>>>0,b>>>0,c>>>0])},Bb:()=>{var a=Qa.pop();a||Ga(\"no exception to throw\");\nvar b=a.Nh;0==z[a.Ih+13>>>0]&&(Qa.push(a),z[a.Ih+13>>>0]=1,z[a.Ih+12>>>0]=0,Ra++);L=b;throw L;},s:function(a,b,c){a>>>=0;var d=new Sa(a);I[d.Ih+16>>>2>>>0]=0;I[d.Ih+4>>>2>>>0]=b>>>0;I[d.Ih+8>>>2>>>0]=c>>>0;L=a;Ra++;throw L;},fb:()=>Ra,g:function(a){L||=a>>>0;throw L;},Cb:function(){return 0},$c:function(){},Mc:function(){},Oc:function(){},Gc:function(){return 0},Zc:function(){},Uc:function(){},Yc:function(){},_b:function(){},Nc:function(){},Kc:function(){},_c:function(){},Lc:function(){},Wb:function(a,\nb,c){b=N(b>>>0);P(a>>>0,{name:b,fromWireType:d=>d,toWireType:function(d,e){if(\"bigint\"!=typeof e&&\"number\"!=typeof e)throw null===e?e=\"null\":(d=typeof e,e=\"object\"===d||\"array\"===d||\"function\"===d?e.toString():\"\"+e),new TypeError(`Cannot convert \"${e}\" to ${this.name}`);\"number\"==typeof e&&(e=BigInt(e));return e},argPackAdvance:8,readValueFromPointer:hb(b,c>>>0,-1==b.indexOf(\"u\")),Mh:null})},Ec:function(a,b,c,d){b=N(b>>>0);P(a>>>0,{name:b,fromWireType:function(e){return!!e},toWireType:function(e,\nf){return f?c:d},argPackAdvance:8,readValueFromPointer:function(e){return this.fromWireType(E[e>>>0])},Mh:null})},Cc:function(a){return P(a>>>0,lb)},Vb:function(a,b,c){b=N(b>>>0);P(a>>>0,{name:b,fromWireType:d=>d,toWireType:(d,e)=>e,argPackAdvance:8,readValueFromPointer:mb(b,c>>>0),Mh:null})},Aa:function(a,b,c,d,e){a>>>=0;c>>>=0;b=N(b>>>0);-1===e&&(e=4294967295);e=k=>k;if(0===d){var f=32-8*c;e=k=>k<<f>>>f}var h=b.includes(\"unsigned\")?function(k,l){return l>>>0}:function(k,l){return l};P(a,{name:b,\nfromWireType:e,toWireType:h,argPackAdvance:8,readValueFromPointer:hb(b,c,0!==d),Mh:null})},_:function(a,b,c){function d(f){return new e(z.buffer,I[f+4>>>2>>>0],I[f>>>2>>>0])}var e=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,BigInt64Array,BigUint64Array][b];c=N(c>>>0);P(a>>>0,{name:c,fromWireType:d,argPackAdvance:8,readValueFromPointer:d},{Xh:!0})},Xb:function(a,b){b=N(b>>>0);var c=\"std::string\"===b;P(a>>>0,{name:b,fromWireType:function(d){var e=I[d>>>\n2>>>0],f=d+4;if(c)for(var h=f,k=0;k<=e;++k){var l=f+k;if(k==e||0==E[l>>>0]){h=J(h,l-h);if(void 0===m)var m=h;else m+=String.fromCharCode(0),m+=h;h=l+1}}else{m=Array(e);for(k=0;k<e;++k)m[k]=String.fromCharCode(E[f+k>>>0]);m=m.join(\"\")}T(d);return m},toWireType:function(d,e){e instanceof ArrayBuffer&&(e=new Uint8Array(e));var f=\"string\"==typeof e;if(!(f||e instanceof Uint8Array||e instanceof Uint8ClampedArray||e instanceof Int8Array))throw new O(\"Cannot pass non-string to std::string\");var h=c&&f?bb(e):\ne.length;var k=Jb(4+h+1),l=k+4;I[k>>>2>>>0]=h;if(c&&f)M(e,E,l,h+1);else if(f)for(f=0;f<h;++f){var m=e.charCodeAt(f);if(255<m)throw T(l),new O(\"String has UTF-16 code units that do not fit in 8 bits\");E[l+f>>>0]=m}else for(f=0;f<h;++f)E[l+f>>>0]=e[f];null!==d&&d.push(T,k);return k},argPackAdvance:8,readValueFromPointer:kb,Mh(d){T(d)}})},Ab:function(a,b,c){b>>>=0;c>>>=0;c=N(c);if(2===b){var d=ob;var e=pb;var f=qb;var h=k=>ua[k>>>1>>>0]}else 4===b&&(d=rb,e=sb,f=tb,h=k=>I[k>>>2>>>0]);P(a>>>0,{name:c,\nfromWireType:k=>{for(var l=I[k>>>2>>>0],m,n=k+4,q=0;q<=l;++q){var r=k+4+q*b;if(q==l||0==h(r))n=d(n,r-n),void 0===m?m=n:(m+=String.fromCharCode(0),m+=n),n=r+b}T(k);return m},toWireType:(k,l)=>{if(\"string\"!=typeof l)throw new O(`Cannot pass non-string to C++ string type ${c}`);var m=f(l),n=Jb(4+m+b);I[n>>>2>>>0]=m/b;e(l,n+4,m+b);null!==k&&k.push(T,n);return n},argPackAdvance:8,readValueFromPointer:kb,Mh(k){T(k)}})},Fc:function(a,b){b=N(b>>>0);P(a>>>0,{Yh:!0,name:b,argPackAdvance:0,fromWireType:()=>\n{},toWireType:()=>{}})},ad:()=>1,kd:function(a,b,c){b>>>=0;c>>>=0;a=R(a>>>0);b=vb(b,\"emval::as\");return wb(b,c,a)},Cd:function(a){a>>>=0;return Ob(()=>{a=R(a);return a.then(S)})},ud:function(a,b,c,d){c>>>=0;d>>>=0;a=Pb[a>>>0];b=R(b>>>0);return a(null,b,c,d)},ia:function(a,b,c,d,e){c>>>=0;d>>>=0;e>>>=0;a=Pb[a>>>0];b=R(b>>>0);c=Rb(c);return a(b,b[c],d,e)},Bc:jb,qd:function(a,b){b>>>=0;a=R(a>>>0);b=R(b);return a==b},zd:function(a){a>>>=0;if(0===a)return S(Sb());a=Rb(a);return S(Sb()[a])},ha:function(a,\nb,c){b=Ub(a,b>>>0);var d=b.shift();a--;var e=\"return function (obj, func, destructorsRef, args) {\\n\",f=0,h=[];0===c&&h.push(\"obj\");for(var k=[\"retType\"],l=[d],m=0;m<a;++m)h.push(\"arg\"+m),k.push(\"argType\"+m),l.push(b[m]),e+=`  var arg${m} = argType${m}.readValueFromPointer(args${f?\"+\"+f:\"\"});\\n`,f+=b[m].argPackAdvance;e+=`  var rv = ${1===c?\"new func\":\"func.call\"}(${h.join(\", \")});\\n`;d.Yh||(k.push(\"emval_returnValue\"),l.push(wb),e+=\"  return emval_returnValue(retType, destructorsRef, rv);\\n\");k.push(e+\n\"};\\n\");a=Wb(k)(...l);c=`methodCaller<(${b.map(n=>n.name).join(\", \")}) => ${d.name}>`;return Tb(Vb(c,a))},yd:function(a,b){b>>>=0;a=R(a>>>0);b=R(b);return S(a[b])},ba:function(a){a>>>=0;9<a&&(Q[a+1]+=1)},md:function(){return S([])},hd:function(a){a=R(a>>>0);for(var b=Array(a.length),c=0;c<a.length;c++)b[c]=a[c];return S(b)},U:function(a){return S(Rb(a>>>0))},Xa:function(){return S({})},vd:function(a){a>>>=0;for(var b=R(a);b.length;){var c=b.pop();b.pop()(c)}jb(a)},sd:function(a,b,c){b>>>=0;c>>>=0;\na=R(a>>>0);b=R(b);c=R(c);a[b]=c},zb:function(a,b){b>>>=0;a=vb(a>>>0,\"_emval_take_value\");a=a.readValueFromPointer(b);return S(a)},Rc:function(a,b){a=-9007199254740992>a||9007199254740992<a?NaN:Number(a);b>>>=0;a=new Date(1E3*a);G[b>>>2>>>0]=a.getUTCSeconds();G[b+4>>>2>>>0]=a.getUTCMinutes();G[b+8>>>2>>>0]=a.getUTCHours();G[b+12>>>2>>>0]=a.getUTCDate();G[b+16>>>2>>>0]=a.getUTCMonth();G[b+20>>>2>>>0]=a.getUTCFullYear()-1900;G[b+24>>>2>>>0]=a.getUTCDay();G[b+28>>>2>>>0]=(a.getTime()-Date.UTC(a.getUTCFullYear(),\n0,1,0,0,0,0))/864E5|0},Sc:function(a,b){a=-9007199254740992>a||9007199254740992<a?NaN:Number(a);b>>>=0;a=new Date(1E3*a);G[b>>>2>>>0]=a.getSeconds();G[b+4>>>2>>>0]=a.getMinutes();G[b+8>>>2>>>0]=a.getHours();G[b+12>>>2>>>0]=a.getDate();G[b+16>>>2>>>0]=a.getMonth();G[b+20>>>2>>>0]=a.getFullYear()-1900;G[b+24>>>2>>>0]=a.getDay();G[b+28>>>2>>>0]=(W(a.getFullYear())?Xb:Yb)[a.getMonth()]+a.getDate()-1|0;G[b+36>>>2>>>0]=-(60*a.getTimezoneOffset());var c=(new Date(a.getFullYear(),6,1)).getTimezoneOffset(),\nd=(new Date(a.getFullYear(),0,1)).getTimezoneOffset();G[b+32>>>2>>>0]=(c!=d&&a.getTimezoneOffset()==Math.min(d,c))|0},Tc:function(a){a>>>=0;var b=new Date(G[a+20>>>2>>>0]+1900,G[a+16>>>2>>>0],G[a+12>>>2>>>0],G[a+8>>>2>>>0],G[a+4>>>2>>>0],G[a>>>2>>>0],0),c=G[a+32>>>2>>>0],d=b.getTimezoneOffset(),e=(new Date(b.getFullYear(),6,1)).getTimezoneOffset(),f=(new Date(b.getFullYear(),0,1)).getTimezoneOffset(),h=Math.min(f,e);0>c?G[a+32>>>2>>>0]=Number(e!=f&&h==d):0<c!=(h==d)&&(e=Math.max(f,e),b.setTime(b.getTime()+\n6E4*((0<c?h:e)-d)));G[a+24>>>2>>>0]=b.getDay();G[a+28>>>2>>>0]=(W(b.getFullYear())?Xb:Yb)[b.getMonth()]+b.getDate()-1|0;G[a>>>2>>>0]=b.getSeconds();G[a+4>>>2>>>0]=b.getMinutes();G[a+8>>>2>>>0]=b.getHours();G[a+12>>>2>>>0]=b.getDate();G[a+16>>>2>>>0]=b.getMonth();G[a+20>>>2>>>0]=b.getYear();a=b.getTime();return BigInt(isNaN(a)?-1:a/1E3)},Pc:function(){return-52},Qc:function(){},Ic:function(a,b,c,d){c>>>=0;d>>>=0;var e=(new Date).getFullYear(),f=new Date(e,0,1),h=new Date(e,6,1);e=f.getTimezoneOffset();\nvar k=h.getTimezoneOffset();I[a>>>0>>>2>>>0]=60*Math.max(e,k);G[b>>>0>>>2>>>0]=Number(e!=k);a=l=>l.toLocaleTimeString(void 0,{hour12:!1,timeZoneName:\"short\"}).split(\" \")[1];f=a(f);h=a(h);k<e?(M(f,E,c,17),M(h,E,d,17)):(M(f,E,d,17),M(h,E,c,17))},bb:()=>{Ga(\"\")},A:function(a,b,c){a>>>=0;b=$b(b>>>0,c>>>0);return Oa[a](...b)},bc:function(a,b,c){a>>>=0;b=$b(b>>>0,c>>>0);return Oa[a](...b)},$b:()=>Date.now(),Jc:function(){return 4294901760},ga:()=>performance.now(),Hc:function(a){a>>>=0;var b=E.length;if(4294901760<\na)return!1;for(var c=1;4>=c;c*=2){var d=b*(1+.2/c);d=Math.min(d,a+100663296);var e=Math;d=Math.max(a,d);a:{e=(e.min.call(e,4294901760,d+(65536-d%65536)%65536)-ra.buffer.byteLength+65535)/65536;try{ra.grow(e);za();var f=1;break a}catch(h){}f=void 0}if(f)return!0}return!1},Wc:function(a,b){a>>>=0;b>>>=0;var c=0;cc().forEach((d,e)=>{var f=b+c;e=I[a+4*e>>>2>>>0]=f;for(f=0;f<d.length;++f)z[e++>>>0]=d.charCodeAt(f);z[e>>>0]=0;c+=d.length+1});return 0},Xc:function(a,b){a>>>=0;b>>>=0;var c=cc();I[a>>>2>>>\n0]=c.length;var d=0;c.forEach(e=>d+=e.length+1);I[b>>>2>>>0]=d;return 0},Db:()=>52,Zb:function(){return 52},Vc:function(){return 70},Yb:function(a,b,c,d){b>>>=0;c>>>=0;d>>>=0;for(var e=0,f=0;f<c;f++){var h=I[b>>>2>>>0],k=I[b+4>>>2>>>0];b+=8;for(var l=0;l<k;l++){var m=E[h+l>>>0],n=dc[a];0===m||10===m?((1===a?qa:w)(ab(n,0)),n.length=0):n.push(m)}e+=k}I[d>>>2>>>0]=e;return 0},xb:nc,cd:oc,ua:pc,W:qc,$:rc,ra:sc,ta:tc,dd:uc,ob:vc,P:wc,z:xc,b:yc,Ub:zc,ya:Ac,e:Bc,kb:Cc,h:Dc,X:Ec,i:Fc,ed:Gc,j:Hc,t:Ic,r:Jc,\no:Kc,Wa:Lc,Ca:Mc,ma:Nc,Qb:Oc,db:Pc,Ib:Qc,mb:Rc,kc:Sc,xc:Tc,hc:Uc,ic:Vc,ac:Wc,oa:Xc,yb:Yc,Ba:Zc,Eb:$c,ea:ad,jc:bd,Ta:cd,F:dd,G:ed,Gb:fd,jd:gd,qa:hd,O:jd,V:kd,T:ld,y:md,Fb:nd,gc:od,D:pd,Hb:qd,id:rd,Ua:sd,wa:td,lc:ud,cc:vd,Nb:wd,aa:xd,I:yd,C:zd,_a:Ad,fc:Bd,Q:Cd,d:Dd,ab:Ed,n:Fd,Ya:Gd,va:Hd,wb:Id,f:Jd,yc:Kd,da:Ld,gb:Md,Da:Nd,lb:Od,hb:Pd,c:Qd,vc:Rd,od:Sd,k:Td,tc:Ud,l:Vd,wc:Wd,sc:Xd,rd:Yd,p:Zd,Ra:$d,tb:ae,Qa:be,Kb:ce,B:de,K:ee,S:fe,$a:ge,pc:he,ub:ie,za:je,ka:ke,xa:le,Sb:me,La:ne,jb:oe,Ga:pe,nc:qe,Ha:re,\nIa:se,fd:te,xd:ue,Z:ve,pa:we,pd:xe,wd:ye,Mb:ze,Ma:Ae,Ka:Be,Tb:Ce,rc:De,Ja:Ee,Na:Fe,pb:Ge,la:He,Ea:Ie,mc:Je,qc:Ke,Jb:Le,Fa:Me,ja:Ne,Ad:Oe,nd:Pe,R:Qe,eb:Re,Za:Se,ec:Te,ib:Ue,E:Ve,M:We,Va:Xe,ld:Ye,ca:Ze,nb:$e,na:af,dc:bf,Ac:cf,u:df,L:ef,td:ff,Pb:gf,oc:hf,Bd:jf,Ob:kf,Lb:lf,cb:mf,zc:nf,Rb:of,Oa:pf,Y:qf,uc:rf,J:sf,gd:tf,vb:uf,sa:vf,H:wf,rb:xf,Pa:yf,Sa:zf,sb:Af,qb:Bf,w:function(a){return a>>>0},Dc:hc,fa:function(a,b,c,d){return hc(a>>>0,b>>>0,c>>>0,d>>>0)}},U=function(){function a(c){U=c.exports;U=zb();\nU=Df();ra=U.Dd;za();Ba.unshift(U.Ed);Da--;0==Da&&(null!==Ea&&(clearInterval(Ea),Ea=null),Fa&&(c=Fa,Fa=null,c()));return U}var b={a:Cf};Da++;if(g.instantiateWasm)try{return g.instantiateWasm(b,a)}catch(c){w(`Module.instantiateWasm callback failed with error: ${c}`),ba(c)}Na(b,function(c){a(c.instance)}).catch(ba);return{}}(),ub=a=>(ub=U.Fd)(a);g._OrtInit=(a,b)=>(g._OrtInit=U.Gd)(a,b);g._OrtGetLastError=(a,b)=>(g._OrtGetLastError=U.Hd)(a,b);\ng._OrtCreateSessionOptions=(a,b,c,d,e,f,h,k,l,m)=>(g._OrtCreateSessionOptions=U.Id)(a,b,c,d,e,f,h,k,l,m);g._OrtAppendExecutionProvider=(a,b)=>(g._OrtAppendExecutionProvider=U.Jd)(a,b);g._OrtAddFreeDimensionOverride=(a,b,c)=>(g._OrtAddFreeDimensionOverride=U.Kd)(a,b,c);g._OrtAddSessionConfigEntry=(a,b,c)=>(g._OrtAddSessionConfigEntry=U.Ld)(a,b,c);g._OrtReleaseSessionOptions=a=>(g._OrtReleaseSessionOptions=U.Md)(a);g._OrtCreateSession=(a,b,c)=>(g._OrtCreateSession=U.Nd)(a,b,c);\ng._OrtReleaseSession=a=>(g._OrtReleaseSession=U.Od)(a);g._OrtGetInputOutputCount=(a,b,c)=>(g._OrtGetInputOutputCount=U.Pd)(a,b,c);g._OrtGetInputName=(a,b)=>(g._OrtGetInputName=U.Qd)(a,b);g._OrtGetOutputName=(a,b)=>(g._OrtGetOutputName=U.Rd)(a,b);g._OrtFree=a=>(g._OrtFree=U.Sd)(a);g._OrtCreateTensor=(a,b,c,d,e,f)=>(g._OrtCreateTensor=U.Td)(a,b,c,d,e,f);g._OrtGetTensorData=(a,b,c,d,e)=>(g._OrtGetTensorData=U.Ud)(a,b,c,d,e);g._OrtReleaseTensor=a=>(g._OrtReleaseTensor=U.Vd)(a);\ng._OrtCreateRunOptions=(a,b,c,d)=>(g._OrtCreateRunOptions=U.Wd)(a,b,c,d);g._OrtAddRunConfigEntry=(a,b,c)=>(g._OrtAddRunConfigEntry=U.Xd)(a,b,c);g._OrtReleaseRunOptions=a=>(g._OrtReleaseRunOptions=U.Yd)(a);g._OrtCreateBinding=a=>(g._OrtCreateBinding=U.Zd)(a);g._OrtBindInput=(a,b,c)=>(g._OrtBindInput=U._d)(a,b,c);g._OrtBindOutput=(a,b,c,d)=>(g._OrtBindOutput=U.$d)(a,b,c,d);g._OrtClearBoundOutputs=a=>(g._OrtClearBoundOutputs=U.ae)(a);g._OrtReleaseBinding=a=>(g._OrtReleaseBinding=U.be)(a);\ng._OrtRunWithBinding=(a,b,c,d,e)=>(g._OrtRunWithBinding=U.ce)(a,b,c,d,e);g._OrtRun=(a,b,c,d,e,f,h,k)=>(g._OrtRun=U.de)(a,b,c,d,e,f,h,k);g._OrtEndProfiling=a=>(g._OrtEndProfiling=U.ee)(a);g._JsepOutput=(a,b,c)=>(g._JsepOutput=U.fe)(a,b,c);g._JsepGetNodeName=a=>(g._JsepGetNodeName=U.ge)(a);\nvar Jb=g._malloc=a=>(Jb=g._malloc=U.he)(a),T=g._free=a=>(T=g._free=U.ie)(a),X=(a,b)=>(X=U.ke)(a,b),Ta=a=>(Ta=U.le)(a),Y=a=>(Y=U.me)(a),Ef=a=>(Ef=U.ne)(a),Z=()=>(Z=U.oe)(),mc=a=>(mc=U.pe)(a),kc=a=>(kc=U.qe)(a),Ua=(a,b,c)=>(Ua=U.re)(a,b,c),lc=a=>(lc=U.se)(a),dynCall_vii=g.dynCall_vii=(a,b,c)=>(dynCall_vii=g.dynCall_vii=U.te)(a,b,c),Ff=g.dynCall_iiii=(a,b,c,d)=>(Ff=g.dynCall_iiii=U.ue)(a,b,c,d),dynCall_iii=g.dynCall_iii=(a,b,c)=>(dynCall_iii=g.dynCall_iii=U.ve)(a,b,c),Gf=g.dynCall_ii=(a,b)=>(Gf=g.dynCall_ii=\nU.we)(a,b),Hf=g.dynCall_iiiiiii=(a,b,c,d,e,f,h)=>(Hf=g.dynCall_iiiiiii=U.xe)(a,b,c,d,e,f,h),dynCall_vi=g.dynCall_vi=(a,b)=>(dynCall_vi=g.dynCall_vi=U.ye)(a,b),dynCall_v=g.dynCall_v=a=>(dynCall_v=g.dynCall_v=U.ze)(a),If=g.dynCall_iiiiii=(a,b,c,d,e,f)=>(If=g.dynCall_iiiiii=U.Ae)(a,b,c,d,e,f),Jf=g.dynCall_iiij=(a,b,c,d)=>(Jf=g.dynCall_iiij=U.Be)(a,b,c,d),Kf=g.dynCall_iiiii=(a,b,c,d,e)=>(Kf=g.dynCall_iiiii=U.Ce)(a,b,c,d,e),Lf=g.dynCall_viii=(a,b,c,d)=>(Lf=g.dynCall_viii=U.De)(a,b,c,d),Mf=g.dynCall_viiiii=\n(a,b,c,d,e,f)=>(Mf=g.dynCall_viiiii=U.Ee)(a,b,c,d,e,f),Nf=g.dynCall_viiii=(a,b,c,d,e)=>(Nf=g.dynCall_viiii=U.Fe)(a,b,c,d,e),Of=g.dynCall_viiiiii=(a,b,c,d,e,f,h)=>(Of=g.dynCall_viiiiii=U.Ge)(a,b,c,d,e,f,h),Pf=g.dynCall_viiji=(a,b,c,d,e)=>(Pf=g.dynCall_viiji=U.He)(a,b,c,d,e),Qf=g.dynCall_viiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q)=>(Qf=g.dynCall_viiiiiiiiiii=U.Ie)(a,b,c,d,e,f,h,k,l,m,n,q),Rf=g.dynCall_viiijjjii=(a,b,c,d,e,f,h,k,l)=>(Rf=g.dynCall_viiijjjii=U.Je)(a,b,c,d,e,f,h,k,l),Sf=g.dynCall_iid=(a,b,c)=>\n(Sf=g.dynCall_iid=U.Ke)(a,b,c),Tf=g.dynCall_iif=(a,b,c)=>(Tf=g.dynCall_iif=U.Le)(a,b,c),Uf=g.dynCall_iij=(a,b,c)=>(Uf=g.dynCall_iij=U.Me)(a,b,c),Vf=g.dynCall_jii=(a,b,c)=>(Vf=g.dynCall_jii=U.Ne)(a,b,c),Wf=g.dynCall_i=a=>(Wf=g.dynCall_i=U.Oe)(a),Xf=g.dynCall_viiiiiiii=(a,b,c,d,e,f,h,k,l)=>(Xf=g.dynCall_viiiiiiii=U.Pe)(a,b,c,d,e,f,h,k,l),Yf=g.dynCall_viiiiij=(a,b,c,d,e,f,h)=>(Yf=g.dynCall_viiiiij=U.Qe)(a,b,c,d,e,f,h),Zf=g.dynCall_ji=(a,b)=>(Zf=g.dynCall_ji=U.Re)(a,b),$f=g.dynCall_viij=(a,b,c,d)=>($f=\ng.dynCall_viij=U.Se)(a,b,c,d),ag=g.dynCall_iiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q)=>(ag=g.dynCall_iiiiiiiiiiii=U.Te)(a,b,c,d,e,f,h,k,l,m,n,q),bg=g.dynCall_viiiiiiiii=(a,b,c,d,e,f,h,k,l,m)=>(bg=g.dynCall_viiiiiiiii=U.Ue)(a,b,c,d,e,f,h,k,l,m),cg=g.dynCall_ij=(a,b)=>(cg=g.dynCall_ij=U.Ve)(a,b),dg=g.dynCall_iiiiij=(a,b,c,d,e,f)=>(dg=g.dynCall_iiiiij=U.We)(a,b,c,d,e,f),eg=g.dynCall_j=a=>(eg=g.dynCall_j=U.Xe)(a),fg=g.dynCall_vij=(a,b,c)=>(fg=g.dynCall_vij=U.Ye)(a,b,c),gg=g.dynCall_viijjjiiiiii=(a,b,c,d,\ne,f,h,k,l,m,n,q)=>(gg=g.dynCall_viijjjiiiiii=U.Ze)(a,b,c,d,e,f,h,k,l,m,n,q),hg=g.dynCall_viiijiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q)=>(hg=g.dynCall_viiijiiiiiii=U._e)(a,b,c,d,e,f,h,k,l,m,n,q),ig=g.dynCall_iiiiiiii=(a,b,c,d,e,f,h,k)=>(ig=g.dynCall_iiiiiiii=U.$e)(a,b,c,d,e,f,h,k),jg=g.dynCall_viiiiiii=(a,b,c,d,e,f,h,k)=>(jg=g.dynCall_viiiiiii=U.af)(a,b,c,d,e,f,h,k),kg=g.dynCall_iiiiiiiij=(a,b,c,d,e,f,h,k,l)=>(kg=g.dynCall_iiiiiiiij=U.bf)(a,b,c,d,e,f,h,k,l),lg=g.dynCall_viiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,\nm,n,q,r,p)=>(lg=g.dynCall_viiiiiiiiiiiii=U.cf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),mg=g.dynCall_iiiiiiiii=(a,b,c,d,e,f,h,k,l)=>(mg=g.dynCall_iiiiiiiii=U.df)(a,b,c,d,e,f,h,k,l),ng=g.dynCall_iiiiijiiiii=(a,b,c,d,e,f,h,k,l,m,n)=>(ng=g.dynCall_iiiiijiiiii=U.ef)(a,b,c,d,e,f,h,k,l,m,n),og=g.dynCall_vijjjiiij=(a,b,c,d,e,f,h,k,l)=>(og=g.dynCall_vijjjiiij=U.ff)(a,b,c,d,e,f,h,k,l),pg=g.dynCall_fi=(a,b)=>(pg=g.dynCall_fi=U.gf)(a,b),qg=g.dynCall_fii=(a,b,c)=>(qg=g.dynCall_fii=U.hf)(a,b,c),rg=g.dynCall_di=(a,b)=>(rg=\ng.dynCall_di=U.jf)(a,b),sg=g.dynCall_dii=(a,b,c)=>(sg=g.dynCall_dii=U.kf)(a,b,c),tg=g.dynCall_vijj=(a,b,c,d)=>(tg=g.dynCall_vijj=U.lf)(a,b,c,d),ug=g.dynCall_iiiiiiiiii=(a,b,c,d,e,f,h,k,l,m)=>(ug=g.dynCall_iiiiiiiiii=U.mf)(a,b,c,d,e,f,h,k,l,m),vg=g.dynCall_viijiii=(a,b,c,d,e,f,h)=>(vg=g.dynCall_viijiii=U.nf)(a,b,c,d,e,f,h),wg=g.dynCall_viid=(a,b,c,d)=>(wg=g.dynCall_viid=U.of)(a,b,c,d),xg=g.dynCall_viffiii=(a,b,c,d,e,f,h)=>(xg=g.dynCall_viffiii=U.pf)(a,b,c,d,e,f,h),yg=g.dynCall_viifiii=(a,b,c,d,e,f,\nh)=>(yg=g.dynCall_viifiii=U.qf)(a,b,c,d,e,f,h),zg=g.dynCall_viiiiidiidi=(a,b,c,d,e,f,h,k,l,m,n)=>(zg=g.dynCall_viiiiidiidi=U.rf)(a,b,c,d,e,f,h,k,l,m,n),Ag=g.dynCall_viiiiiiiiidi=(a,b,c,d,e,f,h,k,l,m,n,q)=>(Ag=g.dynCall_viiiiiiiiidi=U.sf)(a,b,c,d,e,f,h,k,l,m,n,q),Bg=g.dynCall_jiii=(a,b,c,d)=>(Bg=g.dynCall_jiii=U.tf)(a,b,c,d),Cg=g.dynCall_vjiiiiii=(a,b,c,d,e,f,h,k)=>(Cg=g.dynCall_vjiiiiii=U.uf)(a,b,c,d,e,f,h,k),Dg=g.dynCall_viiid=(a,b,c,d,e)=>(Dg=g.dynCall_viiid=U.vf)(a,b,c,d,e),Eg=g.dynCall_viiiiiiiiiji=\n(a,b,c,d,e,f,h,k,l,m,n,q)=>(Eg=g.dynCall_viiiiiiiiiji=U.wf)(a,b,c,d,e,f,h,k,l,m,n,q),Fg=g.dynCall_viji=(a,b,c,d)=>(Fg=g.dynCall_viji=U.xf)(a,b,c,d),Gg=g.dynCall_vijjjjjjjjjjjjji=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>(Gg=g.dynCall_vijjjjjjjjjjjjji=U.yf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y),Hg=g.dynCall_viiiji=(a,b,c,d,e,f)=>(Hg=g.dynCall_viiiji=U.zf)(a,b,c,d,e,f),Ig=g.dynCall_vijjjiiji=(a,b,c,d,e,f,h,k,l)=>(Ig=g.dynCall_vijjjiiji=U.Af)(a,b,c,d,e,f,h,k,l),Jg=g.dynCall_iiiji=(a,b,c,d,e)=>(Jg=g.dynCall_iiiji=\nU.Bf)(a,b,c,d,e),Kg=g.dynCall_iiijiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(Kg=g.dynCall_iiijiiiiiiiiii=U.Cf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),Lg=g.dynCall_vj=(a,b)=>(Lg=g.dynCall_vj=U.Df)(a,b),Mg=g.dynCall_jjj=(a,b,c)=>(Mg=g.dynCall_jjj=U.Ef)(a,b,c),Ng=g.dynCall_iiijiiiiii=(a,b,c,d,e,f,h,k,l,m)=>(Ng=g.dynCall_iiijiiiiii=U.Ff)(a,b,c,d,e,f,h,k,l,m),Og=g.dynCall_vfiii=(a,b,c,d,e)=>(Og=g.dynCall_vfiii=U.Gf)(a,b,c,d,e),Pg=g.dynCall_viiiiff=(a,b,c,d,e,f,h)=>(Pg=g.dynCall_viiiiff=U.Hf)(a,b,c,d,e,f,h),Qg=g.dynCall_viiiiiff=\n(a,b,c,d,e,f,h,k)=>(Qg=g.dynCall_viiiiiff=U.If)(a,b,c,d,e,f,h,k),Rg=g.dynCall_viiff=(a,b,c,d,e)=>(Rg=g.dynCall_viiff=U.Jf)(a,b,c,d,e),Sg=g.dynCall_viiiiiiiiifiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(Sg=g.dynCall_viiiiiiiiifiii=U.Kf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),Tg=g.dynCall_viiiiiiiijj=(a,b,c,d,e,f,h,k,l,m,n)=>(Tg=g.dynCall_viiiiiiiijj=U.Lf)(a,b,c,d,e,f,h,k,l,m,n),Ug=g.dynCall_iiiiiiiiiiiiiifii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)=>(Ug=g.dynCall_iiiiiiiiiiiiiifii=U.Mf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A),\nVg=g.dynCall_viiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Vg=g.dynCall_viiiiiiiiiiii=U.Nf)(a,b,c,d,e,f,h,k,l,m,n,q,r),Wg=g.dynCall_iiiiiiiiiiiiiiiiifii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)=>(Wg=g.dynCall_iiiiiiiiiiiiiiiiifii=U.Of)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D),Xg=g.dynCall_vijjiiiiii=(a,b,c,d,e,f,h,k,l,m)=>(Xg=g.dynCall_vijjiiiiii=U.Pf)(a,b,c,d,e,f,h,k,l,m),Yg=g.dynCall_iiiijjj=(a,b,c,d,e,f,h)=>(Yg=g.dynCall_iiiijjj=U.Qf)(a,b,c,d,e,f,h),Zg=g.dynCall_viiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,\nn)=>(Zg=g.dynCall_viiiiiiiiii=U.Rf)(a,b,c,d,e,f,h,k,l,m,n),$g=g.dynCall_iiijjj=(a,b,c,d,e,f)=>($g=g.dynCall_iiijjj=U.Sf)(a,b,c,d,e,f),ah=g.dynCall_fffffff=(a,b,c,d,e,f,h)=>(ah=g.dynCall_fffffff=U.Tf)(a,b,c,d,e,f,h),bh=g.dynCall_viiiij=(a,b,c,d,e,f)=>(bh=g.dynCall_viiiij=U.Uf)(a,b,c,d,e,f),ch=g.dynCall_viiiiiijiifiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(ch=g.dynCall_viiiiiijiifiii=U.Vf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),dh=g.dynCall_vjjjjjjffjifiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B)=>(dh=g.dynCall_vjjjjjjffjifiiiiii=\nU.Wf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B),eh=g.dynCall_viiiiiiffjifiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)=>(eh=g.dynCall_viiiiiiffjifiiiii=U.Xf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A),fh=g.dynCall_viiiiiiffjfiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>(fh=g.dynCall_viiiiiiffjfiiiii=U.Yf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y),gh=g.dynCall_viiiiiiffjiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>(gh=g.dynCall_viiiiiiffjiiiii=U.Zf)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u),hh=g.dynCall_vjjjjjjjjfffiiifiiiii=(a,b,c,d,e,f,h,k,l,\nm,n,q,r,p,u,y,A,B,C,D,F)=>(hh=g.dynCall_vjjjjjjjjfffiiifiiiii=U._f)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F),ih=g.dynCall_vjjjjjjfffifijiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C)=>(ih=g.dynCall_vjjjjjjfffifijiiiii=U.$f)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C),jh=g.dynCall_vjjjjjjfffifiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B)=>(jh=g.dynCall_vjjjjjjfffifiiiiii=U.ag)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B),kh=g.dynCall_vjjjjjjjjfffjifiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F)=>(kh=g.dynCall_vjjjjjjjjfffjifiiiiii=\nU.bg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F),lh=g.dynCall_vijiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(lh=g.dynCall_vijiiiiiiiiii=U.cg)(a,b,c,d,e,f,h,k,l,m,n,q,r),mh=g.dynCall_vijjfffiii=(a,b,c,d,e,f,h,k,l,m)=>(mh=g.dynCall_vijjfffiii=U.dg)(a,b,c,d,e,f,h,k,l,m),nh=g.dynCall_viiiiiiijiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(nh=g.dynCall_viiiiiiijiiii=U.eg)(a,b,c,d,e,f,h,k,l,m,n,q,r),oh=g.dynCall_vijjjjjjifiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>(oh=g.dynCall_vijjjjjjifiiiii=U.fg)(a,b,c,d,e,f,h,k,l,m,n,\nq,r,p,u),ph=g.dynCall_viifi=(a,b,c,d,e)=>(ph=g.dynCall_viifi=U.gg)(a,b,c,d,e),qh=g.dynCall_vjjjjjiiii=(a,b,c,d,e,f,h,k,l,m)=>(qh=g.dynCall_vjjjjjiiii=U.hg)(a,b,c,d,e,f,h,k,l,m),rh=g.dynCall_vjjjjfiii=(a,b,c,d,e,f,h,k,l)=>(rh=g.dynCall_vjjjjfiii=U.ig)(a,b,c,d,e,f,h,k,l),sh=g.dynCall_viiiiiijiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(sh=g.dynCall_viiiiiijiiiiii=U.jg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),th=g.dynCall_vijjii=(a,b,c,d,e,f)=>(th=g.dynCall_vijjii=U.kg)(a,b,c,d,e,f),uh=g.dynCall_viiiiijjiiiii=(a,b,c,\nd,e,f,h,k,l,m,n,q,r)=>(uh=g.dynCall_viiiiijjiiiii=U.lg)(a,b,c,d,e,f,h,k,l,m,n,q,r),vh=g.dynCall_iiiiiji=(a,b,c,d,e,f,h)=>(vh=g.dynCall_iiiiiji=U.mg)(a,b,c,d,e,f,h),wh=g.dynCall_iiiiji=(a,b,c,d,e,f)=>(wh=g.dynCall_iiiiji=U.ng)(a,b,c,d,e,f),xh=g.dynCall_viiiiijiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(xh=g.dynCall_viiiiijiiiiii=U.og)(a,b,c,d,e,f,h,k,l,m,n,q,r),yh=g.dynCall_viiijiiiiii=(a,b,c,d,e,f,h,k,l,m,n)=>(yh=g.dynCall_viiijiiiiii=U.pg)(a,b,c,d,e,f,h,k,l,m,n),zh=g.dynCall_viijj=(a,b,c,d,e)=>(zh=g.dynCall_viijj=\nU.qg)(a,b,c,d,e),Ah=g.dynCall_viiiijii=(a,b,c,d,e,f,h,k)=>(Ah=g.dynCall_viiiijii=U.rg)(a,b,c,d,e,f,h,k),Bh=g.dynCall_viijjiii=(a,b,c,d,e,f,h,k)=>(Bh=g.dynCall_viijjiii=U.sg)(a,b,c,d,e,f,h,k),Ch=g.dynCall_ijii=(a,b,c,d)=>(Ch=g.dynCall_ijii=U.tg)(a,b,c,d),Dh=g.dynCall_viiiiijjji=(a,b,c,d,e,f,h,k,l,m)=>(Dh=g.dynCall_viiiiijjji=U.ug)(a,b,c,d,e,f,h,k,l,m),Eh=g.dynCall_vijjjjiij=(a,b,c,d,e,f,h,k,l)=>(Eh=g.dynCall_vijjjjiij=U.vg)(a,b,c,d,e,f,h,k,l),Fh=g.dynCall_viiiiijij=(a,b,c,d,e,f,h,k,l)=>(Fh=g.dynCall_viiiiijij=\nU.wg)(a,b,c,d,e,f,h,k,l),Gh=g.dynCall_viiiiiijij=(a,b,c,d,e,f,h,k,l,m)=>(Gh=g.dynCall_viiiiiijij=U.xg)(a,b,c,d,e,f,h,k,l,m),Hh=g.dynCall_vijiii=(a,b,c,d,e,f)=>(Hh=g.dynCall_vijiii=U.yg)(a,b,c,d,e,f),Ih=g.dynCall_viiiiiiiiifi=(a,b,c,d,e,f,h,k,l,m,n,q)=>(Ih=g.dynCall_viiiiiiiiifi=U.zg)(a,b,c,d,e,f,h,k,l,m,n,q),Jh=g.dynCall_iiijiiii=(a,b,c,d,e,f,h,k)=>(Jh=g.dynCall_iiijiiii=U.Ag)(a,b,c,d,e,f,h,k),Kh=g.dynCall_viiiiiijjiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(Kh=g.dynCall_viiiiiijjiiiii=U.Bg)(a,b,c,d,e,\nf,h,k,l,m,n,q,r,p),Lh=g.dynCall_viiiiiiijiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>(Lh=g.dynCall_viiiiiiijiiiiii=U.Cg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u),Mh=g.dynCall_vif=(a,b,c)=>(Mh=g.dynCall_vif=U.Dg)(a,b,c),Nh=g.dynCall_viif=(a,b,c,d)=>(Nh=g.dynCall_viif=U.Eg)(a,b,c,d),Oh=g.dynCall_fiii=(a,b,c,d)=>(Oh=g.dynCall_fiii=U.Fg)(a,b,c,d),Ph=g.dynCall_diii=(a,b,c,d)=>(Ph=g.dynCall_diii=U.Gg)(a,b,c,d),Qh=g.dynCall_viiiiiifii=(a,b,c,d,e,f,h,k,l,m)=>(Qh=g.dynCall_viiiiiifii=U.Hg)(a,b,c,d,e,f,h,k,l,m),Rh=g.dynCall_viiiiijiiiiiiiiiiiiiiiiiii=\n(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F,H,K,Va,Wa,Xa)=>(Rh=g.dynCall_viiiiijiiiiiiiiiiiiiiiiiii=U.Ig)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F,H,K,Va,Wa,Xa),Sh=g.dynCall_viijji=(a,b,c,d,e,f)=>(Sh=g.dynCall_viijji=U.Jg)(a,b,c,d,e,f),Th=g.dynCall_iiiiiiiiiiiji=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Th=g.dynCall_iiiiiiiiiiiji=U.Kg)(a,b,c,d,e,f,h,k,l,m,n,q,r),Uh=g.dynCall_viifiifijjjii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Uh=g.dynCall_viifiifijjjii=U.Lg)(a,b,c,d,e,f,h,k,l,m,n,q,r),Vh=g.dynCall_viiiiiiiiiiiiiiiiiiii=\n(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F)=>(Vh=g.dynCall_viiiiiiiiiiiiiiiiiiii=U.Mg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F),Wh=g.dynCall_viiiiifiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Wh=g.dynCall_viiiiifiiiiii=U.Ng)(a,b,c,d,e,f,h,k,l,m,n,q,r),Xh=g.dynCall_vijiiiiiiijjii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p)=>(Xh=g.dynCall_vijiiiiiiijjii=U.Og)(a,b,c,d,e,f,h,k,l,m,n,q,r,p),Yh=g.dynCall_viiiiiiiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C)=>(Yh=g.dynCall_viiiiiiiiiiiiiiiiii=U.Pg)(a,b,c,d,e,f,h,k,l,\nm,n,q,r,p,u,y,A,B,C),Zh=g.dynCall_viiiiiiiiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)=>(Zh=g.dynCall_viiiiiiiiiiiiiiiiiii=U.Qg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D),$h=g.dynCall_viiiiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)=>($h=g.dynCall_viiiiiiiiiiiiiii=U.Rg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y),ai=g.dynCall_viiiiiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)=>(ai=g.dynCall_viiiiiiiiiiiiiiii=U.Sg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A),bi=g.dynCall_viiiijjj=(a,b,c,d,e,f,h,k)=>(bi=\ng.dynCall_viiiijjj=U.Tg)(a,b,c,d,e,f,h,k),ci=g.dynCall_iiiiid=(a,b,c,d,e,f)=>(ci=g.dynCall_iiiiid=U.Ug)(a,b,c,d,e,f),di=g.dynCall_viiiiiiijjj=(a,b,c,d,e,f,h,k,l,m,n)=>(di=g.dynCall_viiiiiiijjj=U.Vg)(a,b,c,d,e,f,h,k,l,m,n),ei=g.dynCall_iiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n)=>(ei=g.dynCall_iiiiiiiiiii=U.Wg)(a,b,c,d,e,f,h,k,l,m,n),fi=g.dynCall_iiiiiiiiiiiiiiiiiifi=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)=>(fi=g.dynCall_iiiiiiiiiiiiiiiiiifi=U.Xg)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D),gi=g.dynCall_viiif=\n(a,b,c,d,e)=>(gi=g.dynCall_viiif=U.Yg)(a,b,c,d,e),hi=g.dynCall_viiijiiiii=(a,b,c,d,e,f,h,k,l,m)=>(hi=g.dynCall_viiijiiiii=U.Zg)(a,b,c,d,e,f,h,k,l,m),ii=g.dynCall_viiij=(a,b,c,d,e)=>(ii=g.dynCall_viiij=U._g)(a,b,c,d,e),ji=g.dynCall_iijjj=(a,b,c,d,e)=>(ji=g.dynCall_iijjj=U.$g)(a,b,c,d,e),ki=g.dynCall_viiiiji=(a,b,c,d,e,f,h)=>(ki=g.dynCall_viiiiji=U.ah)(a,b,c,d,e,f,h),li=g.dynCall_iijjji=(a,b,c,d,e,f)=>(li=g.dynCall_iijjji=U.bh)(a,b,c,d,e,f),mi=g.dynCall_ijijji=(a,b,c,d,e,f)=>(mi=g.dynCall_ijijji=U.ch)(a,\nb,c,d,e,f),ni=g.dynCall_viiijjiii=(a,b,c,d,e,f,h,k,l)=>(ni=g.dynCall_viiijjiii=U.dh)(a,b,c,d,e,f,h,k,l),oi=g.dynCall_iiiiijji=(a,b,c,d,e,f,h,k)=>(oi=g.dynCall_iiiiijji=U.eh)(a,b,c,d,e,f,h,k),pi=g.dynCall_iiiifi=(a,b,c,d,e,f)=>(pi=g.dynCall_iiiifi=U.fh)(a,b,c,d,e,f),qi=g.dynCall_iiijii=(a,b,c,d,e,f)=>(qi=g.dynCall_iiijii=U.gh)(a,b,c,d,e,f),ri=g.dynCall_iiiiiiiiijii=(a,b,c,d,e,f,h,k,l,m,n,q)=>(ri=g.dynCall_iiiiiiiiijii=U.hh)(a,b,c,d,e,f,h,k,l,m,n,q),si=g.dynCall_iiiijjii=(a,b,c,d,e,f,h,k)=>(si=g.dynCall_iiiijjii=\nU.ih)(a,b,c,d,e,f,h,k),ti=g.dynCall_iiiiiijjjii=(a,b,c,d,e,f,h,k,l,m,n)=>(ti=g.dynCall_iiiiiijjjii=U.jh)(a,b,c,d,e,f,h,k,l,m,n),ui=g.dynCall_iiijiii=(a,b,c,d,e,f,h)=>(ui=g.dynCall_iiijiii=U.kh)(a,b,c,d,e,f,h),vi=g.dynCall_iiiiiiiijjjfi=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(vi=g.dynCall_iiiiiiiijjjfi=U.lh)(a,b,c,d,e,f,h,k,l,m,n,q,r),wi=g.dynCall_iijiiii=(a,b,c,d,e,f,h)=>(wi=g.dynCall_iijiiii=U.mh)(a,b,c,d,e,f,h),xi=g.dynCall_iijjjii=(a,b,c,d,e,f,h)=>(xi=g.dynCall_iijjjii=U.nh)(a,b,c,d,e,f,h),yi=g.dynCall_jij=\n(a,b,c)=>(yi=g.dynCall_jij=U.oh)(a,b,c),zi=g.dynCall_iiji=(a,b,c,d)=>(zi=g.dynCall_iiji=U.ph)(a,b,c,d),Ai=g.dynCall_iiif=(a,b,c,d)=>(Ai=g.dynCall_iiif=U.qh)(a,b,c,d),Bi=g.dynCall_vidi=(a,b,c,d)=>(Bi=g.dynCall_vidi=U.rh)(a,b,c,d),Ci=g.dynCall_vjiii=(a,b,c,d,e)=>(Ci=g.dynCall_vjiii=U.sh)(a,b,c,d,e),Di=g.dynCall_diiii=(a,b,c,d,e)=>(Di=g.dynCall_diiii=U.th)(a,b,c,d,e),Ei=g.dynCall_diiiii=(a,b,c,d,e,f)=>(Ei=g.dynCall_diiiii=U.uh)(a,b,c,d,e,f),Fi=g.dynCall_viiijjiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q)=>(Fi=g.dynCall_viiijjiiiiii=\nU.vh)(a,b,c,d,e,f,h,k,l,m,n,q),Gi=g.dynCall_viijjijjjjiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Gi=g.dynCall_viijjijjjjiii=U.wh)(a,b,c,d,e,f,h,k,l,m,n,q,r),Hi=g.dynCall_iiiij=(a,b,c,d,e)=>(Hi=g.dynCall_iiiij=U.xh)(a,b,c,d,e),Ii=g.dynCall_viiijii=(a,b,c,d,e,f,h)=>(Ii=g.dynCall_viiijii=U.yh)(a,b,c,d,e,f,h),Ji=g.dynCall_viijiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r)=>(Ji=g.dynCall_viijiiiiiiiii=U.zh)(a,b,c,d,e,f,h,k,l,m,n,q,r),Ki=g.dynCall_fiiii=(a,b,c,d,e)=>(Ki=g.dynCall_fiiii=U.Ah)(a,b,c,d,e),Li=g.dynCall_jfi=\n(a,b,c)=>(Li=g.dynCall_jfi=U.Bh)(a,b,c),Mi=g.dynCall_viiiiiiiiiiiiii=(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)=>(Mi=g.dynCall_viiiiiiiiiiiiii=U.Ch)(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u),Ni=g.dynCall_jiij=(a,b,c,d)=>(Ni=g.dynCall_jiij=U.Dh)(a,b,c,d),Mb=a=>(Mb=U.Eh)(a),Bb=()=>(Bb=U.Fh)(),Lb=a=>(Lb=U.Gh)(a),Nb=()=>(Nb=U.Hh)();g.___start_em_js=1275044;g.___stop_em_js=1275205;function Dc(a,b,c,d){var e=Z();try{return Ff(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}\nfunction Bc(a,b,c){var d=Z();try{return dynCall_iii(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function Jd(a,b,c){var d=Z();try{dynCall_vii(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function yc(a,b){var c=Z();try{return Gf(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}function Fd(a,b){var c=Z();try{dynCall_vi(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}function dd(a,b,c,d){var e=Z();try{return Jf(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}\nfunction Dd(a){var b=Z();try{dynCall_v(a)}catch(c){Y(b);if(c!==c+0)throw c;X(1,0)}}function Ic(a,b,c,d,e,f,h){var k=Z();try{return Hf(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Hc(a,b,c,d,e,f){var h=Z();try{return If(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Fc(a,b,c,d,e){var f=Z();try{return Kf(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Qd(a,b,c,d){var e=Z();try{Lf(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}\nfunction Td(a,b,c,d,e){var f=Z();try{Nf(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Vd(a,b,c,d,e,f){var h=Z();try{Mf(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Zd(a,b,c,d,e,f,h){var k=Z();try{Of(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function ke(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{Qf(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function zc(a,b,c){var d=Z();try{return Sf(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}\nfunction Ac(a,b,c){var d=Z();try{return Tf(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function md(a,b,c){var d=Z();try{return Uf(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function yd(a,b,c){var d=Z();try{return Vf(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0);return 0n}}function ee(a,b,c,d,e,f,h,k,l){var m=Z();try{Xf(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}function xc(a){var b=Z();try{return Wf(a)}catch(c){Y(b);if(c!==c+0)throw c;X(1,0)}}\nfunction df(a,b,c){var d=Z();try{fg(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function We(a,b,c,d,e){var f=Z();try{Pf(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Ce(a,b,c,d,e,f,h){var k=Z();try{Yf(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function cf(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{gg(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}\nfunction Re(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{hg(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function Jc(a,b,c,d,e,f,h,k){var l=Z();try{return ig(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function de(a,b,c,d,e,f,h,k){var l=Z();try{jg(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function Nc(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{return ag(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}\nfunction fe(a,b,c,d,e,f,h,k,l,m){var n=Z();try{bg(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function me(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{lg(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}function Yc(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{return ng(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}function Kc(a,b,c,d,e,f,h,k,l){var m=Z();try{return mg(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}\nfunction nf(a,b,c,d,e,f,h,k,l){var m=Z();try{og(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}function Ve(a,b,c,d){var e=Z();try{$f(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function tc(a,b){var c=Z();try{return pg(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}function xd(a,b){var c=Z();try{return Zf(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0);return 0n}}function nc(a,b){var c=Z();try{return rg(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}\nfunction jf(a,b,c,d){var e=Z();try{tg(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function Oe(a,b,c,d,e,f,h){var k=Z();try{Ii(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Ze(a,b,c,d,e){var f=Z();try{zh(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Lc(a,b,c,d,e,f,h,k,l,m){var n=Z();try{return ug(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function Xe(a,b,c,d,e,f,h){var k=Z();try{vg(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}\nfunction Kd(a,b,c,d){var e=Z();try{wg(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function Tc(a,b,c,d,e,f,h,k,l){var m=Z();try{return kg(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}function Id(a,b,c,d,e,f,h){var k=Z();try{xg(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Ue(a,b,c,d,e,f,h,k,l){var m=Z();try{Rf(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}\nfunction Pd(a,b,c,d,e,f,h){var k=Z();try{yg(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Wd(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{zg(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}function zd(a,b,c,d){var e=Z();try{return Bg(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0);return 0n}}function uf(a,b,c,d,e,f,h,k){var l=Z();try{Cg(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}\nfunction Rd(a,b,c,d,e){var f=Z();try{Dg(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function ef(a,b,c,d){var e=Z();try{Fg(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function rf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y){var A=Z();try{Gg(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)}catch(B){Y(A);if(B!==B+0)throw B;X(1,0)}}function Ne(a,b,c,d,e,f){var h=Z();try{Hg(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}\nfunction of(a,b,c,d,e,f,h,k,l){var m=Z();try{Ig(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}function ed(a,b,c,d,e){var f=Z();try{return Jg(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function kd(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{return Kg(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}function sf(a,b){var c=Z();try{Lg(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}\nfunction Cd(a,b,c){var d=Z();try{return Mg(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0);return 0n}}function jd(a,b,c,d,e,f,h,k,l,m){var n=Z();try{return Ng(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function ie(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{Sg(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}function Ed(a,b,c,d,e){var f=Z();try{Og(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}\nfunction Ud(a,b,c,d,e,f,h){var k=Z();try{Pg(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Md(a,b,c,d,e){var f=Z();try{Rg(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Xd(a,b,c,d,e,f,h,k){var l=Z();try{Qg(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function ue(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{Tg(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}\nfunction Oc(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A){var B=Z();try{return Ug(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)}catch(C){Y(B);if(C!==C+0)throw C;X(1,0)}}function le(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{Vg(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function sd(a,b){var c=Z();try{return cg(a,b)}catch(d){Y(c);if(d!==d+0)throw d;X(1,0)}}function wc(a,b,c,d,e){var f=Z();try{return Ki(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}\nfunction Pc(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D){var F=Z();try{return Wg(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)}catch(H){Y(F);if(H!==H+0)throw H;X(1,0)}}function mf(a,b,c,d,e,f,h,k,l,m){var n=Z();try{Xg(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function cd(a,b,c,d,e,f,h){var k=Z();try{return Yg(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function je(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{Zg(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}\nfunction ld(a,b,c,d,e,f){var h=Z();try{return $g(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Ie(a,b,c,d,e,f){var h=Z();try{bh(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function ye(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{ch(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}function zf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B){var C=Z();try{dh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B)}catch(D){Y(C);if(D!==D+0)throw D;X(1,0)}}\nfunction ae(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A){var B=Z();try{eh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)}catch(C){Y(B);if(C!==C+0)throw C;X(1,0)}}function $d(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y){var A=Z();try{fh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)}catch(B){Y(A);if(B!==B+0)throw B;X(1,0)}}function be(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u){var y=Z();try{gh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)}catch(A){Y(y);if(A!==A+0)throw A;X(1,0)}}\nfunction Af(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F){var H=Z();try{hh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F)}catch(K){Y(H);if(K!==K+0)throw K;X(1,0)}}function yf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C){var D=Z();try{ih(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C)}catch(F){Y(D);if(F!==F+0)throw F;X(1,0)}}function xf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B){var C=Z();try{jh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B)}catch(D){Y(C);if(D!==D+0)throw D;X(1,0)}}\nfunction Bf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F){var H=Z();try{kh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F)}catch(K){Y(H);if(K!==K+0)throw K;X(1,0)}}function gf(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{lh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function kf(a,b,c,d,e,f,h,k,l,m){var n=Z();try{mh(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}\nfunction ve(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{nh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function qf(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u){var y=Z();try{oh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)}catch(A){Y(y);if(A!==A+0)throw A;X(1,0)}}function wf(a,b,c,d,e,f,h,k,l,m){var n=Z();try{qh(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function vf(a,b,c,d,e,f,h,k,l){var m=Z();try{rh(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}\nfunction sc(a,b,c,d,e,f,h){var k=Z();try{return ah(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Nd(a,b,c,d,e){var f=Z();try{ph(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function wd(a,b,c){var d=Z();try{return Li(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0);return 0n}}function ze(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{sh(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}\nfunction Ge(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{uh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function Xc(a,b,c,d,e,f,h){var k=Z();try{return vh(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function ad(a,b,c,d,e,f){var h=Z();try{return wh(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function De(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{xh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}\nfunction lf(a,b,c,d,e,f){var h=Z();try{th(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Qe(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{yh(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}function Ke(a,b,c,d,e,f,h,k){var l=Z();try{Ah(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function af(a,b,c,d,e,f,h,k){var l=Z();try{Bh(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}\nfunction td(a,b,c,d){var e=Z();try{return Ch(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function He(a,b,c,d,e,f,h,k,l,m){var n=Z();try{Dh(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function pf(a,b,c,d,e,f,h,k,l){var m=Z();try{Eh(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}function Fe(a,b,c,d,e,f,h,k,l){var m=Z();try{Fh(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}\nfunction Ae(a,b,c,d,e,f,h,k,l,m){var n=Z();try{Gh(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function ff(a,b,c,d,e,f){var h=Z();try{Hh(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function he(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{Ih(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function hd(a,b,c,d,e,f,h,k){var l=Z();try{return Jh(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}\nfunction ne(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u){var y=Z();try{Mi(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)}catch(A){Y(y);if(A!==A+0)throw A;X(1,0)}}function Be(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{Kh(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}function we(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u){var y=Z();try{Lh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u)}catch(A){Y(y);if(A!==A+0)throw A;X(1,0)}}function Hd(a,b,c){var d=Z();try{Mh(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}\nfunction vc(a,b,c,d){var e=Z();try{return Oh(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function pc(a,b,c,d){var e=Z();try{return Ph(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function ce(a,b,c,d,e,f,h,k,l,m){var n=Z();try{Qh(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}function Ee(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F,H,K,Va,Wa,Xa){var Qi=Z();try{Rh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F,H,K,Va,Wa,Xa)}catch(Ya){Y(Qi);if(Ya!==Ya+0)throw Ya;X(1,0)}}\nfunction $e(a,b,c,d,e,f){var h=Z();try{Sh(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Rc(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{return Th(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function Od(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{Uh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}\nfunction se(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F){var H=Z();try{Vh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D,F)}catch(K){Y(H);if(K!==K+0)throw K;X(1,0)}}function Yd(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{Wh(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function hf(a,b,c,d,e,f,h,k,l,m,n,q,r,p){var u=Z();try{Xh(a,b,c,d,e,f,h,k,l,m,n,q,r,p)}catch(y){Y(u);if(y!==y+0)throw y;X(1,0)}}\nfunction re(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D){var F=Z();try{Zh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)}catch(H){Y(F);if(H!==H+0)throw H;X(1,0)}}function pe(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A){var B=Z();try{ai(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A)}catch(C){Y(B);if(C!==C+0)throw C;X(1,0)}}function qe(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C){var D=Z();try{Yh(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C)}catch(F){Y(D);if(F!==F+0)throw F;X(1,0)}}\nfunction Le(a,b,c,d,e,f,h,k){var l=Z();try{bi(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function xe(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{di(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}function Mc(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{return ei(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}\nfunction Qc(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D){var F=Z();try{return fi(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y,A,B,C,D)}catch(H){Y(F);if(H!==H+0)throw H;X(1,0)}}function Sd(a,b,c,d,e){var f=Z();try{gi(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function ge(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{Ag(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function Pe(a,b,c,d,e,f,h,k,l,m){var n=Z();try{hi(a,b,c,d,e,f,h,k,l,m)}catch(q){Y(n);if(q!==q+0)throw q;X(1,0)}}\nfunction Me(a,b,c,d,e){var f=Z();try{ii(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Ye(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{Ji(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function pd(a,b,c,d,e){var f=Z();try{return ji(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function Ad(a,b,c,d){var e=Z();try{return Ni(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0);return 0n}}\nfunction Je(a,b,c,d,e,f,h){var k=Z();try{ki(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function qd(a,b,c,d,e,f){var h=Z();try{return li(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function ud(a,b,c,d,e,f){var h=Z();try{return mi(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Se(a,b,c,d,e,f,h,k,l){var m=Z();try{ni(a,b,c,d,e,f,h,k,l)}catch(n){Y(m);if(n!==n+0)throw n;X(1,0)}}\nfunction Ld(a,b,c,d){var e=Z();try{Nh(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function Zc(a,b,c,d,e,f,h,k){var l=Z();try{return oi(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function Ec(a,b,c,d,e,f){var h=Z();try{return pi(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function fd(a,b,c,d,e,f){var h=Z();try{return qi(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}\nfunction Sc(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{return ri(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function bd(a,b,c,d,e,f,h,k){var l=Z();try{return si(a,b,c,d,e,f,h,k)}catch(m){Y(l);if(m!==m+0)throw m;X(1,0)}}function Vc(a,b,c,d,e,f,h,k,l,m,n){var q=Z();try{return ti(a,b,c,d,e,f,h,k,l,m,n)}catch(r){Y(q);if(r!==r+0)throw r;X(1,0)}}function gd(a,b,c,d,e,f,h){var k=Z();try{return ui(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}\nfunction Uc(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{return vi(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function od(a,b,c,d,e,f,h){var k=Z();try{return wi(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function rd(a,b,c,d,e,f,h){var k=Z();try{return xi(a,b,c,d,e,f,h)}catch(l){Y(k);if(l!==l+0)throw l;X(1,0)}}function Bd(a,b,c){var d=Z();try{return yi(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0);return 0n}}\nfunction nd(a,b,c,d){var e=Z();try{return zi(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function Gd(a,b,c,d){var e=Z();try{Bi(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function Cc(a,b,c,d){var e=Z();try{return Ai(a,b,c,d)}catch(f){Y(e);if(f!==f+0)throw f;X(1,0)}}function tf(a,b,c,d,e){var f=Z();try{Ci(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function qc(a,b,c,d,e){var f=Z();try{return Di(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}\nfunction rc(a,b,c,d,e,f){var h=Z();try{return Ei(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Te(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{Fi(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}function bf(a,b,c,d,e,f,h,k,l,m,n,q,r){var p=Z();try{Gi(a,b,c,d,e,f,h,k,l,m,n,q,r)}catch(u){Y(p);if(u!==u+0)throw u;X(1,0)}}function te(a,b,c,d,e,f,h,k,l,m,n,q){var r=Z();try{Eg(a,b,c,d,e,f,h,k,l,m,n,q)}catch(p){Y(r);if(p!==p+0)throw p;X(1,0)}}\nfunction $c(a,b,c,d,e){var f=Z();try{return Hi(a,b,c,d,e)}catch(h){Y(f);if(h!==h+0)throw h;X(1,0)}}function vd(a){var b=Z();try{return eg(a)}catch(c){Y(b);if(c!==c+0)throw c;X(1,0);return 0n}}function Wc(a,b,c,d,e,f){var h=Z();try{return dg(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}function Gc(a,b,c,d,e,f){var h=Z();try{return ci(a,b,c,d,e,f)}catch(k){Y(h);if(k!==k+0)throw k;X(1,0)}}\nfunction oe(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y){var A=Z();try{$h(a,b,c,d,e,f,h,k,l,m,n,q,r,p,u,y)}catch(B){Y(A);if(B!==B+0)throw B;X(1,0)}}function uc(a,b,c){var d=Z();try{return qg(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function oc(a,b,c){var d=Z();try{return sg(a,b,c)}catch(e){Y(d);if(e!==e+0)throw e;X(1,0)}}function Df(){var a=U;a=Object.assign({},a);var b=c=>d=>c(d)>>>0;a.Fd=b(a.Fd);a.he=b(a.he);a.ne=b(a.ne);a.oe=(c=>()=>c()>>>0)(a.oe);return a}g.stackSave=()=>Z();g.stackRestore=a=>Y(a);\ng.stackAlloc=a=>Ef(a);g.UTF8ToString=J;g.stringToUTF8=(a,b,c)=>M(a,E,b,c);g.lengthBytesUTF8=bb;var Oi;Fa=function Pi(){Oi||Ri();Oi||(Fa=Pi)};function Ri(){if(!(0<Da)){if(g.preRun)for(\"function\"==typeof g.preRun&&(g.preRun=[g.preRun]);g.preRun.length;){var a=g.preRun.shift();Aa.unshift(a)}for(;0<Aa.length;)Aa.shift()(g);if(!(0<Da||Oi||(Oi=!0,g.calledRun=!0,x))){for(;0<Ba.length;)Ba.shift()(g);for(aa(g);0<Ca.length;)Ca.shift()(g)}}}Ri();\n\n\n  return readyPromise\n}\n);\n})();\nif (typeof exports === 'object' && typeof module === 'object')\n  module.exports = ortWasm;\nelse if (typeof define === 'function' && define['amd'])\n  define([], () => ortWasm);\n", "", "", "export const cpus = undefined;", "\nvar ortWasmThreaded = (() => {\n  var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;\n  if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename;\n  return (\nfunction(moduleArg = {}) {\n\nfunction d(){l.buffer!=p.buffer&&t();return p}function v(){l.buffer!=p.buffer&&t();return aa}function z(){l.buffer!=p.buffer&&t();return ba}function A(){l.buffer!=p.buffer&&t();return ca}function da(){l.buffer!=p.buffer&&t();return ea}var B=moduleArg,fa,C;B.ready=new Promise((a,b)=>{fa=a;C=b});\"use strict\";\nB.jsepInit=(a,b,c,e,f,h,k,q)=>{B.Qb=a;B.wb=b;B.yb=c;B.jb=e;B.xb=f;B.Ea=h;B.zb=k;B.Ab=q;b=(n,m,r)=>(...w)=>{const x=D,g=m?.();w=n(...w);const u=m?.();g!==u&&(n=u,r(g),m=r=null);return D!=x?ha():w};c=n=>async(...m)=>{try{if(B.bb)throw Error(\"Session already started\");const r=B.bb={Fb:m[0],errors:[]},w=await n(...m);if(B.bb!==r)throw Error(\"Session mismatch\");a.flush();const x=r.errors;if(0<x.length){let g=await Promise.all(x);g=g.filter(u=>u);if(0<g.length)throw Error(g.join(\"\\n\"));}return w}finally{B.bb=\nnull}};B._OrtRun=c(b(B._OrtRun,()=>B._OrtRun,n=>B._OrtRun=n));B._OrtRunWithBinding=c(b(B._OrtRunWithBinding,()=>B._OrtRunWithBinding,n=>B._OrtRunWithBinding=n));B._OrtBindInput=b(B._OrtBindInput,()=>B._OrtBindInput,n=>B._OrtBindInput=n);B.jsepRegisterBuffer=(n,m,r,w)=>a.registerBuffer(n,m,r,w);B.jsepUnregisterBuffers=n=>{a.unregisterBuffers(n)};B.jsepGetBuffer=n=>a.getBuffer(n);B.jsepCreateDownloader=(n,m,r)=>a.createDownloader(n,m,r)};\nvar ia=Object.assign({},B),ja=\"./this.program\",E=(a,b)=>{throw b;},ka=\"object\"==typeof window,F=\"function\"==typeof importScripts,G=\"object\"==typeof process&&\"object\"==typeof process.versions&&\"string\"==typeof process.versions.node,H=B.ENVIRONMENT_IS_PTHREAD||!1,I=\"\";function la(a){return B.locateFile?B.locateFile(a,I):I+a}var ma,J,na;\nif(G){var fs=require(\"fs\"),oa=require(\"path\");I=F?oa.dirname(I)+\"/\":__dirname+\"/\";ma=(b,c)=>{b=b.startsWith(\"file://\")?new URL(b):oa.normalize(b);return fs.readFileSync(b,c?void 0:\"utf8\")};na=b=>{b=ma(b,!0);b.buffer||(b=new Uint8Array(b));return b};J=(b,c,e,f=!0)=>{b=b.startsWith(\"file://\")?new URL(b):oa.normalize(b);fs.readFile(b,f?void 0:\"utf8\",(h,k)=>{h?e(h):c(f?k.buffer:k)})};!B.thisProgram&&1<process.argv.length&&(ja=process.argv[1].replace(/\\\\/g,\"/\"));process.argv.slice(2);E=(b,c)=>{process.exitCode=\nb;throw c;};B.inspect=()=>\"[Emscripten Module object]\";let a;try{a=require(\"worker_threads\")}catch(b){throw console.error('The \"worker_threads\" module is not supported in this node.js build - perhaps a newer version is needed?'),b;}global.Worker=a.Worker}else if(ka||F)F?I=self.location.href:\"undefined\"!=typeof document&&document.currentScript&&(I=document.currentScript.src),(typeof _scriptDir !== \"undefined\" && _scriptDir)&&(I=_scriptDir),0!==I.indexOf(\"blob:\")?I=I.substr(0,I.replace(/[?#].*/,\"\").lastIndexOf(\"/\")+1):I=\"\",G||(ma=a=>{var b=\nnew XMLHttpRequest;b.open(\"GET\",a,!1);b.send(null);return b.responseText},F&&(na=a=>{var b=new XMLHttpRequest;b.open(\"GET\",a,!1);b.responseType=\"arraybuffer\";b.send(null);return new Uint8Array(b.response)}),J=(a,b,c)=>{var e=new XMLHttpRequest;e.open(\"GET\",a,!0);e.responseType=\"arraybuffer\";e.onload=()=>{200==e.status||0==e.status&&e.response?b(e.response):c()};e.onerror=c;e.send(null)});G&&\"undefined\"==typeof performance&&(global.performance=require(\"perf_hooks\").performance);\nvar pa=console.log.bind(console),qa=console.error.bind(console);G&&(pa=(...a)=>fs.writeSync(1,a.join(\" \")+\"\\n\"),qa=(...a)=>fs.writeSync(2,a.join(\" \")+\"\\n\"));var ra=B.print||pa,K=B.printErr||qa;Object.assign(B,ia);ia=null;B.thisProgram&&(ja=B.thisProgram);B.quit&&(E=B.quit);var L;B.wasmBinary&&(L=B.wasmBinary);var noExitRuntime=B.noExitRuntime||!0;\"object\"!=typeof WebAssembly&&M(\"no native wasm support detected\");var l,N,sa,P=!1,Q,p,aa,ba,ca,ea;\nfunction t(){var a=l.buffer;B.HEAP8=p=new Int8Array(a);B.HEAP16=new Int16Array(a);B.HEAP32=ba=new Int32Array(a);B.HEAPU8=aa=new Uint8Array(a);B.HEAPU16=new Uint16Array(a);B.HEAPU32=ca=new Uint32Array(a);B.HEAPF32=new Float32Array(a);B.HEAPF64=ea=new Float64Array(a)}var ta=B.INITIAL_MEMORY||16777216;5242880<=ta||M(\"INITIAL_MEMORY should be larger than STACK_SIZE, was \"+ta+\"! (STACK_SIZE=5242880)\");\nif(H)l=B.wasmMemory;else if(B.wasmMemory)l=B.wasmMemory;else if(l=new WebAssembly.Memory({initial:ta/65536,maximum:65536,shared:!0}),!(l.buffer instanceof SharedArrayBuffer))throw K(\"requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag\"),G&&K(\"(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and/or recent version)\"),\nError(\"bad memory\");t();ta=l.buffer.byteLength;var ua=[],va=[],wa=[],xa=0;function ya(){return noExitRuntime||0<xa}var R=0,za=null,S=null;function Aa(){R++;B.monitorRunDependencies&&B.monitorRunDependencies(R)}function Ba(){R--;B.monitorRunDependencies&&B.monitorRunDependencies(R);if(0==R&&(null!==za&&(clearInterval(za),za=null),S)){var a=S;S=null;a()}}\nfunction M(a){if(B.onAbort)B.onAbort(a);a=\"Aborted(\"+a+\")\";K(a);P=!0;Q=1;a=new WebAssembly.RuntimeError(a+\". Build with -sASSERTIONS for more info.\");C(a);throw a;}function Ca(a){return a.startsWith(\"data:application/octet-stream;base64,\")}var T;T=\"ort-wasm-simd-threaded.wasm\";Ca(T)||(T=la(T));function Da(a){if(a==T&&L)return new Uint8Array(L);if(na)return na(a);throw\"both async and sync fetching of the wasm failed\";}\nfunction Ea(a){if(!L&&(ka||F)){if(\"function\"==typeof fetch&&!a.startsWith(\"file://\"))return fetch(a,{credentials:\"same-origin\"}).then(b=>{if(!b.ok)throw\"failed to load wasm binary file at '\"+a+\"'\";return b.arrayBuffer()}).catch(()=>Da(a));if(J)return new Promise((b,c)=>{J(a,e=>b(new Uint8Array(e)),c)})}return Promise.resolve().then(()=>Da(a))}function Fa(a,b,c){return Ea(a).then(e=>WebAssembly.instantiate(e,b)).then(e=>e).then(c,e=>{K(\"failed to asynchronously prepare wasm: \"+e);M(e)})}\nfunction Ga(a,b){var c=T;return L||\"function\"!=typeof WebAssembly.instantiateStreaming||Ca(c)||c.startsWith(\"file://\")||G||\"function\"!=typeof fetch?Fa(c,a,b):fetch(c,{credentials:\"same-origin\"}).then(e=>WebAssembly.instantiateStreaming(e,a).then(b,function(f){K(\"wasm streaming compile failed: \"+f);K(\"falling back to ArrayBuffer instantiation\");return Fa(c,a,b)}))}\nvar U,Ha={906828:a=>{B.Ea(\"Abs\",a,void 0)},906879:a=>{B.Ea(\"Neg\",a,void 0)},906930:a=>{B.Ea(\"Floor\",a,void 0)},906983:a=>{B.Ea(\"Ceil\",a,void 0)},907035:a=>{B.Ea(\"Reciprocal\",a,void 0)},907093:a=>{B.Ea(\"Sqrt\",a,void 0)},907145:a=>{B.Ea(\"Exp\",a,void 0)},907196:a=>{B.Ea(\"Erf\",a,void 0)},907247:a=>{B.Ea(\"Sigmoid\",a,void 0)},907302:a=>{B.Ea(\"Log\",a,void 0)},907353:a=>{B.Ea(\"Sin\",a,void 0)},907404:a=>{B.Ea(\"Cos\",a,void 0)},907455:a=>{B.Ea(\"Tan\",a,void 0)},907506:a=>{B.Ea(\"Asin\",a,void 0)},907558:a=>{B.Ea(\"Acos\",\na,void 0)},907610:a=>{B.Ea(\"Atan\",a,void 0)},907662:a=>{B.Ea(\"Sinh\",a,void 0)},907714:a=>{B.Ea(\"Cosh\",a,void 0)},907766:a=>{B.Ea(\"Asinh\",a,void 0)},907819:a=>{B.Ea(\"Acosh\",a,void 0)},907872:a=>{B.Ea(\"Atanh\",a,void 0)},907925:a=>{B.Ea(\"Tanh\",a,void 0)},907977:a=>{B.Ea(\"Not\",a,void 0)},908028:(a,b,c)=>{B.Ea(\"ClipV10\",a,{min:b,max:c})},908100:a=>{B.Ea(\"Clip\",a,void 0)},908152:(a,b)=>{B.Ea(\"Elu\",a,{alpha:b})},908210:a=>{B.Ea(\"Relu\",a,void 0)},908262:(a,b)=>{B.Ea(\"LeakyRelu\",a,{alpha:b})},908326:(a,b)=>\n{B.Ea(\"ThresholdedRelu\",a,{alpha:b})},908396:(a,b)=>{B.Ea(\"Cast\",a,{to:b})},908454:a=>{B.Ea(\"Add\",a,void 0)},908505:a=>{B.Ea(\"Sub\",a,void 0)},908556:a=>{B.Ea(\"Mul\",a,void 0)},908607:a=>{B.Ea(\"Div\",a,void 0)},908658:a=>{B.Ea(\"Pow\",a,void 0)},908709:a=>{B.Ea(\"Equal\",a,void 0)},908762:a=>{B.Ea(\"Greater\",a,void 0)},908817:a=>{B.Ea(\"GreaterOrEqual\",a,void 0)},908879:a=>{B.Ea(\"Less\",a,void 0)},908931:a=>{B.Ea(\"LessOrEqual\",a,void 0)},908990:(a,b,c,e,f)=>{B.Ea(\"ReduceMean\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,\naxes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909154:(a,b,c,e,f)=>{B.Ea(\"ReduceMax\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909317:(a,b,c,e,f)=>{B.Ea(\"ReduceMin\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909480:(a,b,c,e,f)=>{B.Ea(\"ReduceProd\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909644:(a,b,c,e,f)=>{B.Ea(\"ReduceSum\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,\naxes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909807:(a,b,c,e,f)=>{B.Ea(\"ReduceL1\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},909969:(a,b,c,e,f)=>{B.Ea(\"ReduceL2\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},910131:(a,b,c,e,f)=>{B.Ea(\"ReduceLogSum\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},910297:(a,b,c,e,f)=>{B.Ea(\"ReduceSumSquare\",a,{keepDims:!!b,\nnoopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},910466:(a,b,c,e,f)=>{B.Ea(\"ReduceLogSumExp\",a,{keepDims:!!b,noopWithEmptyAxes:!!c,axes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},910635:a=>{B.Ea(\"Where\",a,void 0)},910688:(a,b,c)=>{B.Ea(\"Transpose\",a,{perm:b?Array.from(z().subarray(c>>>0,c+b>>>0)):[]})},910801:(a,b,c,e,f,h,k,q,n,m)=>{B.Ea(\"Conv\",a,{format:n?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c],group:e,kernel_shape:[f],pads:[h,k],strides:[q],w_is_const:()=>!!d()[m>>>\n0]})},911029:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u)=>{B.Ea(\"Conv\",a,{format:g?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c,e],group:f,kernel_shape:[h,k],pads:[q,n,m,r],strides:[w,x],w_is_const:()=>!!d()[u>>>0]})},911288:(a,b,c,e,f,h,k,q,n,m)=>{B.Ea(\"Conv\",a,{format:n?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c],group:e,kernel_shape:[f],pads:[h,k],strides:[q],w_is_const:()=>!!d()[m>>>0]})},911516:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u)=>{B.Ea(\"Conv\",a,{format:g?\"NHWC\":\"NCHW\",auto_pad:b,dilations:[c,e],group:f,kernel_shape:[h,\nk],pads:[q,n,m,r],strides:[w,x],w_is_const:()=>!!d()[u>>>0]})},911775:(a,b,c,e,f,h,k,q,n,m,r,w,x,g)=>{B.Ea(\"ConvTranspose\",a,{format:n?\"NHWC\":\"NCHW\",autoPad:b,dilations:[c],group:e,kernel_shape:[f],pads:[h,k],strides:[q],wIsConst:()=>!!d()[m>>>0],outputPadding:r?Array.from(z().subarray(w>>>0,w+r>>>0)):[],outputShape:x?Array.from(z().subarray(g>>>0,g+x>>>0)):[]})},912155:(a,b,c,e,f,h,k,q,n,m,r,w,x)=>{B.Ea(\"ConvTranspose\",a,{format:q?\"NHWC\":\"NCHW\",autoPad:b,dilations:Array.from(z().subarray(c>>>0,c+\n2>>>0)),group:e,kernelShape:Array.from(z().subarray(f>>>0,f+2>>>0)),pads:Array.from(z().subarray(h>>>0,h+4>>>0)),strides:Array.from(z().subarray(k>>>0,k+2>>>0)),wIsConst:()=>!!d()[n>>>0],outputPadding:0<m?Array.from(z().subarray(r>>>0,r+m>>>0)):[],outputShape:0<w?Array.from(z().subarray(x>>>0,x+w>>>0)):[]})},912678:(a,b,c,e,f,h,k,q,n,m,r,w,x,g)=>{B.Ea(\"ConvTranspose\",a,{format:n?\"NHWC\":\"NCHW\",autoPad:b,dilations:[c],group:e,kernel_shape:[f],pads:[h,k],strides:[q],wIsConst:()=>!!d()[m>>>0],outputPadding:r?\nArray.from(z().subarray(w>>>0,w+r>>>0)):[],outputShape:x?Array.from(z().subarray(g>>>0,g+x>>>0)):[]})},913058:(a,b,c,e,f,h,k,q,n,m,r,w,x)=>{B.Ea(\"ConvTranspose\",a,{format:q?\"NHWC\":\"NCHW\",autoPad:b,dilations:Array.from(z().subarray(c>>>0,c+2>>>0)),group:e,kernelShape:Array.from(z().subarray(f>>>0,f+2>>>0)),pads:Array.from(z().subarray(h>>>0,h+4>>>0)),strides:Array.from(z().subarray(k>>>0,k+2>>>0)),wIsConst:()=>!!d()[n>>>0],outputPadding:0<m?Array.from(z().subarray(r>>>0,r+m>>>0)):[],outputShape:0<\nw?Array.from(z().subarray(x>>>0,x+w>>>0)):[]})},913581:(a,b)=>{B.Ea(\"GlobalAveragePool\",a,{format:b?\"NHWC\":\"NCHW\"})},913672:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u,y)=>{B.Ea(\"AveragePool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:e,storage_order:f,dilations:[h,k],kernel_shape:[q,n],pads:[m,r,w,x],strides:[g,u]})},913956:(a,b)=>{B.Ea(\"GlobalAveragePool\",a,{format:b?\"NHWC\":\"NCHW\"})},914047:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u,y)=>{B.Ea(\"AveragePool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,\ncount_include_pad:e,storage_order:f,dilations:[h,k],kernel_shape:[q,n],pads:[m,r,w,x],strides:[g,u]})},914331:(a,b)=>{B.Ea(\"GlobalMaxPool\",a,{format:b?\"NHWC\":\"NCHW\"})},914418:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u,y)=>{B.Ea(\"MaxPool\",a,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:e,storage_order:f,dilations:[h,k],kernel_shape:[q,n],pads:[m,r,w,x],strides:[g,u]})},914698:(a,b)=>{B.Ea(\"GlobalMaxPool\",a,{format:b?\"NHWC\":\"NCHW\"})},914785:(a,b,c,e,f,h,k,q,n,m,r,w,x,g,u,y)=>{B.Ea(\"MaxPool\",\na,{format:y?\"NHWC\":\"NCHW\",auto_pad:b,ceil_mode:c,count_include_pad:e,storage_order:f,dilations:[h,k],kernel_shape:[q,n],pads:[m,r,w,x],strides:[g,u]})},915065:(a,b,c,e,f)=>{B.Ea(\"Gemm\",a,{alpha:b,beta:c,transA:e,transB:f})},915169:a=>{B.Ea(\"MatMul\",a,void 0)},915223:(a,b,c,e)=>{B.Ea(\"ArgMax\",a,{keepDims:!!b,selectLastIndex:!!c,axis:e})},915331:(a,b,c,e)=>{B.Ea(\"ArgMin\",a,{keepDims:!!b,selectLastIndex:!!c,axis:e})},915439:(a,b)=>{B.Ea(\"Softmax\",a,{axis:b})},915502:(a,b)=>{B.Ea(\"Concat\",a,{axis:b})},\n915562:(a,b,c,e,f)=>{B.Ea(\"Split\",a,{axis:b,numOutputs:c,splitSizes:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},915707:a=>{B.Ea(\"Expand\",a,void 0)},915761:(a,b)=>{B.Ea(\"Gather\",a,{axis:Number(b)})},915832:(a,b)=>{B.Ea(\"GatherElements\",a,{axis:Number(b)})},915911:(a,b,c,e,f,h,k,q,n,m,r)=>{B.Ea(\"Resize\",a,{antialias:b,axes:c?Array.from(z().subarray(e>>>0,e+c>>>0)):[],coordinateTransformMode:V(f),cubicCoeffA:h,excludeOutside:k,extrapolationValue:q,keepAspectRatioPolicy:V(n),mode:V(m),nearestMode:V(r)})},\n916262:(a,b,c,e,f,h,k)=>{B.Ea(\"Slice\",a,{starts:b?Array.from(z().subarray(c>>>0,c+b>>>0)):[],ends:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[],axes:h?Array.from(z().subarray(k>>>0,k+h>>>0)):[]})},916493:a=>{B.Ea(\"Tile\",a,void 0)},916545:(a,b,c)=>{B.Ea(\"LayerNormalization\",a,{axis:Number(b),epsilon:Number(c)})},916652:(a,b,c)=>{B.Ea(\"InstanceNormalization\",a,{epsilon:b,format:c?\"NHWC\":\"NCHW\"})},916766:(a,b,c)=>{B.Ea(\"InstanceNormalization\",a,{epsilon:b,format:c?\"NHWC\":\"NCHW\"})},916880:a=>{B.Ea(\"Range\",\na,void 0)},916933:(a,b)=>{B.Ea(\"Einsum\",a,{equation:V(b)})},917014:(a,b,c,e,f)=>{B.Ea(\"Pad\",a,{mode:b,value:c,pads:e?Array.from(z().subarray(f>>>0,f+e>>>0)):[]})},917146:a=>{B.Ea(\"Gelu\",a,void 0)},917198:a=>{B.Ea(\"BiasAdd\",a,void 0)},917253:a=>{B.Ea(\"BiasSplitGelu\",a,void 0)},917314:(a,b)=>{B.Ea(\"SkipLayerNormalization\",a,{epsilon:b})},917395:a=>{B.zb(a)},917429:(a,b)=>B.Ab(a,b,B.bb.Fb,B.bb.errors),917541:a=>B.wb(a),917574:a=>B.yb(a),917606:(a,b,c)=>{B.jb(a,b,c,!0)},917645:(a,b,c)=>{B.jb(a,b,c)}};\nfunction Ia(a){this.name=\"ExitStatus\";this.message=`Program terminated with exit(${a})`;this.status=a}function Ja(a){a.terminate();a.onmessage=()=>{}}function Ka(a){(a=W.Qa[a])||M();W.Eb(a)}function La(a){var b=W.tb();if(!b)return 6;W.Ya.push(b);W.Qa[a.Xa]=b;b.Xa=a.Xa;var c={cmd:\"run\",start_routine:a.Gb,arg:a.rb,pthread_ptr:a.Xa};G&&b.unref();b.postMessage(c,a.Mb);return 0}\nvar Ma=\"undefined\"!=typeof TextDecoder?new TextDecoder(\"utf8\"):void 0,Na=(a,b,c)=>{b>>>=0;var e=b+c;for(c=b;a[c]&&!(c>=e);)++c;if(16<c-b&&a.buffer&&Ma)return Ma.decode(a.buffer instanceof SharedArrayBuffer?a.slice(b,c):a.subarray(b,c));for(e=\"\";b<c;){var f=a[b++];if(f&128){var h=a[b++]&63;if(192==(f&224))e+=String.fromCharCode((f&31)<<6|h);else{var k=a[b++]&63;f=224==(f&240)?(f&15)<<12|h<<6|k:(f&7)<<18|h<<12|k<<6|a[b++]&63;65536>f?e+=String.fromCharCode(f):(f-=65536,e+=String.fromCharCode(55296|f>>\n10,56320|f&1023))}}else e+=String.fromCharCode(f)}return e},V=(a,b)=>(a>>>=0)?Na(v(),a,b):\"\";function Oa(a){if(H)return X(1,1,a);Q=a;if(!ya()){W.Hb();if(B.onExit)B.onExit(a);P=!0}E(a,new Ia(a))}\nvar Qa=a=>{Q=a;if(H)throw Pa(a),\"unwind\";Oa(a)},W={ab:[],Ya:[],mb:[],Qa:{},gb:function(){H?W.vb():W.ub()},ub:function(){ua.unshift(()=>{Aa();W.Bb(()=>Ba())})},vb:function(){W.receiveObjectTransfer=W.Db;W.threadInitTLS=W.lb;W.setExitStatus=W.kb;noExitRuntime=!1},kb:function(a){Q=a},Sb:[\"$terminateWorker\"],Hb:function(){for(var a of W.Ya)Ja(a);for(a of W.ab)Ja(a);W.ab=[];W.Ya=[];W.Qa=[]},Eb:function(a){var b=a.Xa;delete W.Qa[b];W.ab.push(a);W.Ya.splice(W.Ya.indexOf(a),1);a.Xa=0;Ra(b)},Db:function(){},\nlb:function(){W.mb.forEach(a=>a())},Cb:a=>new Promise(b=>{a.onmessage=h=>{h=h.data;var k=h.cmd;if(h.targetThread&&h.targetThread!=Sa()){var q=W.Qa[h.Rb];q?q.postMessage(h,h.transferList):K('Internal error! Worker sent a message \"'+k+'\" to target pthread '+h.targetThread+\", but that thread no longer exists!\")}else if(\"checkMailbox\"===k)Ta();else if(\"spawnThread\"===k)La(h);else if(\"cleanupThread\"===k)Ka(h.thread);else if(\"killThread\"===k)h=h.thread,k=W.Qa[h],delete W.Qa[h],Ja(k),Ra(h),W.Ya.splice(W.Ya.indexOf(k),\n1),k.Xa=0;else if(\"cancelThread\"===k)W.Qa[h.thread].postMessage({cmd:\"cancel\"});else if(\"loaded\"===k)a.loaded=!0,b(a);else if(\"alert\"===k)alert(\"Thread \"+h.threadId+\": \"+h.text);else if(\"setimmediate\"===h.target)a.postMessage(h);else if(\"callHandler\"===k)B[h.handler](...h.args);else k&&K(\"worker sent an unknown command \"+k)};a.onerror=h=>{K(\"worker sent an error! \"+h.filename+\":\"+h.lineno+\": \"+h.message);throw h;};G&&(a.on(\"message\",function(h){a.onmessage({data:h})}),a.on(\"error\",function(h){a.onerror(h)}));\nvar c=[],e=[\"onExit\",\"onAbort\",\"print\",\"printErr\"],f;for(f of e)B.hasOwnProperty(f)&&c.push(f);a.postMessage({cmd:\"load\",handlers:c,urlOrBlob:B.mainScriptUrlOrBlob||_scriptDir,wasmMemory:l,wasmModule:sa})}),Bb:function(a){a()},qb:function(){var a=la(\"ort-wasm-simd-threaded.worker.js\");a=new Worker(a);W.ab.push(a)},tb:function(){0==W.ab.length&&(W.qb(),W.Cb(W.ab[0]));return W.ab.pop()}};B.PThread=W;var Ua=a=>{for(;0<a.length;)a.shift()(B)};\nB.establishStackSpace=function(){var a=Sa(),b=z()[a+52>>2>>>0];a=z()[a+56>>2>>>0];Va(b,b-a);Wa(b)};function Pa(a){if(H)return X(2,0,a);Qa(a)}B.invokeEntryPoint=function(a,b){a=Xa.apply(null,[a,b]);ya()?W.kb(a):Ya(a)};function Za(a){this.fb=a-24;this.pb=function(b){A()[this.fb+4>>2>>>0]=b};this.ob=function(b){A()[this.fb+8>>2>>>0]=b};this.gb=function(b,c){this.nb();this.pb(b);this.ob(c)};this.nb=function(){A()[this.fb+16>>2>>>0]=0}}var $a=0,ab=0;\nfunction bb(a,b,c,e){return H?X(3,1,a,b,c,e):cb(a,b,c,e)}function cb(a,b,c,e){a>>>=0;b>>>=0;c>>>=0;e>>>=0;if(\"undefined\"==typeof SharedArrayBuffer)return K(\"Current environment does not support SharedArrayBuffer, pthreads are not available!\"),6;var f=[];if(H&&0===f.length)return bb(a,b,c,e);a={Gb:c,Xa:a,rb:e,Mb:f};return H?(a.Ob=\"spawnThread\",postMessage(a,f),0):La(a)}function db(a,b,c){return H?X(4,1,a,b,c):0}function eb(a,b){if(H)return X(5,1,a,b)}\nvar fb=a=>{for(var b=0,c=0;c<a.length;++c){var e=a.charCodeAt(c);127>=e?b++:2047>=e?b+=2:55296<=e&&57343>=e?(b+=4,++c):b+=3}return b},gb=(a,b,c,e)=>{c>>>=0;if(!(0<e))return 0;var f=c;e=c+e-1;for(var h=0;h<a.length;++h){var k=a.charCodeAt(h);if(55296<=k&&57343>=k){var q=a.charCodeAt(++h);k=65536+((k&1023)<<10)|q&1023}if(127>=k){if(c>=e)break;b[c++>>>0]=k}else{if(2047>=k){if(c+1>=e)break;b[c++>>>0]=192|k>>6}else{if(65535>=k){if(c+2>=e)break;b[c++>>>0]=224|k>>12}else{if(c+3>=e)break;b[c++>>>0]=240|k>>\n18;b[c++>>>0]=128|k>>12&63}b[c++>>>0]=128|k>>6&63}b[c++>>>0]=128|k&63}}b[c>>>0]=0;return c-f},hb=(a,b,c)=>gb(a,v(),b,c);function ib(a,b){if(H)return X(6,1,a,b)}function jb(a,b,c){if(H)return X(7,1,a,b,c)}function kb(a,b,c){return H?X(8,1,a,b,c):0}function lb(a,b){if(H)return X(9,1,a,b)}function mb(a,b,c){if(H)return X(10,1,a,b,c)}function nb(a,b,c,e){if(H)return X(11,1,a,b,c,e)}function ob(a,b,c,e){if(H)return X(12,1,a,b,c,e)}function pb(a,b,c,e){if(H)return X(13,1,a,b,c,e)}\nfunction qb(a){if(H)return X(14,1,a)}function rb(a,b){if(H)return X(15,1,a,b)}function sb(a,b,c){if(H)return X(16,1,a,b,c)}var tb=a=>{if(!P)try{if(a(),!ya())try{H?Ya(Q):Qa(Q)}catch(b){b instanceof Ia||\"unwind\"==b||E(1,b)}}catch(b){b instanceof Ia||\"unwind\"==b||E(1,b)}};function ub(a){a>>>=0;\"function\"===typeof Atomics.Nb&&(Atomics.Nb(z(),a>>2,a).value.then(Ta),a+=128,Atomics.store(z(),a>>2,1))}B.__emscripten_thread_mailbox_await=ub;function Ta(){var a=Sa();a&&(ub(a),tb(()=>vb()))}B.checkMailbox=Ta;\nvar Y=a=>0===a%4&&(0!==a%100||0===a%400),wb=[0,31,60,91,121,152,182,213,244,274,305,335],xb=[0,31,59,90,120,151,181,212,243,273,304,334];function yb(a,b,c,e,f,h,k,q){return H?X(17,1,a,b,c,e,f,h,k,q):-52}function zb(a,b,c,e,f,h,k){if(H)return X(18,1,a,b,c,e,f,h,k)}var Bb=a=>{var b=fb(a)+1,c=Ab(b);c&&hb(a,c,b);return c},Cb=[],Db=(a,b)=>{Cb.length=0;var c;for(b>>=2;c=v()[a++>>>0];)b+=105!=c&b,Cb.push(105==c?z()[b>>>0]:da()[b++>>>1]),++b;return Cb},Fb=a=>{var b=Eb();a=a();Wa(b);return a};\nfunction X(a,b){var c=arguments.length-2,e=arguments;return Fb(()=>{for(var f=Gb(8*c),h=f>>3,k=0;k<c;k++){var q=e[2+k];da()[h+k>>>0]=q}return Hb(a,c,f,b)})}\nvar Ib=[],Jb={},Lb=()=>{if(!Kb){var a={USER:\"web_user\",LOGNAME:\"web_user\",PATH:\"/\",PWD:\"/\",HOME:\"/home/web_user\",LANG:(\"object\"==typeof navigator&&navigator.languages&&navigator.languages[0]||\"C\").replace(\"-\",\"_\")+\".UTF-8\",_:ja||\"./this.program\"},b;for(b in Jb)void 0===Jb[b]?delete a[b]:a[b]=Jb[b];var c=[];for(b in a)c.push(`${b}=${a[b]}`);Kb=c}return Kb},Kb;\nfunction Mb(a,b){if(H)return X(19,1,a,b);a>>>=0;b>>>=0;var c=0;Lb().forEach(function(e,f){var h=b+c;f=A()[a+4*f>>2>>>0]=h;for(h=0;h<e.length;++h)d()[f++>>0>>>0]=e.charCodeAt(h);d()[f>>0>>>0]=0;c+=e.length+1});return 0}function Nb(a,b){if(H)return X(20,1,a,b);a>>>=0;b>>>=0;var c=Lb();A()[a>>2>>>0]=c.length;var e=0;c.forEach(function(f){e+=f.length+1});A()[b>>2>>>0]=e;return 0}function Ob(a){return H?X(21,1,a):52}function Pb(a,b,c,e){return H?X(22,1,a,b,c,e):52}\nfunction Qb(a,b,c,e,f){return H?X(23,1,a,b,c,e,f):70}var Rb=[null,[],[]];function Tb(a,b,c,e){if(H)return X(24,1,a,b,c,e);b>>>=0;c>>>=0;e>>>=0;for(var f=0,h=0;h<c;h++){var k=A()[b>>2>>>0],q=A()[b+4>>2>>>0];b+=8;for(var n=0;n<q;n++){var m=v()[k+n>>>0],r=Rb[a];0===m||10===m?((1===a?ra:K)(Na(r,0)),r.length=0):r.push(m)}f+=q}A()[e>>2>>>0]=f;return 0}var Ub=[31,29,31,30,31,30,31,31,30,31,30,31],Vb=[31,28,31,30,31,30,31,31,30,31,30,31];function Wb(a){var b=Array(fb(a)+1);gb(a,b,0,b.length);return b}\nvar Xb=(a,b)=>{d().set(a,b>>>0)};\nfunction Yb(a,b,c,e){function f(g,u,y){for(g=\"number\"==typeof g?g.toString():g||\"\";g.length<u;)g=y[0]+g;return g}function h(g,u){return f(g,u,\"0\")}function k(g,u){function y(Sb){return 0>Sb?-1:0<Sb?1:0}var O;0===(O=y(g.getFullYear()-u.getFullYear()))&&0===(O=y(g.getMonth()-u.getMonth()))&&(O=y(g.getDate()-u.getDate()));return O}function q(g){switch(g.getDay()){case 0:return new Date(g.getFullYear()-1,11,29);case 1:return g;case 2:return new Date(g.getFullYear(),0,3);case 3:return new Date(g.getFullYear(),\n0,2);case 4:return new Date(g.getFullYear(),0,1);case 5:return new Date(g.getFullYear()-1,11,31);case 6:return new Date(g.getFullYear()-1,11,30)}}function n(g){var u=g.Za;for(g=new Date((new Date(g.$a+1900,0,1)).getTime());0<u;){var y=g.getMonth(),O=(Y(g.getFullYear())?Ub:Vb)[y];if(u>O-g.getDate())u-=O-g.getDate()+1,g.setDate(1),11>y?g.setMonth(y+1):(g.setMonth(0),g.setFullYear(g.getFullYear()+1));else{g.setDate(g.getDate()+u);break}}y=new Date(g.getFullYear()+1,0,4);u=q(new Date(g.getFullYear(),\n0,4));y=q(y);return 0>=k(u,g)?0>=k(y,g)?g.getFullYear()+1:g.getFullYear():g.getFullYear()-1}a>>>=0;b>>>=0;c>>>=0;e>>>=0;var m=z()[e+40>>2>>>0];e={Kb:z()[e>>2>>>0],Jb:z()[e+4>>2>>>0],cb:z()[e+8>>2>>>0],ib:z()[e+12>>2>>>0],eb:z()[e+16>>2>>>0],$a:z()[e+20>>2>>>0],Wa:z()[e+24>>2>>>0],Za:z()[e+28>>2>>>0],Tb:z()[e+32>>2>>>0],Ib:z()[e+36>>2>>>0],Lb:m?V(m):\"\"};c=V(c);m={\"%c\":\"%a %b %d %H:%M:%S %Y\",\"%D\":\"%m/%d/%y\",\"%F\":\"%Y-%m-%d\",\"%h\":\"%b\",\"%r\":\"%I:%M:%S %p\",\"%R\":\"%H:%M\",\"%T\":\"%H:%M:%S\",\"%x\":\"%m/%d/%y\",\"%X\":\"%H:%M:%S\",\n\"%Ec\":\"%c\",\"%EC\":\"%C\",\"%Ex\":\"%m/%d/%y\",\"%EX\":\"%H:%M:%S\",\"%Ey\":\"%y\",\"%EY\":\"%Y\",\"%Od\":\"%d\",\"%Oe\":\"%e\",\"%OH\":\"%H\",\"%OI\":\"%I\",\"%Om\":\"%m\",\"%OM\":\"%M\",\"%OS\":\"%S\",\"%Ou\":\"%u\",\"%OU\":\"%U\",\"%OV\":\"%V\",\"%Ow\":\"%w\",\"%OW\":\"%W\",\"%Oy\":\"%y\"};for(var r in m)c=c.replace(new RegExp(r,\"g\"),m[r]);var w=\"Sunday Monday Tuesday Wednesday Thursday Friday Saturday\".split(\" \"),x=\"January February March April May June July August September October November December\".split(\" \");m={\"%a\":g=>w[g.Wa].substring(0,3),\"%A\":g=>w[g.Wa],\"%b\":g=>\nx[g.eb].substring(0,3),\"%B\":g=>x[g.eb],\"%C\":g=>h((g.$a+1900)/100|0,2),\"%d\":g=>h(g.ib,2),\"%e\":g=>f(g.ib,2,\" \"),\"%g\":g=>n(g).toString().substring(2),\"%G\":g=>n(g),\"%H\":g=>h(g.cb,2),\"%I\":g=>{g=g.cb;0==g?g=12:12<g&&(g-=12);return h(g,2)},\"%j\":g=>{for(var u=0,y=0;y<=g.eb-1;u+=(Y(g.$a+1900)?Ub:Vb)[y++]);return h(g.ib+u,3)},\"%m\":g=>h(g.eb+1,2),\"%M\":g=>h(g.Jb,2),\"%n\":()=>\"\\n\",\"%p\":g=>0<=g.cb&&12>g.cb?\"AM\":\"PM\",\"%S\":g=>h(g.Kb,2),\"%t\":()=>\"\\t\",\"%u\":g=>g.Wa||7,\"%U\":g=>h(Math.floor((g.Za+7-g.Wa)/7),2),\"%V\":g=>\n{var u=Math.floor((g.Za+7-(g.Wa+6)%7)/7);2>=(g.Wa+371-g.Za-2)%7&&u++;if(u)53==u&&(y=(g.Wa+371-g.Za)%7,4==y||3==y&&Y(g.$a)||(u=1));else{u=52;var y=(g.Wa+7-g.Za-1)%7;(4==y||5==y&&Y(g.$a%400-1))&&u++}return h(u,2)},\"%w\":g=>g.Wa,\"%W\":g=>h(Math.floor((g.Za+7-(g.Wa+6)%7)/7),2),\"%y\":g=>(g.$a+1900).toString().substring(2),\"%Y\":g=>g.$a+1900,\"%z\":g=>{g=g.Ib;var u=0<=g;g=Math.abs(g)/60;return(u?\"+\":\"-\")+String(\"0000\"+(g/60*100+g%60)).slice(-4)},\"%Z\":g=>g.Lb,\"%%\":()=>\"%\"};c=c.replace(/%%/g,\"\\x00\\x00\");for(r in m)c.includes(r)&&\n(c=c.replace(new RegExp(r,\"g\"),m[r](e)));c=c.replace(/\\0\\0/g,\"%\");r=Wb(c);if(r.length>b)return 0;Xb(r,a);return r.length-1}function Zb(a){try{a()}catch(b){M(b)}}function $b(a){var b={},c;for(c in a)(function(e){var f=a[e];b[e]=\"function\"==typeof f?function(){ac.push(e);try{return f.apply(null,arguments)}finally{P||(ac.pop()===e||M(),D&&1===Z&&0===ac.length&&(Z=0,xa+=1,Zb(bc),\"undefined\"!=typeof Fibers&&Fibers.Ub()))}}:f})(c);return b}var Z=0,D=null,cc=0,ac=[],dc={},ec={},fc=0,gc=null,hc=[];\nfunction ha(){return new Promise((a,b)=>{gc={resolve:a,reject:b}})}function ic(){var a=Ab(65548),b=a+12;A()[a>>2>>>0]=b;A()[a+4>>2>>>0]=b+65536;b=ac[0];var c=dc[b];void 0===c&&(c=fc++,dc[b]=c,ec[c]=b);b=c;z()[a+8>>2>>>0]=b;return a}function jc(){var a=z()[D+8>>2>>>0];a=N[ec[a]];--xa;return a()}\nfunction kc(a){if(!P){if(0===Z){var b=!1,c=!1;a((e=0)=>{if(!P&&(cc=e,b=!0,c)){Z=2;Zb(()=>lc(D));\"undefined\"!=typeof Browser&&Browser.hb.sb&&Browser.hb.resume();e=!1;try{var f=jc()}catch(q){f=q,e=!0}var h=!1;if(!D){var k=gc;k&&(gc=null,(e?k.reject:k.resolve)(f),h=!0)}if(e&&!h)throw f;}});c=!0;b||(Z=1,D=ic(),\"undefined\"!=typeof Browser&&Browser.hb.sb&&Browser.hb.pause(),Zb(()=>mc(D)))}else 2===Z?(Z=0,Zb(nc),oc(D),D=null,hc.forEach(e=>tb(e))):M(`invalid state: ${Z}`);return cc}}\nfunction pc(a){return kc(b=>{a().then(b)})}W.gb();\nvar qc=[null,Oa,Pa,bb,db,eb,ib,jb,kb,lb,mb,nb,ob,pb,qb,rb,sb,yb,zb,Mb,Nb,Ob,Pb,Qb,Tb],tc={r:function(a,b,c){return pc(async()=>{await B.xb(a,b,c)})},b:function(a,b,c){a>>>=0;(new Za(a)).gb(b>>>0,c>>>0);$a=a;ab++;throw $a;},O:function(a){rc(a>>>0,!F,1,!ka,131072,!1);W.lb()},l:function(a){a>>>=0;H?postMessage({cmd:\"cleanupThread\",thread:a}):Ka(a)},I:cb,i:db,U:eb,E:ib,G:jb,V:kb,S:lb,K:mb,R:nb,p:ob,F:pb,C:qb,T:rb,D:sb,q:()=>!0,A:function(a,b){a>>>=0;a==b>>>0?setTimeout(()=>Ta()):H?postMessage({targetThread:a,\ncmd:\"checkMailbox\"}):(a=W.Qa[a])&&a.postMessage({cmd:\"checkMailbox\"})},M:function(){return-1},N:ub,X:function(a){G&&W.Qa[a>>>0].ref()},u:function(a,b,c){a=b+2097152>>>0<4194305-!!a?(a>>>0)+4294967296*b:NaN;c>>>=0;a=new Date(1E3*a);z()[c>>2>>>0]=a.getUTCSeconds();z()[c+4>>2>>>0]=a.getUTCMinutes();z()[c+8>>2>>>0]=a.getUTCHours();z()[c+12>>2>>>0]=a.getUTCDate();z()[c+16>>2>>>0]=a.getUTCMonth();z()[c+20>>2>>>0]=a.getUTCFullYear()-1900;z()[c+24>>2>>>0]=a.getUTCDay();a=(a.getTime()-Date.UTC(a.getUTCFullYear(),\n0,1,0,0,0,0))/864E5|0;z()[c+28>>2>>>0]=a},v:function(a,b,c){a=b+2097152>>>0<4194305-!!a?(a>>>0)+4294967296*b:NaN;c>>>=0;a=new Date(1E3*a);z()[c>>2>>>0]=a.getSeconds();z()[c+4>>2>>>0]=a.getMinutes();z()[c+8>>2>>>0]=a.getHours();z()[c+12>>2>>>0]=a.getDate();z()[c+16>>2>>>0]=a.getMonth();z()[c+20>>2>>>0]=a.getFullYear()-1900;z()[c+24>>2>>>0]=a.getDay();b=(Y(a.getFullYear())?wb:xb)[a.getMonth()]+a.getDate()-1|0;z()[c+28>>2>>>0]=b;z()[c+36>>2>>>0]=-(60*a.getTimezoneOffset());b=(new Date(a.getFullYear(),\n6,1)).getTimezoneOffset();var e=(new Date(a.getFullYear(),0,1)).getTimezoneOffset();a=(b!=e&&a.getTimezoneOffset()==Math.min(e,b))|0;z()[c+32>>2>>>0]=a},w:function(a){a>>>=0;var b=new Date(z()[a+20>>2>>>0]+1900,z()[a+16>>2>>>0],z()[a+12>>2>>>0],z()[a+8>>2>>>0],z()[a+4>>2>>>0],z()[a>>2>>>0],0),c=z()[a+32>>2>>>0],e=b.getTimezoneOffset(),f=(new Date(b.getFullYear(),6,1)).getTimezoneOffset(),h=(new Date(b.getFullYear(),0,1)).getTimezoneOffset(),k=Math.min(h,f);0>c?z()[a+32>>2>>>0]=Number(f!=h&&k==e):\n0<c!=(k==e)&&(f=Math.max(h,f),b.setTime(b.getTime()+6E4*((0<c?k:f)-e)));z()[a+24>>2>>>0]=b.getDay();c=(Y(b.getFullYear())?wb:xb)[b.getMonth()]+b.getDate()-1|0;z()[a+28>>2>>>0]=c;z()[a>>2>>>0]=b.getSeconds();z()[a+4>>2>>>0]=b.getMinutes();z()[a+8>>2>>>0]=b.getHours();z()[a+12>>2>>>0]=b.getDate();z()[a+16>>2>>>0]=b.getMonth();z()[a+20>>2>>>0]=b.getYear();a=b.getTime()/1E3;return sc((U=a,1<=+Math.abs(U)?0<U?+Math.floor(U/4294967296)>>>0:~~+Math.ceil((U-+(~~U>>>0))/4294967296)>>>0:0)),a>>>0},s:yb,t:zb,\nz:function(a,b,c){function e(m){return(m=m.toTimeString().match(/\\(([A-Za-z ]+)\\)$/))?m[1]:\"GMT\"}a>>>=0;b>>>=0;c>>>=0;var f=(new Date).getFullYear(),h=new Date(f,0,1),k=new Date(f,6,1);f=h.getTimezoneOffset();var q=k.getTimezoneOffset(),n=Math.max(f,q);A()[a>>2>>>0]=60*n;z()[b>>2>>>0]=Number(f!=q);a=e(h);b=e(k);a=Bb(a);b=Bb(b);q<f?(A()[c>>2>>>0]=a,A()[c+4>>2>>>0]=b):(A()[c>>2>>>0]=b,A()[c+4>>2>>>0]=a)},d:()=>{M(\"\")},c:function(a,b,c){a>>>=0;b=Db(b>>>0,c>>>0);return Ha[a].apply(null,b)},k:function(a,\nb,c){a>>>=0;b=Db(b>>>0,c>>>0);return Ha[a].apply(null,b)},m:function(){},j:function(){return Date.now()},W:()=>{xa+=1;throw\"unwind\";},B:function(){return 4294901760},f:()=>performance.timeOrigin+performance.now(),g:function(){return G?require(\"os\").cpus().length:navigator.hardwareConcurrency},L:function(a,b,c,e){W.Pb=b>>>0;Ib.length=c;b=e>>>0>>3;for(e=0;e<c;e++)Ib[e]=da()[b+e>>>0];return(0>a?Ha[-a-1]:qc[a]).apply(null,Ib)},y:function(a){a>>>=0;var b=v().length;if(a<=b||4294901760<a)return!1;for(var c=\n1;4>=c;c*=2){var e=b*(1+.2/c);e=Math.min(e,a+100663296);var f=Math;e=Math.max(a,e);a:{f=f.min.call(f,4294901760,e+(65536-e%65536)%65536)-l.buffer.byteLength+65535>>>16;try{l.grow(f);t();var h=1;break a}catch(k){}h=void 0}if(h)return!0}return!1},P:Mb,Q:Nb,H:Qa,h:Ob,o:Pb,x:Qb,n:Tb,a:l||B.wasmMemory,J:Yb,e:function(a,b,c,e){return Yb(a>>>0,b>>>0,c>>>0,e>>>0)}};\n(function(){function a(c,e){c=c.exports;c=$b(c);N=c=uc(c);W.mb.push(N.Da);va.unshift(N.Y);sa=e;Ba();return c}var b={a:tc};Aa();if(B.instantiateWasm)try{return B.instantiateWasm(b,a)}catch(c){K(\"Module.instantiateWasm callback failed with error: \"+c),C(c)}Ga(b,function(c){a(c.instance,c.module)}).catch(C);return{}})();B._OrtInit=(a,b)=>(B._OrtInit=N.Z)(a,b);B._OrtGetLastError=(a,b)=>(B._OrtGetLastError=N._)(a,b);\nB._OrtCreateSessionOptions=(a,b,c,e,f,h,k,q,n,m)=>(B._OrtCreateSessionOptions=N.$)(a,b,c,e,f,h,k,q,n,m);B._OrtAppendExecutionProvider=(a,b)=>(B._OrtAppendExecutionProvider=N.aa)(a,b);B._OrtAddFreeDimensionOverride=(a,b,c)=>(B._OrtAddFreeDimensionOverride=N.ba)(a,b,c);B._OrtAddSessionConfigEntry=(a,b,c)=>(B._OrtAddSessionConfigEntry=N.ca)(a,b,c);B._OrtReleaseSessionOptions=a=>(B._OrtReleaseSessionOptions=N.da)(a);B._OrtCreateSession=(a,b,c)=>(B._OrtCreateSession=N.ea)(a,b,c);\nB._OrtReleaseSession=a=>(B._OrtReleaseSession=N.fa)(a);B._OrtGetInputOutputCount=(a,b,c)=>(B._OrtGetInputOutputCount=N.ga)(a,b,c);B._OrtGetInputName=(a,b)=>(B._OrtGetInputName=N.ha)(a,b);B._OrtGetOutputName=(a,b)=>(B._OrtGetOutputName=N.ia)(a,b);B._OrtFree=a=>(B._OrtFree=N.ja)(a);B._OrtCreateTensor=(a,b,c,e,f,h)=>(B._OrtCreateTensor=N.ka)(a,b,c,e,f,h);B._OrtGetTensorData=(a,b,c,e,f)=>(B._OrtGetTensorData=N.la)(a,b,c,e,f);B._OrtReleaseTensor=a=>(B._OrtReleaseTensor=N.ma)(a);\nB._OrtCreateRunOptions=(a,b,c,e)=>(B._OrtCreateRunOptions=N.na)(a,b,c,e);B._OrtAddRunConfigEntry=(a,b,c)=>(B._OrtAddRunConfigEntry=N.oa)(a,b,c);B._OrtReleaseRunOptions=a=>(B._OrtReleaseRunOptions=N.pa)(a);B._OrtCreateBinding=a=>(B._OrtCreateBinding=N.qa)(a);B._OrtBindInput=(a,b,c)=>(B._OrtBindInput=N.ra)(a,b,c);B._OrtBindOutput=(a,b,c,e)=>(B._OrtBindOutput=N.sa)(a,b,c,e);B._OrtClearBoundOutputs=a=>(B._OrtClearBoundOutputs=N.ta)(a);B._OrtReleaseBinding=a=>(B._OrtReleaseBinding=N.ua)(a);\nB._OrtRunWithBinding=(a,b,c,e,f)=>(B._OrtRunWithBinding=N.va)(a,b,c,e,f);B._OrtRun=(a,b,c,e,f,h,k,q)=>(B._OrtRun=N.wa)(a,b,c,e,f,h,k,q);B._OrtEndProfiling=a=>(B._OrtEndProfiling=N.xa)(a);B._JsepOutput=(a,b,c)=>(B._JsepOutput=N.ya)(a,b,c);B._JsepGetNodeName=a=>(B._JsepGetNodeName=N.za)(a);var Sa=B._pthread_self=()=>(Sa=B._pthread_self=N.Aa)(),Ab=B._malloc=a=>(Ab=B._malloc=N.Ba)(a),oc=B._free=a=>(oc=B._free=N.Ca)(a);B.__emscripten_tls_init=()=>(B.__emscripten_tls_init=N.Da)();\nvar rc=B.__emscripten_thread_init=(a,b,c,e,f,h)=>(rc=B.__emscripten_thread_init=N.Fa)(a,b,c,e,f,h);B.__emscripten_thread_crashed=()=>(B.__emscripten_thread_crashed=N.Ga)();\nvar Hb=(a,b,c,e)=>(Hb=N.Ha)(a,b,c,e),Ra=a=>(Ra=N.Ia)(a),Ya=B.__emscripten_thread_exit=a=>(Ya=B.__emscripten_thread_exit=N.Ja)(a),vb=B.__emscripten_check_mailbox=()=>(vb=B.__emscripten_check_mailbox=N.Ka)(),sc=a=>(sc=N.La)(a),Va=(a,b)=>(Va=N.Ma)(a,b),Eb=()=>(Eb=N.Na)(),Wa=a=>(Wa=N.Oa)(a),Gb=a=>(Gb=N.Pa)(a),Xa=B.dynCall_ii=(a,b)=>(Xa=B.dynCall_ii=N.Ra)(a,b),mc=a=>(mc=N.Sa)(a),bc=()=>(bc=N.Ta)(),lc=a=>(lc=N.Ua)(a),nc=()=>(nc=N.Va)();B.___start_em_js=917678;B.___stop_em_js=917839;\nfunction uc(a){a=Object.assign({},a);var b=e=>()=>e()>>>0,c=e=>f=>e(f)>>>0;a.__errno_location=b(a.__errno_location);a.pthread_self=b(a.pthread_self);a.malloc=c(a.malloc);a.stackSave=b(a.stackSave);a.stackAlloc=c(a.stackAlloc);return a}B.keepRuntimeAlive=ya;B.wasmMemory=l;B.stackAlloc=Gb;B.stackSave=Eb;B.stackRestore=Wa;B.UTF8ToString=V;B.stringToUTF8=hb;B.lengthBytesUTF8=fb;B.ExitStatus=Ia;B.PThread=W;var vc;S=function wc(){vc||xc();vc||(S=wc)};\nfunction xc(){function a(){if(!vc&&(vc=!0,B.calledRun=!0,!P)){H||Ua(va);fa(B);if(B.onRuntimeInitialized)B.onRuntimeInitialized();if(!H){if(B.postRun)for(\"function\"==typeof B.postRun&&(B.postRun=[B.postRun]);B.postRun.length;){var b=B.postRun.shift();wa.unshift(b)}Ua(wa)}}}if(!(0<R))if(H)fa(B),H||Ua(va),startWorker(B);else{if(B.preRun)for(\"function\"==typeof B.preRun&&(B.preRun=[B.preRun]);B.preRun.length;)ua.unshift(B.preRun.shift());Ua(ua);0<R||(B.setStatus?(B.setStatus(\"Running...\"),setTimeout(function(){setTimeout(function(){B.setStatus(\"\")},\n1);a()},1)):a())}}if(B.preInit)for(\"function\"==typeof B.preInit&&(B.preInit=[B.preInit]);0<B.preInit.length;)B.preInit.pop()();xc();\n\n\n  return moduleArg.ready\n}\n\n);\n})();\nif (typeof exports === 'object' && typeof module === 'object')\n  module.exports = ortWasmThreaded;\nelse if (typeof define === 'function' && define['amd'])\n  define([], () => ortWasmThreaded);\n", "\"use strict\";var Module={};var ENVIRONMENT_IS_NODE=typeof process==\"object\"&&typeof process.versions==\"object\"&&typeof process.versions.node==\"string\";if(ENVIRONMENT_IS_NODE){var nodeWorkerThreads=require(\"worker_threads\");var parentPort=nodeWorkerThreads.parentPort;parentPort.on(\"message\",data=>onmessage({data:data}));var fs=require(\"fs\");Object.assign(global,{self:global,require:require,Module:Module,location:{href:__filename},Worker:nodeWorkerThreads.Worker,importScripts:f=>(0,eval)(fs.readFileSync(f,\"utf8\")+\"//# sourceURL=\"+f),postMessage:msg=>parentPort.postMessage(msg),performance:global.performance||{now:Date.now}})}var initializedJS=false;function threadPrintErr(){var text=Array.prototype.slice.call(arguments).join(\" \");if(ENVIRONMENT_IS_NODE){fs.writeSync(2,text+\"\\n\");return}console.error(text)}function threadAlert(){var text=Array.prototype.slice.call(arguments).join(\" \");postMessage({cmd:\"alert\",text:text,threadId:Module[\"_pthread_self\"]()})}var err=threadPrintErr;self.alert=threadAlert;Module[\"instantiateWasm\"]=(info,receiveInstance)=>{var module=Module[\"wasmModule\"];Module[\"wasmModule\"]=null;var instance=new WebAssembly.Instance(module,info);return receiveInstance(instance)};self.onunhandledrejection=e=>{throw e.reason??e};function handleMessage(e){try{if(e.data.cmd===\"load\"){let messageQueue=[];self.onmessage=e=>messageQueue.push(e);self.startWorker=instance=>{Module=instance;postMessage({\"cmd\":\"loaded\"});for(let msg of messageQueue){handleMessage(msg)}self.onmessage=handleMessage};Module[\"wasmModule\"]=e.data.wasmModule;for(const handler of e.data.handlers){Module[handler]=(...args)=>{postMessage({cmd:\"callHandler\",handler:handler,args:args})}}Module[\"wasmMemory\"]=e.data.wasmMemory;Module[\"buffer\"]=Module[\"wasmMemory\"].buffer;Module[\"ENVIRONMENT_IS_PTHREAD\"]=true;if(typeof e.data.urlOrBlob==\"string\"){importScripts(e.data.urlOrBlob)}else{var objectUrl=URL.createObjectURL(e.data.urlOrBlob);importScripts(objectUrl);URL.revokeObjectURL(objectUrl)}ortWasmThreaded(Module)}else if(e.data.cmd===\"run\"){Module[\"__emscripten_thread_init\"](e.data.pthread_ptr,/*isMainBrowserThread=*/0,/*isMainRuntimeThread=*/0,/*canBlock=*/1);Module[\"__emscripten_thread_mailbox_await\"](e.data.pthread_ptr);Module[\"establishStackSpace\"]();Module[\"PThread\"].receiveObjectTransfer(e.data);Module[\"PThread\"].threadInitTLS();if(!initializedJS){initializedJS=true}try{Module[\"invokeEntryPoint\"](e.data.start_routine,e.data.arg)}catch(ex){if(ex!=\"unwind\"){throw ex}}}else if(e.data.cmd===\"cancel\"){if(Module[\"_pthread_self\"]()){Module[\"__emscripten_thread_exit\"](-1)}}else if(e.data.target===\"setimmediate\"){}else if(e.data.cmd===\"checkMailbox\"){if(initializedJS){Module[\"checkMailbox\"]()}}else if(e.data.cmd){err(\"worker.js received unknown command \"+e.data.cmd);err(e.data)}}catch(ex){if(Module[\"__emscripten_thread_crashed\"]){Module[\"__emscripten_thread_crashed\"]()}throw ex}}self.onmessage=handleMessage;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Tensor} from 'onnxruntime-common';\n\n// a dummy type declaration for Float16Array in case any polyfill is available.\ndeclare global {\n  // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any\n  const Float16Array: any;\n}\n\n// This file includes common definitions. They do NOT have dependency on the WebAssembly instance.\n\n/**\n * Copied from ONNX definition. Use this to drop dependency 'onnx_proto' to decrease compiled .js file size.\n */\nexport const enum DataType {\n  undefined = 0,\n  float = 1,\n  uint8 = 2,\n  int8 = 3,\n  uint16 = 4,\n  int16 = 5,\n  int32 = 6,\n  int64 = 7,\n  string = 8,\n  bool = 9,\n  float16 = 10,\n  double = 11,\n  uint32 = 12,\n  uint64 = 13,\n  complex64 = 14,\n  complex128 = 15,\n  bfloat16 = 16\n}\n\n/**\n * Map string tensor data to enum value\n */\nexport const tensorDataTypeStringToEnum = (type: string): DataType => {\n  switch (type) {\n    case 'int8':\n      return DataType.int8;\n    case 'uint8':\n      return DataType.uint8;\n    case 'bool':\n      return DataType.bool;\n    case 'int16':\n      return DataType.int16;\n    case 'uint16':\n      return DataType.uint16;\n    case 'int32':\n      return DataType.int32;\n    case 'uint32':\n      return DataType.uint32;\n    case 'float16':\n      return DataType.float16;\n    case 'float32':\n      return DataType.float;\n    case 'float64':\n      return DataType.double;\n    case 'string':\n      return DataType.string;\n    case 'int64':\n      return DataType.int64;\n    case 'uint64':\n      return DataType.uint64;\n\n    default:\n      throw new Error(`unsupported data type: ${type}`);\n  }\n};\n\n/**\n * Map enum value to string tensor data\n */\nexport const tensorDataTypeEnumToString = (typeProto: DataType): Tensor.Type => {\n  switch (typeProto) {\n    case DataType.int8:\n      return 'int8';\n    case DataType.uint8:\n      return 'uint8';\n    case DataType.bool:\n      return 'bool';\n    case DataType.int16:\n      return 'int16';\n    case DataType.uint16:\n      return 'uint16';\n    case DataType.int32:\n      return 'int32';\n    case DataType.uint32:\n      return 'uint32';\n    case DataType.float16:\n      return 'float16';\n    case DataType.float:\n      return 'float32';\n    case DataType.double:\n      return 'float64';\n    case DataType.string:\n      return 'string';\n    case DataType.int64:\n      return 'int64';\n    case DataType.uint64:\n      return 'uint64';\n\n    default:\n      throw new Error(`unsupported data type: ${typeProto}`);\n  }\n};\n\n/**\n * get tensor element size in bytes by the given data type\n * @returns size in integer or undefined if the data type is not supported\n */\nexport const getTensorElementSize = (dateType: number): number|\n    undefined => [undefined, 4, 1, 1, 2, 2, 4, 8, undefined, 1, 2, 8, 4, 8, undefined, undefined, undefined][dateType];\n\n/**\n * get typed array constructor by the given tensor type\n */\nexport const tensorTypeToTypedArrayConstructor = (type: Tensor.Type): Float32ArrayConstructor|Uint8ArrayConstructor|\n    Int8ArrayConstructor|Uint16ArrayConstructor|Int16ArrayConstructor|Int32ArrayConstructor|BigInt64ArrayConstructor|\n    Uint8ArrayConstructor|Float64ArrayConstructor|Uint32ArrayConstructor|BigUint64ArrayConstructor => {\n      switch (type) {\n        case 'float16':\n          // allow Float16Array polyfill.\n          return typeof Float16Array !== 'undefined' && Float16Array.from ? Float16Array : Uint16Array;\n        case 'float32':\n          return Float32Array;\n        case 'uint8':\n          return Uint8Array;\n        case 'int8':\n          return Int8Array;\n        case 'uint16':\n          return Uint16Array;\n        case 'int16':\n          return Int16Array;\n        case 'int32':\n          return Int32Array;\n        case 'bool':\n          return Uint8Array;\n        case 'float64':\n          return Float64Array;\n        case 'uint32':\n          return Uint32Array;\n        case 'int64':\n          return BigInt64Array;\n        case 'uint64':\n          return BigUint64Array;\n        default:\n          throw new Error(`unsupported type: ${type}`);\n      }\n    };\n\n/**\n * Map string log level to integer value\n */\nexport const logLevelStringToEnum = (logLevel?: 'verbose'|'info'|'warning'|'error'|'fatal'): number => {\n  switch (logLevel) {\n    case 'verbose':\n      return 0;\n    case 'info':\n      return 1;\n    case 'warning':\n      return 2;\n    case 'error':\n      return 3;\n    case 'fatal':\n      return 4;\n    default:\n      throw new Error(`unsupported logging level: ${logLevel}`);\n  }\n};\n\n/**\n * Check whether the given tensor type is supported by GPU buffer\n */\nexport const isGpuBufferSupportedType = (type: Tensor.Type): type is Tensor.GpuBufferDataTypes => type === 'float32' ||\n    type === 'float16' || type === 'int32' || type === 'int64' || type === 'uint32' || type === 'uint8' ||\n    type === 'bool';\n\n/**\n * Map string data location to integer value\n */\nexport const dataLocationStringToEnum = (location: Tensor.DataLocation): number => {\n  switch (location) {\n    case 'none':\n      return 0;\n    case 'cpu':\n      return 1;\n    case 'cpu-pinned':\n      return 2;\n    case 'texture':\n      return 3;\n    case 'gpu-buffer':\n      return 4;\n    default:\n      throw new Error(`unsupported data location: ${location}`);\n  }\n};\n\n/**\n * Map integer data location to string value\n */\nexport const dataLocationEnumToString = (location: number): Tensor.DataLocation|undefined =>\n    (['none', 'cpu', 'cpu-pinned', 'texture', 'gpu-buffer'] as const)[location];\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Backend} from './backend.js';\nimport {InferenceSession} from './inference-session.js';\n\ninterface BackendInfo {\n  backend: Backend;\n  priority: number;\n\n  initPromise?: Promise<void>;\n  initialized?: boolean;\n  aborted?: boolean;\n  error?: string;\n}\n\nconst backends: Map<string, BackendInfo> = new Map();\nconst backendsSortedByPriority: string[] = [];\n\n/**\n * Register a backend.\n *\n * @param name - the name as a key to lookup as an execution provider.\n * @param backend - the backend object.\n * @param priority - an integer indicating the priority of the backend. Higher number means higher priority. if priority\n * < 0, it will be considered as a 'beta' version and will not be used as a fallback backend by default.\n *\n * @ignore\n */\nexport const registerBackend = (name: string, backend: Backend, priority: number): void => {\n  if (backend && typeof backend.init === 'function' && typeof backend.createInferenceSessionHandler === 'function') {\n    const currentBackend = backends.get(name);\n    if (currentBackend === undefined) {\n      backends.set(name, {backend, priority});\n    } else if (currentBackend.priority > priority) {\n      // same name is already registered with a higher priority. skip registeration.\n      return;\n    } else if (currentBackend.priority === priority) {\n      if (currentBackend.backend !== backend) {\n        throw new Error(`cannot register backend \"${name}\" using priority ${priority}`);\n      }\n    }\n\n    if (priority >= 0) {\n      const i = backendsSortedByPriority.indexOf(name);\n      if (i !== -1) {\n        backendsSortedByPriority.splice(i, 1);\n      }\n\n      for (let i = 0; i < backendsSortedByPriority.length; i++) {\n        if (backends.get(backendsSortedByPriority[i])!.priority <= priority) {\n          backendsSortedByPriority.splice(i, 0, name);\n          return;\n        }\n      }\n      backendsSortedByPriority.push(name);\n    }\n    return;\n  }\n\n  throw new TypeError('not a valid backend');\n};\n\n/**\n * Try to resolve and initialize a backend.\n *\n * @param backendName - the name of the backend.\n * @returns the backend instance if resolved and initialized successfully, or an error message if failed.\n */\nconst tryResolveAndInitializeBackend = async(backendName: string): Promise<Backend|string> => {\n  const backendInfo = backends.get(backendName);\n  if (!backendInfo) {\n    return 'backend not found.';\n  }\n\n  if (backendInfo.initialized) {\n    return backendInfo.backend;\n  } else if (backendInfo.aborted) {\n    return backendInfo.error!;\n  } else {\n    const isInitializing = !!backendInfo.initPromise;\n    try {\n      if (!isInitializing) {\n        backendInfo.initPromise = backendInfo.backend.init(backendName);\n      }\n      await backendInfo.initPromise;\n      backendInfo.initialized = true;\n      return backendInfo.backend;\n    } catch (e) {\n      if (!isInitializing) {\n        backendInfo.error = `${e}`;\n        backendInfo.aborted = true;\n      }\n      return backendInfo.error!;\n    } finally {\n      delete backendInfo.initPromise;\n    }\n  }\n};\n\n/**\n * Resolve execution providers from the specific session options.\n *\n * @param options - the session options object.\n * @returns a promise that resolves to a tuple of an initialized backend instance and a session options object with\n * filtered EP list.\n *\n * @ignore\n */\nexport const resolveBackendAndExecutionProviders = async(options: InferenceSession.SessionOptions):\n    Promise<[backend: Backend, options: InferenceSession.SessionOptions]> => {\n      // extract backend hints from session options\n      const eps = options.executionProviders || [];\n      const backendHints = eps.map(i => typeof i === 'string' ? i : i.name);\n      const backendNames = backendHints.length === 0 ? backendsSortedByPriority : backendHints;\n\n      // try to resolve and initialize all requested backends\n      let backend: Backend|undefined;\n      const errors = [];\n      const availableBackendNames = new Set<string>();\n      for (const backendName of backendNames) {\n        const resolveResult = await tryResolveAndInitializeBackend(backendName);\n        if (typeof resolveResult === 'string') {\n          errors.push({name: backendName, err: resolveResult});\n        } else {\n          if (!backend) {\n            backend = resolveResult;\n          }\n          if (backend === resolveResult) {\n            availableBackendNames.add(backendName);\n          }\n        }\n      }\n\n      // if no backend is available, throw error.\n      if (!backend) {\n        throw new Error(`no available backend found. ERR: ${errors.map(e => `[${e.name}] ${e.err}`).join(', ')}`);\n      }\n\n      // for each explicitly requested backend, if it's not available, output warning message.\n      for (const {name, err} of errors) {\n        if (backendHints.includes(name)) {\n          // eslint-disable-next-line no-console\n          console.warn(`removing requested execution provider \"${\n              name}\" from session options because it is not available: ${err}`);\n        }\n      }\n\n      const filteredEps = eps.filter(i => availableBackendNames.has(typeof i === 'string' ? i : i.name));\n\n      return [\n        backend, new Proxy(options, {\n          get: (target, prop) => {\n            if (prop === 'executionProviders') {\n              return filteredEps;\n            }\n            return Reflect.get(target, prop);\n          }\n        })\n      ];\n    };\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {InferenceSession} from './inference-session.js';\nimport {OnnxValue} from './onnx-value.js';\nimport {TrainingSession} from './training-session.js';\n\n/**\n * @ignore\n */\nexport declare namespace SessionHandler {\n  type FeedsType = {[name: string]: OnnxValue};\n  type FetchesType = {[name: string]: OnnxValue | null};\n  type ReturnType = {[name: string]: OnnxValue};\n}\n\n/**\n * Represents shared SessionHandler functionality\n *\n * @ignore\n */\ninterface SessionHandler {\n  dispose(): Promise<void>;\n\n  readonly inputNames: readonly string[];\n  readonly outputNames: readonly string[];\n}\n\n/**\n * Represent a handler instance of an inference session.\n *\n * @ignore\n */\nexport interface InferenceSessionHandler extends SessionHandler {\n  startProfiling(): void;\n  endProfiling(): void;\n\n  run(feeds: SessionHandler.FeedsType, fetches: SessionHandler.FetchesType,\n      options: InferenceSession.RunOptions): Promise<SessionHandler.ReturnType>;\n}\n\n/**\n * Represent a handler instance of a training inference session.\n *\n * @ignore\n */\nexport interface TrainingSessionHandler extends SessionHandler {\n  readonly evalInputNames: readonly string[];\n  readonly evalOutputNames: readonly string[];\n\n  lazyResetGrad(): Promise<void>;\n  runTrainStep(\n      feeds: SessionHandler.FeedsType, fetches: SessionHandler.FetchesType,\n      options: InferenceSession.RunOptions): Promise<SessionHandler.ReturnType>;\n  runOptimizerStep(options: InferenceSession.RunOptions): Promise<void>;\n  runEvalStep(\n      feeds: SessionHandler.FeedsType, fetches: SessionHandler.FetchesType,\n      options: InferenceSession.RunOptions): Promise<SessionHandler.ReturnType>;\n\n  getParametersSize(trainableOnly: boolean): Promise<number>;\n  loadParametersBuffer(buffer: Uint8Array, trainableOnly: boolean): Promise<void>;\n  getContiguousParameters(trainableOnly: boolean): Promise<OnnxValue>;\n}\n\n/**\n * Represent a backend that provides implementation of model inferencing.\n *\n * @ignore\n */\nexport interface Backend {\n  /**\n   * Initialize the backend asynchronously. Should throw when failed.\n   */\n  init(backendName: string): Promise<void>;\n\n  createInferenceSessionHandler(uriOrBuffer: string|Uint8Array, options?: InferenceSession.SessionOptions):\n      Promise<InferenceSessionHandler>;\n\n  createTrainingSessionHandler?\n      (checkpointStateUriOrBuffer: TrainingSession.UriOrBuffer, trainModelUriOrBuffer: TrainingSession.UriOrBuffer,\n       evalModelUriOrBuffer: TrainingSession.UriOrBuffer, optimizerModelUriOrBuffer: TrainingSession.UriOrBuffer,\n       options: InferenceSession.SessionOptions): Promise<TrainingSessionHandler>;\n}\n\nexport {registerBackend} from './backend-impl.js';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// This file is generated by /js/scripts/update-version.ts\n// Do not modify file content manually.\n\nexport const version = '1.18.0';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Env} from './env.js';\nimport {version} from './version.js';\n\ntype LogLevelType = Env['logLevel'];\n\nlet logLevelValue: Required<LogLevelType> = 'warning';\n\nexport const env: Env = {\n  wasm: {} as Env.WebAssemblyFlags,\n  webgl: {} as Env.WebGLFlags,\n  webgpu: {} as Env.WebGpuFlags,\n  versions: {common: version},\n\n  set logLevel(value: LogLevelType) {\n    if (value === undefined) {\n      return;\n    }\n    if (typeof value !== 'string' || ['verbose', 'info', 'warning', 'error', 'fatal'].indexOf(value) === -1) {\n      throw new Error(`Unsupported logging level: ${value}`);\n    }\n    logLevelValue = value;\n  },\n  get logLevel(): Required<LogLevelType> {\n    return logLevelValue;\n  },\n};\n\n// set property 'logLevel' so that they can be correctly transferred to worker by `postMessage()`.\nObject.defineProperty(env, 'logLevel', {enumerable: true});\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {env as envImpl} from './env-impl.js';\n\nexport declare namespace Env {\n  export type WasmPrefixOrFilePaths = string|{\n    /* eslint-disable @typescript-eslint/naming-convention */\n    'ort-wasm.wasm'?: string;\n    'ort-wasm-threaded.wasm'?: string;\n    'ort-wasm-simd.wasm'?: string;\n    'ort-training-wasm-simd.wasm'?: string;\n    'ort-wasm-simd-threaded.wasm'?: string;\n    /* eslint-enable @typescript-eslint/naming-convention */\n  };\n  export interface WebAssemblyFlags {\n    /**\n     * set or get number of thread(s). If omitted or set to 0, number of thread(s) will be determined by system. If set\n     * to 1, no worker thread will be spawned.\n     *\n     * This setting is available only when WebAssembly multithread feature is available in current context.\n     *\n     * @defaultValue `0`\n     */\n    numThreads?: number;\n\n    /**\n     * set or get a boolean value indicating whether to enable SIMD. If set to false, SIMD will be forcely disabled.\n     *\n     * This setting is available only when WebAssembly SIMD feature is available in current context.\n     *\n     * @defaultValue `true`\n     */\n    simd?: boolean;\n\n    /**\n     * set or get a boolean value indicating whether to enable trace.\n     *\n     * @deprecated Use `env.trace` instead. If `env.trace` is set, this property will be ignored.\n     * @defaultValue `false`\n     */\n    trace?: boolean;\n\n    /**\n     * Set or get a number specifying the timeout for initialization of WebAssembly backend, in milliseconds. A zero\n     * value indicates no timeout is set.\n     *\n     * @defaultValue `0`\n     */\n    initTimeout?: number;\n\n    /**\n     * Set a custom URL prefix to the .wasm files or a set of overrides for each .wasm file. The override path should be\n     * an absolute path.\n     */\n    wasmPaths?: WasmPrefixOrFilePaths;\n\n    /**\n     * Set or get a boolean value indicating whether to proxy the execution of main thread to a worker thread.\n     *\n     * @defaultValue `false`\n     */\n    proxy?: boolean;\n  }\n\n  export interface WebGLFlags {\n    /**\n     * Set or get the WebGL Context ID (webgl or webgl2).\n     *\n     * @defaultValue `'webgl2'`\n     */\n    contextId?: 'webgl'|'webgl2';\n    /**\n     * Get the WebGL rendering context.\n     */\n    readonly context: WebGLRenderingContext;\n    /**\n     * Set or get the maximum batch size for matmul. 0 means to disable batching.\n     *\n     * @deprecated\n     */\n    matmulMaxBatchSize?: number;\n    /**\n     * Set or get the texture cache mode.\n     *\n     * @defaultValue `'full'`\n     */\n    textureCacheMode?: 'initializerOnly'|'full';\n    /**\n     * Set or get the packed texture mode\n     *\n     * @defaultValue `false`\n     */\n    pack?: boolean;\n    /**\n     * Set or get whether enable async download.\n     *\n     * @defaultValue `false`\n     */\n    async?: boolean;\n  }\n\n  export interface WebGpuProfilingDataV1TensorMetadata {\n    dims: readonly number[];\n    dataType: string;\n  }\n  export interface WebGpuProfilingDataV1 {\n    version: 1;\n    inputsMetadata: readonly WebGpuProfilingDataV1TensorMetadata[];\n    outputsMetadata: readonly WebGpuProfilingDataV1TensorMetadata[];\n    kernelId: number;\n    kernelType: string;\n    kernelName: string;\n    programName: string;\n    startTime: number;\n    endTime: number;\n  }\n\n  export type WebGpuProfilingData = WebGpuProfilingDataV1;\n\n  export interface WebGpuFlags {\n    /**\n     * Set or get the profiling mode.\n     *\n     * @deprecated Use `env.webgpu.profiling.mode` instead. If `env.webgpu.profiling.mode` is set, this property will be\n     * ignored.\n     */\n    profilingMode?: 'off'|'default';\n    /**\n     * Set or get the profiling configuration.\n     */\n    profiling?: {\n      /**\n       * Set or get the profiling mode.\n       *\n       * @defaultValue `'off'`\n       */\n      mode?: 'off'|'default';\n\n      /**\n       * Set or get a callback function when a profiling data is received. If not set, the profiling data will be\n       * printed to console.\n       */\n      ondata?: (data: WebGpuProfilingData) => void;\n    };\n    /**\n     * Set or get the power preference.\n     *\n     * Setting this property only has effect before the first WebGPU inference session is created. The value will be\n     * used as options for `navigator.gpu.requestAdapter()`.\n     *\n     * See {@link https://gpuweb.github.io/gpuweb/#dictdef-gpurequestadapteroptions} for more details.\n     *\n     * @defaultValue `undefined`\n     */\n    powerPreference?: 'low-power'|'high-performance';\n    /**\n     * Set or get the force fallback adapter flag.\n     *\n     * Setting this property only has effect before the first WebGPU inference session is created. The value will be\n     * used as options for `navigator.gpu.requestAdapter()`.\n     *\n     * See {@link https://gpuweb.github.io/gpuweb/#dictdef-gpurequestadapteroptions} for more details.\n     *\n     * @defaultValue `undefined`\n     */\n    forceFallbackAdapter?: boolean;\n    /**\n     * Set or get the adapter for WebGPU.\n     *\n     * Setting this property only has effect before the first WebGPU inference session is created. The value will be\n     * used as the GPU adapter for the underlying WebGPU backend to create GPU device.\n     *\n     * If this property is not set, it will be available to get after the first WebGPU inference session is created. The\n     * value will be the GPU adapter that created by the underlying WebGPU backend.\n     *\n     * When use with TypeScript, the type of this property is `GPUAdapter` defined in \"@webgpu/types\".\n     * Use `const adapter = env.webgpu.adapter as GPUAdapter;` in TypeScript to access this property with correct type.\n     *\n     * see comments on {@link Tensor.GpuBufferType}\n     */\n    adapter: unknown;\n    /**\n     * Get the device for WebGPU.\n     *\n     * This property is only available after the first WebGPU inference session is created.\n     *\n     * When use with TypeScript, the type of this property is `GPUDevice` defined in \"@webgpu/types\".\n     * Use `const device = env.webgpu.device as GPUDevice;` in TypeScript to access this property with correct type.\n     *\n     * see comments on {@link Tensor.GpuBufferType} for more details about why not use types defined in \"@webgpu/types\".\n     */\n    readonly device: unknown;\n    /**\n     * Set or get whether validate input content.\n     *\n     * @defaultValue `false`\n     */\n    validateInputContent?: boolean;\n  }\n}\n\nexport interface Env {\n  /**\n   * set the severity level for logging.\n   *\n   * @defaultValue `'warning'`\n   */\n  logLevel?: 'verbose'|'info'|'warning'|'error'|'fatal';\n\n  /**\n   * Indicate whether run in debug mode.\n   *\n   * @defaultValue `false`\n   */\n  debug?: boolean;\n\n  /**\n   * set or get a boolean value indicating whether to enable trace.\n   *\n   * @defaultValue `false`\n   */\n  trace?: boolean;\n\n  /**\n   * Get version of the current package.\n   */\n  readonly versions: {\n    readonly common: string;\n    readonly web?: string;\n    readonly node?: string;\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    readonly 'react-native'?: string;\n  };\n\n  /**\n   * Represent a set of flags for WebAssembly\n   */\n  readonly wasm: Env.WebAssemblyFlags;\n\n  /**\n   * Represent a set of flags for WebGL\n   */\n  readonly webgl: Env.WebGLFlags;\n\n  /**\n   * Represent a set of flags for WebGPU\n   */\n  readonly webgpu: Env.WebGpuFlags;\n\n  [name: string]: unknown;\n}\n\n/**\n * Represent a set of flags as a global singleton.\n */\nexport const env: Env = envImpl;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorToDataUrlOptions, TensorToImageDataOptions} from './tensor-conversion.js';\nimport {Tensor} from './tensor.js';\n\n/**\n * implementation of Tensor.toDataURL()\n */\nexport const tensorToDataURL = (tensor: Tensor, options?: TensorToDataUrlOptions): string => {\n  const canvas = typeof document !== 'undefined' ? document.createElement('canvas') : (new OffscreenCanvas(1, 1));\n  canvas.width = tensor.dims[3];\n  canvas.height = tensor.dims[2];\n  const pixels2DContext =\n      canvas.getContext('2d') as (CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | null);\n\n  if (pixels2DContext != null) {\n    // Default values for height and width & format\n    let width: number;\n    let height: number;\n    if (options?.tensorLayout !== undefined && options.tensorLayout === 'NHWC') {\n      width = tensor.dims[2];\n      height = tensor.dims[3];\n    } else {  // Default layout is NCWH\n      width = tensor.dims[3];\n      height = tensor.dims[2];\n    }\n\n    const inputformat = options?.format !== undefined ? options.format : 'RGB';\n\n    const norm = options?.norm;\n    let normMean: [number, number, number, number];\n    let normBias: [number, number, number, number];\n    if (norm === undefined || norm.mean === undefined) {\n      normMean = [255, 255, 255, 255];\n    } else {\n      if (typeof (norm.mean) === 'number') {\n        normMean = [norm.mean, norm.mean, norm.mean, norm.mean];\n      } else {\n        normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 0];\n        if (norm.mean[3] !== undefined) {\n          normMean[3] = norm.mean[3];\n        }\n      }\n    }\n    if (norm === undefined || norm.bias === undefined) {\n      normBias = [0, 0, 0, 0];\n    } else {\n      if (typeof (norm.bias) === 'number') {\n        normBias = [norm.bias, norm.bias, norm.bias, norm.bias];\n      } else {\n        normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];\n        if (norm.bias[3] !== undefined) {\n          normBias[3] = norm.bias[3];\n        }\n      }\n    }\n\n    const stride = height * width;\n    // Default pointer assignments\n    let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;\n\n    // Updating the pointer assignments based on the input image format\n    if (inputformat === 'RGBA') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n      aTensorPointer = stride * 3;\n    } else if (inputformat === 'RGB') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n    } else if (inputformat === 'RBG') {\n      rTensorPointer = 0;\n      bTensorPointer = stride;\n      gTensorPointer = stride * 2;\n    }\n\n    for (let i = 0; i < height; i++) {\n      for (let j = 0; j < width; j++) {\n        const R = ((tensor.data[rTensorPointer++] as number) - normBias[0]) * normMean[0];  // R value\n        const G = ((tensor.data[gTensorPointer++] as number) - normBias[1]) * normMean[1];  // G value\n        const B = ((tensor.data[bTensorPointer++] as number) - normBias[2]) * normMean[2];  // B value\n        const A = aTensorPointer === -1 ?\n            255 :\n            ((tensor.data[aTensorPointer++] as number) - normBias[3]) * normMean[3];  // A value\n        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n        pixels2DContext.fillStyle = 'rgba(' + R + ',' + G + ',' + B + ',' + A + ')';\n        pixels2DContext.fillRect(j, i, 1, 1);\n      }\n    }\n    if ('toDataURL' in canvas) {\n      return canvas.toDataURL();\n    } else {\n      throw new Error('toDataURL is not supported');\n    }\n  } else {\n    throw new Error('Can not access image data');\n  }\n};\n\n/**\n * implementation of Tensor.toImageData()\n */\nexport const tensorToImageData = (tensor: Tensor, options?: TensorToImageDataOptions): ImageData => {\n  const pixels2DContext = typeof document !== 'undefined' ?\n      document.createElement('canvas').getContext('2d') :\n      new OffscreenCanvas(1, 1).getContext('2d') as OffscreenCanvasRenderingContext2D;\n  let image: ImageData;\n  if (pixels2DContext != null) {\n    // Default values for height and width & format\n    let width: number;\n    let height: number;\n    let channels: number;\n    if (options?.tensorLayout !== undefined && options.tensorLayout === 'NHWC') {\n      width = tensor.dims[2];\n      height = tensor.dims[1];\n      channels = tensor.dims[3];\n    } else {  // Default layout is NCWH\n      width = tensor.dims[3];\n      height = tensor.dims[2];\n      channels = tensor.dims[1];\n    }\n    const inputformat = options !== undefined ? (options.format !== undefined ? options.format : 'RGB') : 'RGB';\n\n    const norm = options?.norm;\n    let normMean: [number, number, number, number];\n    let normBias: [number, number, number, number];\n    if (norm === undefined || norm.mean === undefined) {\n      normMean = [255, 255, 255, 255];\n    } else {\n      if (typeof (norm.mean) === 'number') {\n        normMean = [norm.mean, norm.mean, norm.mean, norm.mean];\n      } else {\n        normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 255];\n        if (norm.mean[3] !== undefined) {\n          normMean[3] = norm.mean[3];\n        }\n      }\n    }\n    if (norm === undefined || norm.bias === undefined) {\n      normBias = [0, 0, 0, 0];\n    } else {\n      if (typeof (norm.bias) === 'number') {\n        normBias = [norm.bias, norm.bias, norm.bias, norm.bias];\n      } else {\n        normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];\n        if (norm.bias[3] !== undefined) {\n          normBias[3] = norm.bias[3];\n        }\n      }\n    }\n\n    const stride = height * width;\n    if (options !== undefined) {\n      if (options.format !== undefined && (channels === 4 && options.format !== 'RGBA') ||\n          (channels === 3 && (options.format !== 'RGB' && options.format !== 'BGR'))) {\n        throw new Error('Tensor format doesn\\'t match input tensor dims');\n      }\n    }\n\n    // Default pointer assignments\n    const step = 4;\n    let rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;\n    let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;\n\n    // Updating the pointer assignments based on the input image format\n    if (inputformat === 'RGBA') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n      aTensorPointer = stride * 3;\n    } else if (inputformat === 'RGB') {\n      rTensorPointer = 0;\n      gTensorPointer = stride;\n      bTensorPointer = stride * 2;\n    } else if (inputformat === 'RBG') {\n      rTensorPointer = 0;\n      bTensorPointer = stride;\n      gTensorPointer = stride * 2;\n    }\n\n    image = pixels2DContext.createImageData(width, height);\n\n    for (let i = 0; i < height * width;\n         rImagePointer += step, gImagePointer += step, bImagePointer += step, aImagePointer += step, i++) {\n      image.data[rImagePointer] = ((tensor.data[rTensorPointer++] as number) - normBias[0]) * normMean[0];  // R value\n      image.data[gImagePointer] = ((tensor.data[gTensorPointer++] as number) - normBias[1]) * normMean[1];  // G value\n      image.data[bImagePointer] = ((tensor.data[bTensorPointer++] as number) - normBias[2]) * normMean[2];  // B value\n      image.data[aImagePointer] = aTensorPointer === -1 ?\n          255 :\n          ((tensor.data[aTensorPointer++] as number) - normBias[3]) * normMean[3];  // A value\n    }\n\n  } else {\n    throw new Error('Can not access image data');\n  }\n  return image;\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {OptionsDimensions, OptionsFormat, OptionsNormalizationParameters, OptionsTensorFormat, OptionsTensorLayout, TensorFromGpuBufferOptions, TensorFromImageBitmapOptions, TensorFromImageDataOptions, TensorFromImageElementOptions, TensorFromTextureOptions, TensorFromUrlOptions} from './tensor-factory.js';\nimport {Tensor} from './tensor-impl.js';\nimport {Tensor as TensorInterface} from './tensor.js';\n\ninterface BufferToTensorOptions extends OptionsDimensions, OptionsTensorLayout, OptionsNormalizationParameters,\n                                        OptionsFormat, OptionsTensorFormat {}\n\n/**\n * Create a new tensor object from image object\n *\n * @param buffer - Extracted image buffer data - assuming RGBA format\n * @param imageFormat - input image configuration - required configurations height, width, format\n * @param tensorFormat - output tensor configuration - Default is RGB format\n */\nexport const bufferToTensor = (buffer: Uint8ClampedArray|undefined, options: BufferToTensorOptions): Tensor => {\n  if (buffer === undefined) {\n    throw new Error('Image buffer must be defined');\n  }\n  if (options.height === undefined || options.width === undefined) {\n    throw new Error('Image height and width must be defined');\n  }\n  if (options.tensorLayout === 'NHWC') {\n    throw new Error('NHWC Tensor layout is not supported yet');\n  }\n\n  const {height, width} = options;\n\n  const norm = options.norm ?? {mean: 255, bias: 0};\n  let normMean: [number, number, number, number];\n  let normBias: [number, number, number, number];\n\n  if (typeof (norm.mean) === 'number') {\n    normMean = [norm.mean, norm.mean, norm.mean, norm.mean];\n  } else {\n    normMean = [norm.mean![0], norm.mean![1], norm.mean![2], norm.mean![3] ?? 255];\n  }\n\n  if (typeof (norm.bias) === 'number') {\n    normBias = [norm.bias, norm.bias, norm.bias, norm.bias];\n  } else {\n    normBias = [norm.bias![0], norm.bias![1], norm.bias![2], norm.bias![3] ?? 0];\n  }\n\n  const inputformat = options.format !== undefined ? options.format : 'RGBA';\n  // default value is RGBA since imagedata and HTMLImageElement uses it\n\n  const outputformat =\n      options.tensorFormat !== undefined ? (options.tensorFormat !== undefined ? options.tensorFormat : 'RGB') : 'RGB';\n  const stride = height * width;\n  const float32Data = outputformat === 'RGBA' ? new Float32Array(stride * 4) : new Float32Array(stride * 3);\n\n  // Default pointer assignments\n  let step = 4, rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;\n  let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;\n\n  // Updating the pointer assignments based on the input image format\n  if (inputformat === 'RGB') {\n    step = 3;\n    rImagePointer = 0;\n    gImagePointer = 1;\n    bImagePointer = 2;\n    aImagePointer = -1;\n  }\n\n  // Updating the pointer assignments based on the output tensor format\n  if (outputformat === 'RGBA') {\n    aTensorPointer = stride * 3;\n  } else if (outputformat === 'RBG') {\n    rTensorPointer = 0;\n    bTensorPointer = stride;\n    gTensorPointer = stride * 2;\n  } else if (outputformat === 'BGR') {\n    bTensorPointer = 0;\n    gTensorPointer = stride;\n    rTensorPointer = stride * 2;\n  }\n\n  for (let i = 0; i < stride;\n       i++, rImagePointer += step, bImagePointer += step, gImagePointer += step, aImagePointer += step) {\n    float32Data[rTensorPointer++] = (buffer[rImagePointer] + normBias[0]) / normMean[0];\n    float32Data[gTensorPointer++] = (buffer[gImagePointer] + normBias[1]) / normMean[1];\n    float32Data[bTensorPointer++] = (buffer[bImagePointer] + normBias[2]) / normMean[2];\n    if (aTensorPointer !== -1 && aImagePointer !== -1) {\n      float32Data[aTensorPointer++] = (buffer[aImagePointer] + normBias[3]) / normMean[3];\n    }\n  }\n\n  // Float32Array -> ort.Tensor\n  const outputTensor = outputformat === 'RGBA' ? new Tensor('float32', float32Data, [1, 4, height, width]) :\n                                                 new Tensor('float32', float32Data, [1, 3, height, width]);\n  return outputTensor;\n};\n\n/**\n * implementation of Tensor.fromImage().\n */\nexport const tensorFromImage = async(\n    image: ImageData|HTMLImageElement|ImageBitmap|string,\n    options?: TensorFromImageDataOptions|TensorFromImageElementOptions|TensorFromImageBitmapOptions|\n    TensorFromUrlOptions): Promise<Tensor> => {\n  // checking the type of image object\n  const isHTMLImageEle = typeof (HTMLImageElement) !== 'undefined' && image instanceof HTMLImageElement;\n  const isImageDataEle = typeof (ImageData) !== 'undefined' && image instanceof ImageData;\n  const isImageBitmap = typeof (ImageBitmap) !== 'undefined' && image instanceof ImageBitmap;\n  const isString = typeof image === 'string';\n\n  let data: Uint8ClampedArray|undefined;\n  let bufferToTensorOptions: BufferToTensorOptions = options ?? {};\n\n  const createCanvas = () => {\n    if (typeof document !== 'undefined') {\n      return document.createElement('canvas');\n    } else if (typeof OffscreenCanvas !== 'undefined') {\n      return new OffscreenCanvas(1, 1);\n    } else {\n      throw new Error('Canvas is not supported');\n    }\n  };\n  const createCanvasContext = (canvas: HTMLCanvasElement|OffscreenCanvas) => {\n    if (canvas instanceof HTMLCanvasElement) {\n      return canvas.getContext('2d');\n    } else if (canvas instanceof OffscreenCanvas) {\n      return canvas.getContext('2d') as OffscreenCanvasRenderingContext2D;\n    } else {\n      return null;\n    }\n  };\n  // filling and checking image configuration options\n  if (isHTMLImageEle) {\n    // HTMLImageElement - image object - format is RGBA by default\n    const canvas = createCanvas();\n    canvas.width = image.width;\n    canvas.height = image.height;\n    const pixels2DContext = createCanvasContext(canvas);\n\n    if (pixels2DContext != null) {\n      let height = image.height;\n      let width = image.width;\n      if (options !== undefined && options.resizedHeight !== undefined && options.resizedWidth !== undefined) {\n        height = options.resizedHeight;\n        width = options.resizedWidth;\n      }\n\n      if (options !== undefined) {\n        bufferToTensorOptions = options;\n        if (options.tensorFormat !== undefined) {\n          throw new Error('Image input config format must be RGBA for HTMLImageElement');\n        } else {\n          bufferToTensorOptions.tensorFormat = 'RGBA';\n        }\n        bufferToTensorOptions.height = height;\n        bufferToTensorOptions.width = width;\n      } else {\n        bufferToTensorOptions.tensorFormat = 'RGBA';\n        bufferToTensorOptions.height = height;\n        bufferToTensorOptions.width = width;\n      }\n\n      pixels2DContext.drawImage(image, 0, 0);\n      data = pixels2DContext.getImageData(0, 0, width, height).data;\n    } else {\n      throw new Error('Can not access image data');\n    }\n  } else if (isImageDataEle) {\n    let height: number;\n    let width: number;\n\n    if (options !== undefined && options.resizedWidth !== undefined && options.resizedHeight !== undefined) {\n      height = options.resizedHeight;\n      width = options.resizedWidth;\n    } else {\n      height = image.height;\n      width = image.width;\n    }\n\n    if (options !== undefined) {\n      bufferToTensorOptions = options;\n    }\n    bufferToTensorOptions.format = 'RGBA';\n    bufferToTensorOptions.height = height;\n    bufferToTensorOptions.width = width;\n\n    if (options !== undefined) {\n      const tempCanvas = createCanvas();\n\n      tempCanvas.width = width;\n      tempCanvas.height = height;\n\n      const pixels2DContext = createCanvasContext(tempCanvas);\n\n      if (pixels2DContext != null) {\n        pixels2DContext.putImageData(image, 0, 0);\n        data = pixels2DContext.getImageData(0, 0, width, height).data;\n      } else {\n        throw new Error('Can not access image data');\n      }\n    } else {\n      data = image.data;\n    }\n  } else if (isImageBitmap) {\n    // ImageBitmap - image object - format must be provided by user\n    if (options === undefined) {\n      throw new Error('Please provide image config with format for Imagebitmap');\n    }\n\n    const canvas = createCanvas();\n    canvas.width = image.width;\n    canvas.height = image.height;\n    const pixels2DContext = createCanvasContext(canvas);\n\n    if (pixels2DContext != null) {\n      const height = image.height;\n      const width = image.width;\n      pixels2DContext.drawImage(image, 0, 0, width, height);\n      data = pixels2DContext.getImageData(0, 0, width, height).data;\n      bufferToTensorOptions.height = height;\n      bufferToTensorOptions.width = width;\n      return bufferToTensor(data, bufferToTensorOptions);\n    } else {\n      throw new Error('Can not access image data');\n    }\n  } else if (isString) {\n    return new Promise((resolve, reject) => {\n      const canvas = createCanvas();\n      const context = createCanvasContext(canvas);\n      if (!image || !context) {\n        return reject();\n      }\n      const newImage = new Image();\n      newImage.crossOrigin = 'Anonymous';\n      newImage.src = image;\n      newImage.onload = () => {\n        canvas.width = newImage.width;\n        canvas.height = newImage.height;\n        context.drawImage(newImage, 0, 0, canvas.width, canvas.height);\n        const img = context.getImageData(0, 0, canvas.width, canvas.height);\n\n        bufferToTensorOptions.height = canvas.height;\n        bufferToTensorOptions.width = canvas.width;\n        resolve(bufferToTensor(img.data, bufferToTensorOptions));\n      };\n    });\n  } else {\n    throw new Error('Input data provided is not supported - aborted tensor creation');\n  }\n\n  if (data !== undefined) {\n    return bufferToTensor(data, bufferToTensorOptions);\n  } else {\n    throw new Error('Input data provided is not supported - aborted tensor creation');\n  }\n};\n\n/**\n * implementation of Tensor.fromTexture().\n */\nexport const tensorFromTexture = <T extends TensorInterface.TextureDataTypes>(\n    texture: TensorInterface.TextureType, options: TensorFromTextureOptions<T>): Tensor => {\n  const {width, height, download, dispose} = options;\n  // Always assume RGBAF32. TODO: support different texture format\n  const dims = [1, height, width, 4];\n  return new Tensor({location: 'texture', type: 'float32', texture, dims, download, dispose});\n};\n\n/**\n * implementation of Tensor.fromGpuBuffer().\n */\nexport const tensorFromGpuBuffer = <T extends TensorInterface.GpuBufferDataTypes>(\n    gpuBuffer: TensorInterface.GpuBufferType, options: TensorFromGpuBufferOptions<T>): Tensor => {\n  const {dataType, dims, download, dispose} = options;\n  return new Tensor({location: 'gpu-buffer', type: dataType ?? 'float32', gpuBuffer, dims, download, dispose});\n};\n\n/**\n * implementation of Tensor.fromPinnedBuffer().\n */\nexport const tensorFromPinnedBuffer = <T extends TensorInterface.CpuPinnedDataTypes>(\n    type: T, buffer: TensorInterface.DataTypeMap[T], dims?: readonly number[]): Tensor =>\n    new Tensor({location: 'cpu-pinned', type, data: buffer, dims: dims ?? [buffer.length]});\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Tensor} from './tensor.js';\n\nexport type SupportedTypedArrayConstructors = Float32ArrayConstructor|Uint8ArrayConstructor|Int8ArrayConstructor|\n    Uint16ArrayConstructor|Int16ArrayConstructor|Int32ArrayConstructor|BigInt64ArrayConstructor|Uint8ArrayConstructor|\n    Float64ArrayConstructor|Uint32ArrayConstructor|BigUint64ArrayConstructor;\nexport type SupportedTypedArray = InstanceType<SupportedTypedArrayConstructors>;\n\n// a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.\nexport const NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP = new Map<string, SupportedTypedArrayConstructors>([\n  ['float32', Float32Array],\n  ['uint8', Uint8Array],\n  ['int8', Int8Array],\n  ['uint16', Uint16Array],\n  ['int16', Int16Array],\n  ['int32', Int32Array],\n  ['bool', Uint8Array],\n  ['float64', Float64Array],\n  ['uint32', Uint32Array],\n]);\n\n// a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.\nexport const NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP = new Map<SupportedTypedArrayConstructors, Tensor.Type>([\n  [Float32Array, 'float32'],\n  [Uint8Array, 'uint8'],\n  [Int8Array, 'int8'],\n  [Uint16Array, 'uint16'],\n  [Int16Array, 'int16'],\n  [Int32Array, 'int32'],\n  [Float64Array, 'float64'],\n  [Uint32Array, 'uint32'],\n]);\n\n// a dummy type declaration for Float16Array in case any polyfill is available.\ndeclare global {\n  // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any\n  const Float16Array: any;\n}\n\n// the following code allows delaying execution of BigInt/Float16Array checking. This allows lazy initialization for\n// NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP and NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP, which allows BigInt/Float16Array\n// polyfill if available.\nlet isTypedArrayChecked = false;\nexport const checkTypedArray = () => {\n  if (!isTypedArrayChecked) {\n    isTypedArrayChecked = true;\n    const isBigInt64ArrayAvailable = typeof BigInt64Array !== 'undefined' && BigInt64Array.from;\n    const isBigUint64ArrayAvailable = typeof BigUint64Array !== 'undefined' && BigUint64Array.from;\n    const isFloat16ArrayAvailable = typeof Float16Array !== 'undefined' && Float16Array.from;\n\n    if (isBigInt64ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('int64', BigInt64Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigInt64Array, 'int64');\n    }\n    if (isBigUint64ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('uint64', BigUint64Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigUint64Array, 'uint64');\n    }\n    if (isFloat16ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('float16', Float16Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(Float16Array, 'float16');\n    } else {\n      // if Float16Array is not available, use 'Uint16Array' to store the data.\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('float16', Uint16Array);\n    }\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {CpuPinnedConstructorParameters, GpuBufferConstructorParameters, TextureConstructorParameters} from './tensor-factory.js';\nimport {Tensor} from './tensor-impl.js';\n\n/**\n * calculate size from dims.\n *\n * @param dims the dims array. May be an illegal input.\n */\nexport const calculateSize = (dims: readonly unknown[]): number => {\n  let size = 1;\n  for (let i = 0; i < dims.length; i++) {\n    const dim = dims[i];\n    if (typeof dim !== 'number' || !Number.isSafeInteger(dim)) {\n      throw new TypeError(`dims[${i}] must be an integer, got: ${dim}`);\n    }\n    if (dim < 0) {\n      throw new RangeError(`dims[${i}] must be a non-negative integer, got: ${dim}`);\n    }\n    size *= dim;\n  }\n  return size;\n};\n\n/**\n * implementation of Tensor.reshape()\n */\nexport const tensorReshape = (tensor: Tensor, dims: readonly number[]): Tensor => {\n  switch (tensor.location) {\n    case 'cpu':\n      return new Tensor(tensor.type, tensor.data, dims);\n    case 'cpu-pinned':\n      return new Tensor({\n        location: 'cpu-pinned',\n        data: tensor.data as CpuPinnedConstructorParameters['data'],\n        type: tensor.type as CpuPinnedConstructorParameters['type'],\n        dims,\n      });\n    case 'texture':\n      return new Tensor({\n        location: 'texture',\n        texture: tensor.texture,\n        type: tensor.type as TextureConstructorParameters['type'],\n        dims,\n      });\n    case 'gpu-buffer':\n      return new Tensor({\n        location: 'gpu-buffer',\n        gpuBuffer: tensor.gpuBuffer,\n        type: tensor.type as GpuBufferConstructorParameters['type'],\n        dims,\n      });\n    default:\n      throw new Error(`tensorReshape: tensor location ${tensor.location} is not supported`);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {tensorToDataURL, tensorToImageData} from './tensor-conversion-impl.js';\nimport {TensorToDataUrlOptions, TensorToImageDataOptions} from './tensor-conversion.js';\nimport {tensorFromGpuBuffer, tensorFromImage, tensorFromPinnedBuffer, tensorFromTexture} from './tensor-factory-impl.js';\nimport {CpuPinnedConstructorParameters, GpuBufferConstructorParameters, TensorFromGpuBufferOptions, TensorFromImageBitmapOptions, TensorFromImageDataOptions, TensorFromImageElementOptions, TensorFromTextureOptions, TensorFromUrlOptions, TextureConstructorParameters} from './tensor-factory.js';\nimport {checkTypedArray, NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP, NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP, SupportedTypedArray, SupportedTypedArrayConstructors} from './tensor-impl-type-mapping.js';\nimport {calculateSize, tensorReshape} from './tensor-utils-impl.js';\nimport {Tensor as TensorInterface} from './tensor.js';\n\n// type aliases for those exported from Tensor interface\n\ntype TensorType = TensorInterface.Type;\ntype TensorDataType = TensorInterface.DataType;\ntype TensorDataLocation = TensorInterface.DataLocation;\ntype TensorTextureType = TensorInterface.TextureType;\ntype TensorGpuBufferType = TensorInterface.GpuBufferType;\n\n/**\n * the implementation of Tensor interface.\n *\n * @ignore\n */\nexport class Tensor implements TensorInterface {\n  // #region constructors\n\n  /**\n   * Construct a new CPU tensor object from the given type, data and dims.\n   */\n  constructor(\n      type: TensorType, data: TensorDataType|readonly string[]|readonly number[]|readonly boolean[],\n      dims?: readonly number[]);\n  /**\n   * Construct a new CPU tensor object from the given data and dims. Type is inferred from data.\n   */\n  constructor(data: TensorDataType|readonly string[]|readonly boolean[], dims?: readonly number[]);\n  /**\n   * Construct a new tensor object from the pinned CPU data with the given type and dims.\n   *\n   * Tensor's location will be set to 'cpu-pinned'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: CpuPinnedConstructorParameters);\n  /**\n   * Construct a new tensor object from the WebGL texture with the given type and dims.\n   *\n   * Tensor's location will be set to 'texture'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: TextureConstructorParameters);\n  /**\n   * Construct a new tensor object from the WebGPU buffer with the given type and dims.\n   *\n   * Tensor's location will be set to 'gpu-buffer'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: GpuBufferConstructorParameters);\n\n  /**\n   * implementation.\n   */\n  constructor(\n      arg0: TensorType|TensorDataType|readonly string[]|readonly boolean[]|CpuPinnedConstructorParameters|\n      TextureConstructorParameters|GpuBufferConstructorParameters,\n      arg1?: TensorDataType|readonly number[]|readonly string[]|readonly boolean[], arg2?: readonly number[]) {\n    // perform one-time check for BigInt/Float16Array support\n    checkTypedArray();\n\n    let type: TensorType;\n    let dims: readonly number[];\n\n    if (typeof arg0 === 'object' && 'location' in arg0) {\n      //\n      // constructing tensor from specific location\n      //\n      this.dataLocation = arg0.location;\n      type = arg0.type;\n      dims = arg0.dims;\n      switch (arg0.location) {\n        case 'cpu-pinned': {\n          const expectedTypedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(type);\n          if (!expectedTypedArrayConstructor) {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from pinned buffer`);\n          }\n          if (!(arg0.data instanceof expectedTypedArrayConstructor)) {\n            throw new TypeError(`buffer should be of type ${expectedTypedArrayConstructor.name}`);\n          }\n          this.cpuData = arg0.data;\n          break;\n        }\n        case 'texture': {\n          if (type !== 'float32') {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from texture`);\n          }\n          this.gpuTextureData = arg0.texture;\n          this.downloader = arg0.download;\n          this.disposer = arg0.dispose;\n          break;\n        }\n        case 'gpu-buffer': {\n          if ((type !== 'float32' && type !== 'float16' && type !== 'int32' && type !== 'int64' && type !== 'uint32' &&\n               type !== 'uint8' && type !== 'bool')) {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from gpu buffer`);\n          }\n          this.gpuBufferData = arg0.gpuBuffer;\n          this.downloader = arg0.download;\n          this.disposer = arg0.dispose;\n          break;\n        }\n        default:\n          throw new Error(`Tensor constructor: unsupported location '${this.dataLocation}'`);\n      }\n    } else {\n      //\n      // constructing tensor of location 'cpu'\n      //\n      let data: TensorDataType;\n      let maybeDims: typeof arg1|typeof arg2;\n      // check whether arg0 is type or data\n      if (typeof arg0 === 'string') {\n        //\n        // Override: constructor(type, data, ...)\n        //\n        type = arg0;\n        maybeDims = arg2;\n        if (arg0 === 'string') {\n          // string tensor\n          if (!Array.isArray(arg1)) {\n            throw new TypeError('A string tensor\\'s data must be a string array.');\n          }\n          // we don't check whether every element in the array is string; this is too slow. we assume it's correct and\n          // error will be populated at inference\n          data = arg1;\n        } else {\n          // numeric tensor\n          const typedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(arg0);\n          if (typedArrayConstructor === undefined) {\n            throw new TypeError(`Unsupported tensor type: ${arg0}.`);\n          }\n          if (Array.isArray(arg1)) {\n            if (arg0 === 'float16' && typedArrayConstructor === Uint16Array) {\n              // When no Float16Array polyfill is used, we cannot create 'float16' tensor from number array.\n              //\n              // Throw error here because when user try to use number array as data,\n              // e.g. new Tensor('float16', [1, 2, 3, 4], dims)), it will actually call\n              // Uint16Array.from(arg1) which generates wrong data.\n              throw new TypeError(\n                  'Creating a float16 tensor from number array is not supported. Please use Uint16Array as data.');\n            } else if (arg0 === 'uint64' || arg0 === 'int64') {\n              // use 'as any' here because:\n              // 1. TypeScript's check on type of 'Array.isArray()' does not work with readonly arrays.\n              // see https://github.com/microsoft/TypeScript/issues/17002\n              // 2. TypeScript's check on union type of '(BigInt64ArrayConstructor|BigUint64ArrayConstructor).from()'\n              // does not accept parameter mapFn.\n              // 3. parameters of 'SupportedTypedArrayConstructors.from()' does not match the requirement of the union\n              // type.\n\n              // assume 'arg1' is of type \"readonly number[]|readonly bigint[]\" here.\n\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              data = (typedArrayConstructor as any).from(arg1, BigInt);\n            } else {\n              // assume 'arg1' is of type \"readonly number[]\" here.\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              data = (typedArrayConstructor as any).from(arg1);\n            }\n          } else if (arg1 instanceof typedArrayConstructor) {\n            data = arg1;\n          } else {\n            throw new TypeError(`A ${type} tensor's data must be type of ${typedArrayConstructor}`);\n          }\n        }\n      } else {\n        //\n        // Override: constructor(data, ...)\n        //\n        maybeDims = arg1;\n        if (Array.isArray(arg0)) {\n          // only boolean[] and string[] is supported\n          if (arg0.length === 0) {\n            throw new TypeError('Tensor type cannot be inferred from an empty array.');\n          }\n          const firstElementType = typeof arg0[0];\n          if (firstElementType === 'string') {\n            type = 'string';\n            data = arg0;\n          } else if (firstElementType === 'boolean') {\n            type = 'bool';\n            // 'arg0' is of type 'boolean[]'. Uint8Array.from(boolean[]) actually works, but typescript thinks this is\n            // wrong type. We use 'as any' to make it happy.\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            data = Uint8Array.from(arg0 as any[]);\n          } else {\n            throw new TypeError(`Invalid element type of data array: ${firstElementType}.`);\n          }\n        } else {\n          // get tensor type from TypedArray\n          const mappedType =\n              NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.get(arg0.constructor as SupportedTypedArrayConstructors);\n          if (mappedType === undefined) {\n            throw new TypeError(`Unsupported type for tensor data: ${arg0.constructor}.`);\n          }\n          type = mappedType;\n          data = arg0 as SupportedTypedArray;\n        }\n      }\n\n      // type and data is processed, now processing dims\n      if (maybeDims === undefined) {\n        // assume 1-D tensor if dims omitted\n        maybeDims = [data.length];\n      } else if (!Array.isArray(maybeDims)) {\n        throw new TypeError('A tensor\\'s dims must be a number array');\n      }\n      dims = maybeDims as readonly number[];\n\n      this.cpuData = data;\n      this.dataLocation = 'cpu';\n    }\n\n    // perform check on dims\n    const size = calculateSize(dims);\n    // if data is on CPU, check whether data length matches tensor size\n    if (this.cpuData && size !== this.cpuData.length) {\n      throw new Error(`Tensor's size(${size}) does not match data length(${this.cpuData.length}).`);\n    }\n\n    this.type = type;\n    this.dims = dims;\n    this.size = size;\n  }\n  // #endregion\n\n  // #region factory\n  static async fromImage(\n      image: ImageData|HTMLImageElement|ImageBitmap|string,\n      options?: TensorFromImageDataOptions|TensorFromImageElementOptions|TensorFromImageBitmapOptions|\n      TensorFromUrlOptions): Promise<TensorInterface> {\n    return tensorFromImage(image, options);\n  }\n\n  static fromTexture<T extends TensorInterface.TextureDataTypes>(\n      texture: TensorTextureType, options: TensorFromTextureOptions<T>): TensorInterface {\n    return tensorFromTexture(texture, options);\n  }\n\n  static fromGpuBuffer<T extends TensorInterface.GpuBufferDataTypes>(\n      gpuBuffer: TensorGpuBufferType, options: TensorFromGpuBufferOptions<T>): TensorInterface {\n    return tensorFromGpuBuffer(gpuBuffer, options);\n  }\n\n  static fromPinnedBuffer<T extends TensorInterface.CpuPinnedDataTypes>(\n      type: T, buffer: TensorInterface.DataTypeMap[T], dims?: readonly number[]): Tensor {\n    return tensorFromPinnedBuffer(type, buffer, dims);\n  }\n\n  // #endregion\n\n  // #region conversions\n  toDataURL(options?: TensorToDataUrlOptions): string {\n    return tensorToDataURL(this, options);\n  }\n\n  toImageData(options?: TensorToImageDataOptions): ImageData {\n    return tensorToImageData(this, options);\n  }\n  // #endregion\n\n  // #region public fields\n  readonly dims: readonly number[];\n  readonly type: TensorType;\n  readonly size: number;\n  // #endregion\n\n  // #region private fields\n\n  /**\n   * stores the location of the data.\n   */\n  private dataLocation: TensorDataLocation;\n\n  /**\n   * stores the data on CPU, if location is 'cpu' or 'cpu-pinned'. otherwise empty.\n   */\n  private cpuData?: TensorDataType;\n\n  /**\n   * stores the underlying texture when location is 'texture'. otherwise empty.\n   */\n  private gpuTextureData?: TensorTextureType;\n\n  /**\n   * stores the underlying GPU buffer when location is 'gpu-buffer'. otherwise empty.\n   */\n  private gpuBufferData?: TensorGpuBufferType;\n\n  /**\n   * stores an optional downloader function to download data from GPU to CPU.\n   */\n  private downloader?(): Promise<TensorDataType>;\n\n  /**\n   * a flag indicating whether the data is being downloaded from GPU to CPU.\n   */\n  private isDownloading?: boolean;\n\n  /**\n   * stores an optional disposer function to dispose the underlying data.\n   */\n  private disposer?(): void;\n  // #endregion\n\n  // #region properties\n  get data(): TensorDataType {\n    this.ensureValid();\n    if (!this.cpuData) {\n      throw new Error(\n          'The data is not on CPU. Use `getData()` to download GPU data to CPU, ' +\n          'or use `texture` or `gpuBuffer` property to access the GPU data directly.');\n    }\n    return this.cpuData;\n  }\n\n  get location(): TensorDataLocation {\n    return this.dataLocation;\n  }\n\n  get texture(): TensorTextureType {\n    this.ensureValid();\n    if (!this.gpuTextureData) {\n      throw new Error('The data is not stored as a WebGL texture.');\n    }\n    return this.gpuTextureData;\n  }\n\n  get gpuBuffer(): TensorGpuBufferType {\n    this.ensureValid();\n    if (!this.gpuBufferData) {\n      throw new Error('The data is not stored as a WebGPU buffer.');\n    }\n    return this.gpuBufferData;\n  }\n  // #endregion\n\n  // #region methods\n\n  async getData(releaseData?: boolean): Promise<TensorDataType> {\n    this.ensureValid();\n    switch (this.dataLocation) {\n      case 'cpu':\n      case 'cpu-pinned':\n        return this.data;\n      case 'texture':\n      case 'gpu-buffer': {\n        if (!this.downloader) {\n          throw new Error('The current tensor is not created with a specified data downloader.');\n        }\n        if (this.isDownloading) {\n          throw new Error('The current tensor is being downloaded.');\n        }\n        try {\n          this.isDownloading = true;\n          const data = await this.downloader();\n          this.downloader = undefined;\n          this.dataLocation = 'cpu';\n          this.cpuData = data;\n\n          if (releaseData && this.disposer) {\n            this.disposer();\n            this.disposer = undefined;\n          }\n\n          return data;\n\n        } finally {\n          this.isDownloading = false;\n        }\n      }\n      default:\n        throw new Error(`cannot get data from location: ${this.dataLocation}`);\n    }\n  }\n\n  dispose(): void {\n    if (this.isDownloading) {\n      throw new Error('The current tensor is being downloaded.');\n    }\n\n    if (this.disposer) {\n      this.disposer();\n      this.disposer = undefined;\n    }\n    this.cpuData = undefined;\n    this.gpuTextureData = undefined;\n    this.gpuBufferData = undefined;\n    this.downloader = undefined;\n    this.isDownloading = undefined;\n\n    this.dataLocation = 'none';\n  }\n\n  // #endregion\n\n  // #region tensor utilities\n  private ensureValid(): void {\n    if (this.dataLocation === 'none') {\n      throw new Error('The tensor is disposed.');\n    }\n  }\n\n  reshape(dims: readonly number[]): TensorInterface {\n    this.ensureValid();\n    if (this.downloader || this.disposer) {\n      throw new Error('Cannot reshape a tensor that owns GPU resource.');\n    }\n    return tensorReshape(this, dims);\n  }\n  // #endregion\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorFactory} from './tensor-factory.js';\nimport {Tensor as TensorImpl} from './tensor-impl.js';\nimport {TypedTensorUtils} from './tensor-utils.js';\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\n/**\n * represent a basic tensor with specified dimensions and data type.\n */\ninterface TypedTensorBase<T extends Tensor.Type> {\n  /**\n   * Get the dimensions of the tensor.\n   */\n  readonly dims: readonly number[];\n  /**\n   * Get the data type of the tensor.\n   */\n  readonly type: T;\n  /**\n   * Get the buffer data of the tensor.\n   *\n   * If the data is not on CPU (eg. it's in the form of WebGL texture or WebGPU buffer), throw error.\n   */\n  readonly data: Tensor.DataTypeMap[T];\n  /**\n   * Get the location of the data.\n   */\n  readonly location: Tensor.DataLocation;\n  /**\n   * Get the WebGL texture that holds the tensor data.\n   *\n   * If the data is not on GPU as WebGL texture, throw error.\n   */\n  readonly texture: Tensor.TextureType;\n  /**\n   * Get the WebGPU buffer that holds the tensor data.\n   *\n   * If the data is not on GPU as WebGPU buffer, throw error.\n   */\n  readonly gpuBuffer: Tensor.GpuBufferType;\n\n  /**\n   * Get the buffer data of the tensor.\n   *\n   * If the data is on CPU, returns the data immediately.\n   * If the data is on GPU, downloads the data and returns the promise.\n   *\n   * @param releaseData - whether release the data on GPU. Ignore if data is already on CPU.\n   */\n  getData(releaseData?: boolean): Promise<Tensor.DataTypeMap[T]>;\n\n  /**\n   * Dispose the tensor data.\n   *\n   * If the data is on CPU, remove its internal reference to the underlying data.\n   * If the data is on GPU, release the data on GPU.\n   *\n   * After calling this function, the tensor is considered no longer valid. Its location will be set to 'none'.\n   */\n  dispose(): void;\n}\n\nexport declare namespace Tensor {\n  interface DataTypeMap {\n    float32: Float32Array;\n    uint8: Uint8Array;\n    int8: Int8Array;\n    uint16: Uint16Array;\n    int16: Int16Array;\n    int32: Int32Array;\n    int64: BigInt64Array;\n    string: string[];\n    bool: Uint8Array;\n    float16: Uint16Array;  // Keep using Uint16Array until we have a concrete solution for float 16.\n    float64: Float64Array;\n    uint32: Uint32Array;\n    uint64: BigUint64Array;\n    // complex64: never;\n    // complex128: never;\n    // bfloat16: never;\n  }\n\n  interface ElementTypeMap {\n    float32: number;\n    uint8: number;\n    int8: number;\n    uint16: number;\n    int16: number;\n    int32: number;\n    int64: bigint;\n    string: string;\n    bool: boolean;\n    float16: number;  // Keep using Uint16Array until we have a concrete solution for float 16.\n    float64: number;\n    uint32: number;\n    uint64: bigint;\n    // complex64: never;\n    // complex128: never;\n    // bfloat16: never;\n  }\n\n  type DataType = DataTypeMap[Type];\n  type ElementType = ElementTypeMap[Type];\n\n  /**\n   * supported data types for constructing a tensor from a pinned CPU buffer\n   */\n  export type CpuPinnedDataTypes = Exclude<Tensor.Type, 'string'>;\n\n  /**\n   * type alias for WebGL texture\n   */\n  export type TextureType = WebGLTexture;\n\n  /**\n   * supported data types for constructing a tensor from a WebGL texture\n   */\n  export type TextureDataTypes = 'float32';\n\n  /**\n   * type alias for WebGPU buffer\n   *\n   * The reason why we don't use type \"GPUBuffer\" defined in webgpu.d.ts from @webgpu/types is because \"@webgpu/types\"\n   * requires \"@types/dom-webcodecs\" as peer dependency when using TypeScript < v5.1 and its version need to be chosen\n   * carefully according to the TypeScript version being used. This means so far there is not a way to keep every\n   * TypeScript version happy. It turns out that we will easily broke users on some TypeScript version.\n   *\n   * for more info see https://github.com/gpuweb/types/issues/127\n   */\n  export type GpuBufferType = {size: number; mapState: 'unmapped' | 'pending' | 'mapped'};\n\n  /**\n   * supported data types for constructing a tensor from a WebGPU buffer\n   */\n  export type GpuBufferDataTypes = 'float32'|'float16'|'int32'|'int64'|'uint32'|'uint8'|'bool';\n\n  /**\n   * represent where the tensor data is stored\n   */\n  export type DataLocation = 'none'|'cpu'|'cpu-pinned'|'texture'|'gpu-buffer';\n\n  /**\n   * represent the data type of a tensor\n   */\n  export type Type = keyof DataTypeMap;\n}\n\n/**\n * Represent multi-dimensional arrays to feed to or fetch from model inferencing.\n */\nexport interface TypedTensor<T extends Tensor.Type> extends TypedTensorBase<T>, TypedTensorUtils<T> {}\n/**\n * Represent multi-dimensional arrays to feed to or fetch from model inferencing.\n */\nexport interface Tensor extends TypedTensorBase<Tensor.Type>, TypedTensorUtils<Tensor.Type> {}\n\n/**\n * type TensorConstructor defines the constructors of 'Tensor' to create CPU tensor instances.\n */\nexport interface TensorConstructor extends TensorFactory {\n  // #region CPU tensor - specify element type\n  /**\n   * Construct a new string tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(type: 'string', data: Tensor.DataTypeMap['string']|readonly string[],\n      dims?: readonly number[]): TypedTensor<'string'>;\n\n  /**\n   * Construct a new bool tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(type: 'bool', data: Tensor.DataTypeMap['bool']|readonly boolean[], dims?: readonly number[]): TypedTensor<'bool'>;\n\n  /**\n   * Construct a new 64-bit integer typed tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new<T extends 'uint64'|'int64'>(\n      type: T, data: Tensor.DataTypeMap[T]|readonly bigint[]|readonly number[],\n      dims?: readonly number[]): TypedTensor<T>;\n\n  /**\n   * Construct a new numeric tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new<T extends Exclude<Tensor.Type, 'string'|'bool'|'uint64'|'int64'>>(\n      type: T, data: Tensor.DataTypeMap[T]|readonly number[], dims?: readonly number[]): TypedTensor<T>;\n  // #endregion\n\n  // #region CPU tensor - infer element types\n\n  /**\n   * Construct a new float32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Float32Array, dims?: readonly number[]): TypedTensor<'float32'>;\n\n  /**\n   * Construct a new int8 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Int8Array, dims?: readonly number[]): TypedTensor<'int8'>;\n\n  /**\n   * Construct a new uint8 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Uint8Array, dims?: readonly number[]): TypedTensor<'uint8'>;\n\n  /**\n   * Construct a new uint16 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Uint16Array, dims?: readonly number[]): TypedTensor<'uint16'>;\n\n  /**\n   * Construct a new int16 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Int16Array, dims?: readonly number[]): TypedTensor<'int16'>;\n\n  /**\n   * Construct a new int32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Int32Array, dims?: readonly number[]): TypedTensor<'int32'>;\n\n  /**\n   * Construct a new int64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: BigInt64Array, dims?: readonly number[]): TypedTensor<'int64'>;\n\n  /**\n   * Construct a new string tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: readonly string[], dims?: readonly number[]): TypedTensor<'string'>;\n\n  /**\n   * Construct a new bool tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: readonly boolean[], dims?: readonly number[]): TypedTensor<'bool'>;\n\n  /**\n   * Construct a new float64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Float64Array, dims?: readonly number[]): TypedTensor<'float64'>;\n\n  /**\n   * Construct a new uint32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Uint32Array, dims?: readonly number[]): TypedTensor<'uint32'>;\n\n  /**\n   * Construct a new uint64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: BigUint64Array, dims?: readonly number[]): TypedTensor<'uint64'>;\n\n  // #endregion\n\n  // #region CPU tensor - fall back to non-generic tensor type declaration\n\n  /**\n   * Construct a new tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(type: Tensor.Type, data: Tensor.DataType|readonly number[]|readonly string[]|readonly bigint[]|readonly boolean[],\n      dims?: readonly number[]): Tensor;\n\n  /**\n   * Construct a new tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new(data: Tensor.DataType, dims?: readonly number[]): Tensor;\n  // #endregion\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const Tensor = TensorImpl as TensorConstructor;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {env} from './env-impl.js';\n\n/**\n * @ignore\n */\nexport const TRACE = (deviceType: string, label: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  // eslint-disable-next-line no-console\n  console.timeStamp(`${deviceType}::ORT::${label}`);\n};\n\nconst TRACE_FUNC = (msg: string, extraMsg?: string) => {\n  const stack = new Error().stack?.split(/\\r\\n|\\r|\\n/g) || [];\n  let hasTraceFunc = false;\n  for (let i = 0; i < stack.length; i++) {\n    if (hasTraceFunc && !stack[i].includes('TRACE_FUNC')) {\n      let label = `FUNC_${msg}::${stack[i].trim().split(' ')[1]}`;\n      if (extraMsg) {\n        label += `::${extraMsg}`;\n      }\n      TRACE('CPU', label);\n      return;\n    }\n    if (stack[i].includes('TRACE_FUNC')) {\n      hasTraceFunc = true;\n    }\n  }\n};\n\n/**\n * @ignore\n */\nexport const TRACE_FUNC_BEGIN = (extraMsg?: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  TRACE_FUNC('BEGIN', extraMsg);\n};\n\n/**\n * @ignore\n */\nexport const TRACE_FUNC_END = (extraMsg?: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  TRACE_FUNC('END', extraMsg);\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {resolveBackendAndExecutionProviders} from './backend-impl.js';\nimport {InferenceSessionHandler} from './backend.js';\nimport {InferenceSession as InferenceSessionInterface} from './inference-session.js';\nimport {OnnxValue} from './onnx-value.js';\nimport {Tensor} from './tensor.js';\nimport {TRACE_FUNC_BEGIN, TRACE_FUNC_END} from './trace.js';\n\ntype SessionOptions = InferenceSessionInterface.SessionOptions;\ntype RunOptions = InferenceSessionInterface.RunOptions;\ntype FeedsType = InferenceSessionInterface.FeedsType;\ntype FetchesType = InferenceSessionInterface.FetchesType;\ntype ReturnType = InferenceSessionInterface.ReturnType;\n\nexport class InferenceSession implements InferenceSessionInterface {\n  private constructor(handler: InferenceSessionHandler) {\n    this.handler = handler;\n  }\n  run(feeds: FeedsType, options?: RunOptions): Promise<ReturnType>;\n  run(feeds: FeedsType, fetches: FetchesType, options?: RunOptions): Promise<ReturnType>;\n  async run(feeds: FeedsType, arg1?: FetchesType|RunOptions, arg2?: RunOptions): Promise<ReturnType> {\n    TRACE_FUNC_BEGIN();\n    const fetches: {[name: string]: OnnxValue|null} = {};\n    let options: RunOptions = {};\n    // check inputs\n    if (typeof feeds !== 'object' || feeds === null || feeds instanceof Tensor || Array.isArray(feeds)) {\n      throw new TypeError(\n          '\\'feeds\\' must be an object that use input names as keys and OnnxValue as corresponding values.');\n    }\n\n    let isFetchesEmpty = true;\n    // determine which override is being used\n    if (typeof arg1 === 'object') {\n      if (arg1 === null) {\n        throw new TypeError('Unexpected argument[1]: cannot be null.');\n      }\n      if (arg1 instanceof Tensor) {\n        throw new TypeError('\\'fetches\\' cannot be a Tensor');\n      }\n\n      if (Array.isArray(arg1)) {\n        if (arg1.length === 0) {\n          throw new TypeError('\\'fetches\\' cannot be an empty array.');\n        }\n        isFetchesEmpty = false;\n        // output names\n        for (const name of arg1) {\n          if (typeof name !== 'string') {\n            throw new TypeError('\\'fetches\\' must be a string array or an object.');\n          }\n          if (this.outputNames.indexOf(name) === -1) {\n            throw new RangeError(`'fetches' contains invalid output name: ${name}.`);\n          }\n          fetches[name] = null;\n        }\n\n        if (typeof arg2 === 'object' && arg2 !== null) {\n          options = arg2;\n        } else if (typeof arg2 !== 'undefined') {\n          throw new TypeError('\\'options\\' must be an object.');\n        }\n      } else {\n        // decide whether arg1 is fetches or options\n        // if any output name is present and its value is valid OnnxValue, we consider it fetches\n        let isFetches = false;\n        const arg1Keys = Object.getOwnPropertyNames(arg1);\n        for (const name of this.outputNames) {\n          if (arg1Keys.indexOf(name) !== -1) {\n            const v = (arg1 as InferenceSessionInterface.NullableOnnxValueMapType)[name];\n            if (v === null || v instanceof Tensor) {\n              isFetches = true;\n              isFetchesEmpty = false;\n              fetches[name] = v;\n            }\n          }\n        }\n\n        if (isFetches) {\n          if (typeof arg2 === 'object' && arg2 !== null) {\n            options = arg2;\n          } else if (typeof arg2 !== 'undefined') {\n            throw new TypeError('\\'options\\' must be an object.');\n          }\n        } else {\n          options = arg1 as RunOptions;\n        }\n      }\n    } else if (typeof arg1 !== 'undefined') {\n      throw new TypeError('Unexpected argument[1]: must be \\'fetches\\' or \\'options\\'.');\n    }\n\n    // check if all inputs are in feed\n    for (const name of this.inputNames) {\n      if (typeof feeds[name] === 'undefined') {\n        throw new Error(`input '${name}' is missing in 'feeds'.`);\n      }\n    }\n\n    // if no fetches is specified, we use the full output names list\n    if (isFetchesEmpty) {\n      for (const name of this.outputNames) {\n        fetches[name] = null;\n      }\n    }\n\n    // feeds, fetches and options are prepared\n\n    const results = await this.handler.run(feeds, fetches, options);\n    const returnValue: {[name: string]: OnnxValue} = {};\n    for (const key in results) {\n      if (Object.hasOwnProperty.call(results, key)) {\n        const result = results[key];\n        if (result instanceof Tensor) {\n          returnValue[key] = result;\n        } else {\n          returnValue[key] = new Tensor(result.type, result.data, result.dims);\n        }\n      }\n    }\n    TRACE_FUNC_END();\n    return returnValue;\n  }\n\n  async release(): Promise<void> {\n    return this.handler.dispose();\n  }\n\n  static create(path: string, options?: SessionOptions): Promise<InferenceSessionInterface>;\n  static create(buffer: ArrayBufferLike, options?: SessionOptions): Promise<InferenceSessionInterface>;\n  static create(buffer: ArrayBufferLike, byteOffset: number, byteLength?: number, options?: SessionOptions):\n      Promise<InferenceSessionInterface>;\n  static create(buffer: Uint8Array, options?: SessionOptions): Promise<InferenceSessionInterface>;\n  static async create(\n      arg0: string|ArrayBufferLike|Uint8Array, arg1?: SessionOptions|number, arg2?: number,\n      arg3?: SessionOptions): Promise<InferenceSessionInterface> {\n    TRACE_FUNC_BEGIN();\n    // either load from a file or buffer\n    let filePathOrUint8Array: string|Uint8Array;\n    let options: SessionOptions = {};\n\n    if (typeof arg0 === 'string') {\n      filePathOrUint8Array = arg0;\n      if (typeof arg1 === 'object' && arg1 !== null) {\n        options = arg1;\n      } else if (typeof arg1 !== 'undefined') {\n        throw new TypeError('\\'options\\' must be an object.');\n      }\n    } else if (arg0 instanceof Uint8Array) {\n      filePathOrUint8Array = arg0;\n      if (typeof arg1 === 'object' && arg1 !== null) {\n        options = arg1;\n      } else if (typeof arg1 !== 'undefined') {\n        throw new TypeError('\\'options\\' must be an object.');\n      }\n    } else if (\n        arg0 instanceof ArrayBuffer ||\n        (typeof SharedArrayBuffer !== 'undefined' && arg0 instanceof SharedArrayBuffer)) {\n      const buffer = arg0;\n      let byteOffset = 0;\n      let byteLength = arg0.byteLength;\n      if (typeof arg1 === 'object' && arg1 !== null) {\n        options = arg1;\n      } else if (typeof arg1 === 'number') {\n        byteOffset = arg1;\n        if (!Number.isSafeInteger(byteOffset)) {\n          throw new RangeError('\\'byteOffset\\' must be an integer.');\n        }\n        if (byteOffset < 0 || byteOffset >= buffer.byteLength) {\n          throw new RangeError(`'byteOffset' is out of range [0, ${buffer.byteLength}).`);\n        }\n        byteLength = arg0.byteLength - byteOffset;\n        if (typeof arg2 === 'number') {\n          byteLength = arg2;\n          if (!Number.isSafeInteger(byteLength)) {\n            throw new RangeError('\\'byteLength\\' must be an integer.');\n          }\n          if (byteLength <= 0 || byteOffset + byteLength > buffer.byteLength) {\n            throw new RangeError(`'byteLength' is out of range (0, ${buffer.byteLength - byteOffset}].`);\n          }\n          if (typeof arg3 === 'object' && arg3 !== null) {\n            options = arg3;\n          } else if (typeof arg3 !== 'undefined') {\n            throw new TypeError('\\'options\\' must be an object.');\n          }\n        } else if (typeof arg2 !== 'undefined') {\n          throw new TypeError('\\'byteLength\\' must be a number.');\n        }\n      } else if (typeof arg1 !== 'undefined') {\n        throw new TypeError('\\'options\\' must be an object.');\n      }\n      filePathOrUint8Array = new Uint8Array(buffer, byteOffset, byteLength);\n    } else {\n      throw new TypeError('Unexpected argument[0]: must be \\'path\\' or \\'buffer\\'.');\n    }\n\n    // resolve backend, update session options with validated EPs, and create session handler\n    const [backend, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);\n    const handler = await backend.createInferenceSessionHandler(filePathOrUint8Array, optionsWithValidatedEPs);\n    TRACE_FUNC_END();\n    return new InferenceSession(handler);\n  }\n\n  startProfiling(): void {\n    this.handler.startProfiling();\n  }\n  endProfiling(): void {\n    this.handler.endProfiling();\n  }\n\n  get inputNames(): readonly string[] {\n    return this.handler.inputNames;\n  }\n  get outputNames(): readonly string[] {\n    return this.handler.outputNames;\n  }\n\n  private handler: InferenceSessionHandler;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {InferenceSession as InferenceSessionImpl} from './inference-session-impl.js';\nimport {OnnxModelOptions} from './onnx-model.js';\nimport {OnnxValue, OnnxValueDataLocation} from './onnx-value.js';\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\nexport declare namespace InferenceSession {\n  // #region input/output types\n\n  type OnnxValueMapType = {readonly [name: string]: OnnxValue};\n  type NullableOnnxValueMapType = {readonly [name: string]: OnnxValue | null};\n\n  /**\n   * A feeds (model inputs) is an object that uses input names as keys and OnnxValue as corresponding values.\n   */\n  type FeedsType = OnnxValueMapType;\n\n  /**\n   * A fetches (model outputs) could be one of the following:\n   *\n   * - Omitted. Use model's output names definition.\n   * - An array of string indicating the output names.\n   * - An object that use output names as keys and OnnxValue or null as corresponding values.\n   *\n   * @remark\n   * different from input argument, in output, OnnxValue is optional. If an OnnxValue is present it will be\n   * used as a pre-allocated value by the inference engine; if omitted, inference engine will allocate buffer\n   * internally.\n   */\n  type FetchesType = readonly string[]|NullableOnnxValueMapType;\n\n  /**\n   * A inferencing return type is an object that uses output names as keys and OnnxValue as corresponding values.\n   */\n  type ReturnType = OnnxValueMapType;\n\n  // #endregion\n\n  // #region session options\n\n  /**\n   * A set of configurations for session behavior.\n   */\n  export interface SessionOptions extends OnnxModelOptions {\n    /**\n     * An array of execution provider options.\n     *\n     * An execution provider option can be a string indicating the name of the execution provider,\n     * or an object of corresponding type.\n     */\n    executionProviders?: readonly ExecutionProviderConfig[];\n\n    /**\n     * The intra OP threads number.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native).\n     */\n    intraOpNumThreads?: number;\n\n    /**\n     * The inter OP threads number.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native).\n     */\n    interOpNumThreads?: number;\n\n    /**\n     * The free dimension override.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    freeDimensionOverrides?: {readonly [dimensionName: string]: number};\n\n    /**\n     * The optimization level.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    graphOptimizationLevel?: 'disabled'|'basic'|'extended'|'all';\n\n    /**\n     * Whether enable CPU memory arena.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    enableCpuMemArena?: boolean;\n\n    /**\n     * Whether enable memory pattern.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    enableMemPattern?: boolean;\n\n    /**\n     * Execution mode.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    executionMode?: 'sequential'|'parallel';\n\n    /**\n     * Optimized model file path.\n     *\n     * If this setting is specified, the optimized model will be dumped. In browser, a blob will be created\n     * with a pop-up window.\n     */\n    optimizedModelFilePath?: string;\n\n    /**\n     * Whether enable profiling.\n     *\n     * This setting is a placeholder for a future use.\n     */\n    enableProfiling?: boolean;\n\n    /**\n     * File prefix for profiling.\n     *\n     * This setting is a placeholder for a future use.\n     */\n    profileFilePrefix?: string;\n\n    /**\n     * Log ID.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    logId?: string;\n\n    /**\n     * Log severity level. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/common/logging/severity.h\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    logSeverityLevel?: 0|1|2|3|4;\n\n    /**\n     * Log verbosity level.\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     */\n    logVerbosityLevel?: number;\n\n    /**\n     * Specify string as a preferred data location for all outputs, or an object that use output names as keys and a\n     * preferred data location as corresponding values.\n     *\n     * This setting is available only in ONNXRuntime Web for WebGL and WebGPU EP.\n     */\n    preferredOutputLocation?: OnnxValueDataLocation|{readonly [outputName: string]: OnnxValueDataLocation};\n\n    /**\n     * Whether enable graph capture.\n     * This setting is available only in ONNXRuntime Web for WebGPU EP.\n     */\n    enableGraphCapture?: boolean;\n\n    /**\n     * Store configurations for a session. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/session/\n     * onnxruntime_session_options_config_keys.h\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     *\n     * @example\n     * ```js\n     * extra: {\n     *   session: {\n     *     set_denormal_as_zero: \"1\",\n     *     disable_prepacking: \"1\"\n     *   },\n     *   optimization: {\n     *     enable_gelu_approximation: \"1\"\n     *   }\n     * }\n     * ```\n     */\n    extra?: Record<string, unknown>;\n  }\n\n  // #region execution providers\n\n  // Currently, we have the following backends to support execution providers:\n  // Backend Node.js binding: supports 'cpu', 'dml' (win32), 'coreml' (macOS) and 'cuda' (linux).\n  // Backend WebAssembly: supports 'cpu', 'wasm', 'webgpu' and 'webnn'.\n  // Backend ONNX.js: supports 'webgl'.\n  // Backend React Native: supports 'cpu', 'xnnpack', 'coreml' (iOS), 'nnapi' (Android).\n  interface ExecutionProviderOptionMap {\n    coreml: CoreMLExecutionProviderOption;\n    cpu: CpuExecutionProviderOption;\n    cuda: CudaExecutionProviderOption;\n    dml: DmlExecutionProviderOption;\n    nnapi: NnapiExecutionProviderOption;\n    tensorrt: TensorRtExecutionProviderOption;\n    wasm: WebAssemblyExecutionProviderOption;\n    webgl: WebGLExecutionProviderOption;\n    webgpu: WebGpuExecutionProviderOption;\n    webnn: WebNNExecutionProviderOption;\n    xnnpack: XnnpackExecutionProviderOption;\n  }\n\n  type ExecutionProviderName = keyof ExecutionProviderOptionMap;\n  type ExecutionProviderConfig =\n      ExecutionProviderOptionMap[ExecutionProviderName]|ExecutionProviderOption|ExecutionProviderName|string;\n\n  export interface ExecutionProviderOption {\n    readonly name: string;\n  }\n  export interface CpuExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'cpu';\n    useArena?: boolean;\n  }\n  export interface CudaExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'cuda';\n    deviceId?: number;\n  }\n  export interface DmlExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'dml';\n    deviceId?: number;\n  }\n  export interface TensorRtExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'tensorrt';\n    deviceId?: number;\n  }\n  export interface WebAssemblyExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'wasm';\n  }\n  export interface WebGLExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'webgl';\n    // TODO: add flags\n  }\n  export interface XnnpackExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'xnnpack';\n  }\n  export interface WebGpuExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'webgpu';\n    preferredLayout?: 'NCHW'|'NHWC';\n  }\n  export interface WebNNExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'webnn';\n    deviceType?: 'cpu'|'gpu'|'npu';\n    numThreads?: number;\n    powerPreference?: 'default'|'low-power'|'high-performance';\n  }\n  export interface CoreMLExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'coreml';\n    /**\n     * The bit flags for CoreML execution provider.\n     *\n     * ```\n     * COREML_FLAG_USE_CPU_ONLY = 0x001\n     * COREML_FLAG_ENABLE_ON_SUBGRAPH = 0x002\n     * COREML_FLAG_ONLY_ENABLE_DEVICE_WITH_ANE = 0x004\n     * COREML_FLAG_ONLY_ALLOW_STATIC_INPUT_SHAPES = 0x008\n     * COREML_FLAG_CREATE_MLPROGRAM = 0x010\n     * ```\n     *\n     * See include/onnxruntime/core/providers/coreml/coreml_provider_factory.h for more details.\n     *\n     * This flag is available only in ONNXRuntime (Node.js binding).\n     */\n    coreMlFlags?: number;\n    /**\n     * Specify whether to use CPU only in CoreML EP.\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    useCPUOnly?: boolean;\n    /**\n     * Specify whether to enable CoreML EP on subgraph.\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    enableOnSubgraph?: boolean;\n    /**\n     * Specify whether to only enable CoreML EP for Apple devices with ANE (Apple Neural Engine).\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    onlyEnableDeviceWithANE?: boolean;\n  }\n  export interface NnapiExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'nnapi';\n    useFP16?: boolean;\n    useNCHW?: boolean;\n    cpuDisabled?: boolean;\n    cpuOnly?: boolean;\n  }\n  // #endregion\n\n  // #endregion\n\n  // #region run options\n\n  /**\n   * A set of configurations for inference run behavior\n   */\n  export interface RunOptions {\n    /**\n     * Log severity level. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/common/logging/severity.h\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    logSeverityLevel?: 0|1|2|3|4;\n\n    /**\n     * Log verbosity level.\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     */\n    logVerbosityLevel?: number;\n\n    /**\n     * Terminate all incomplete OrtRun calls as soon as possible if true\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     */\n    terminate?: boolean;\n\n    /**\n     * A tag for the Run() calls using this\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    tag?: string;\n\n    /**\n     * Set a single run configuration entry. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/session/\n     * onnxruntime_run_options_config_keys.h\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     *\n     * @example\n     *\n     * ```js\n     * extra: {\n     *   memory: {\n     *     enable_memory_arena_shrinkage: \"1\",\n     *   }\n     * }\n     * ```\n     */\n    extra?: Record<string, unknown>;\n  }\n\n  // #endregion\n\n  // #region value metadata\n\n  // eslint-disable-next-line @typescript-eslint/no-empty-interface\n  interface ValueMetadata {\n    // TBD\n  }\n\n  // #endregion\n}\n\n/**\n * Represent a runtime instance of an ONNX model.\n */\nexport interface InferenceSession {\n  // #region run()\n\n  /**\n   * Execute the model asynchronously with the given feeds and options.\n   *\n   * @param feeds - Representation of the model input. See type description of `InferenceSession.InputType` for detail.\n   * @param options - Optional. A set of options that controls the behavior of model inference.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding values.\n   */\n  run(feeds: InferenceSession.FeedsType, options?: InferenceSession.RunOptions): Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Execute the model asynchronously with the given feeds, fetches and options.\n   *\n   * @param feeds - Representation of the model input. See type description of `InferenceSession.InputType` for detail.\n   * @param fetches - Representation of the model output. See type description of `InferenceSession.OutputType` for\n   * detail.\n   * @param options - Optional. A set of options that controls the behavior of model inference.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding values.\n   */\n  run(feeds: InferenceSession.FeedsType, fetches: InferenceSession.FetchesType,\n      options?: InferenceSession.RunOptions): Promise<InferenceSession.ReturnType>;\n\n  // #endregion\n\n  // #region release()\n\n  /**\n   * Release the inference session and the underlying resources.\n   */\n  release(): Promise<void>;\n\n  // #endregion\n\n  // #region profiling\n\n  /**\n   * Start profiling.\n   */\n  startProfiling(): void;\n\n  /**\n   * End profiling.\n   */\n  endProfiling(): void;\n\n  // #endregion\n\n  // #region metadata\n\n  /**\n   * Get input names of the loaded model.\n   */\n  readonly inputNames: readonly string[];\n\n  /**\n   * Get output names of the loaded model.\n   */\n  readonly outputNames: readonly string[];\n\n  // /**\n  //  * Get input metadata of the loaded model.\n  //  */\n  // readonly inputMetadata: ReadonlyArray<Readonly<InferenceSession.ValueMetadata>>;\n\n  // /**\n  //  * Get output metadata of the loaded model.\n  //  */\n  // readonly outputMetadata: ReadonlyArray<Readonly<InferenceSession.ValueMetadata>>;\n\n  // #endregion\n}\n\nexport interface InferenceSessionFactory {\n  // #region create()\n\n  /**\n   * Create a new inference session and load model asynchronously from an ONNX model file.\n   *\n   * @param uri - The URI or file path of the model to load.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(uri: string, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from an array bufer.\n   *\n   * @param buffer - An ArrayBuffer representation of an ONNX model.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(buffer: ArrayBufferLike, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from segment of an array bufer.\n   *\n   * @param buffer - An ArrayBuffer representation of an ONNX model.\n   * @param byteOffset - The beginning of the specified portion of the array buffer.\n   * @param byteLength - The length in bytes of the array buffer.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(buffer: ArrayBufferLike, byteOffset: number, byteLength?: number, options?: InferenceSession.SessionOptions):\n      Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from a Uint8Array.\n   *\n   * @param buffer - A Uint8Array representation of an ONNX model.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(buffer: Uint8Array, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  // #endregion\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const InferenceSession: InferenceSessionFactory = InferenceSessionImpl;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {OptionsFormat, OptionsNormalizationParameters, OptionsTensorLayout} from './tensor-factory.js';\n\nexport interface TensorToDataUrlOptions extends OptionsTensorLayout, OptionsFormat, OptionsNormalizationParameters {}\n\nexport interface TensorToImageDataOptions extends OptionsTensorLayout, OptionsFormat, OptionsNormalizationParameters {}\n\nexport interface ConversionUtils {\n  /**\n   * creates a DataURL instance from tensor\n   *\n   * @param options - An optional object representing options for creating a DataURL instance from the tensor.\n   *\n   * The following default settings will be applied:\n   * - `format`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * @returns a DataURL string representing the image converted from tensor data\n   */\n  toDataURL(options?: TensorToDataUrlOptions): string;\n\n  /**\n   * creates an ImageData instance from tensor\n   *\n   * @param options - An optional object representing options for creating an ImageData instance from the tensor.\n   *\n   * The following default settings will be applied:\n   * - `format`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * @returns an ImageData instance representing the image converted from tensor data\n   */\n  toImageData(options?: TensorToImageDataOptions): ImageData;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Tensor, TypedTensor} from './tensor.js';\n\nexport type ImageFormat = 'RGB'|'RGBA'|'BGR'|'RBG';\nexport type ImageTensorLayout = 'NHWC'|'NCHW';\n\n// the following region contains type definitions for constructing tensor from a specific location.\n\n// #region types for constructing a tensor from a specific location\n\n/**\n * represent common properties of the parameter for constructing a tensor from a specific location.\n */\ninterface CommonConstructorParameters<T> extends Pick<Tensor, 'dims'> {\n  /**\n   * Specify the data type of the tensor.\n   */\n  readonly type: T;\n}\n\n/**\n * represent the parameter for constructing a tensor from a GPU resource.\n */\ninterface GpuResourceConstructorParameters<T extends Tensor.Type> {\n  /**\n   * an optional callback function to download data from GPU to CPU.\n   *\n   * If not provided, the tensor treat the GPU data as external resource.\n   */\n  download?(): Promise<Tensor.DataTypeMap[T]>;\n\n  /**\n   * an optional callback function that will be called when the tensor is disposed.\n   *\n   * If not provided, the tensor treat the GPU data as external resource.\n   */\n  dispose?(): void;\n}\n\n/**\n * represent the parameter for constructing a tensor from a pinned CPU buffer\n */\nexport interface CpuPinnedConstructorParameters<T extends Tensor.CpuPinnedDataTypes = Tensor.CpuPinnedDataTypes> extends\n    CommonConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'cpu-pinned'.\n   */\n  readonly location: 'cpu-pinned';\n  /**\n   * Specify the CPU pinned buffer that holds the tensor data.\n   */\n  readonly data: Tensor.DataTypeMap[T];\n}\n\n/**\n * represent the parameter for constructing a tensor from a WebGL texture\n */\nexport interface TextureConstructorParameters<T extends Tensor.TextureDataTypes = Tensor.TextureDataTypes> extends\n    CommonConstructorParameters<T>, GpuResourceConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'texture'.\n   */\n  readonly location: 'texture';\n  /**\n   * Specify the WebGL texture that holds the tensor data.\n   */\n  readonly texture: Tensor.TextureType;\n}\n\n/**\n * represent the parameter for constructing a tensor from a WebGPU buffer\n */\nexport interface GpuBufferConstructorParameters<T extends Tensor.GpuBufferDataTypes = Tensor.GpuBufferDataTypes> extends\n    CommonConstructorParameters<T>, GpuResourceConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'gpu-buffer'.\n   */\n  readonly location: 'gpu-buffer';\n  /**\n   * Specify the WebGPU buffer that holds the tensor data.\n   */\n  readonly gpuBuffer: Tensor.GpuBufferType;\n}\n\n// #endregion\n\n// the following region contains type definitions of each individual options.\n// the tensor factory functions use a composition of those options as the parameter type.\n\n// #region Options fields\n\nexport interface OptionsFormat {\n  /**\n   * Describes the image format represented in RGBA color space.\n   */\n  format?: ImageFormat;\n}\n\nexport interface OptionsTensorFormat {\n  /**\n   * Describes the image format of the tensor.\n   *\n   * NOTE: this is different from option 'format'. While option 'format' represents the original image, 'tensorFormat'\n   * represents the target format of the tensor. A transpose will be performed if they are different.\n   */\n  tensorFormat?: ImageFormat;\n}\n\nexport interface OptionsTensorDataType {\n  /**\n   * Describes the data type of the tensor.\n   */\n  dataType?: 'float32'|'uint8';\n}\n\nexport interface OptionsTensorLayout {\n  /**\n   * Describes the tensor layout when representing data of one or more image(s).\n   */\n  tensorLayout?: ImageTensorLayout;\n}\n\nexport interface OptionsDimensions {\n  /**\n   * Describes the image height in pixel\n   */\n  height?: number;\n  /**\n   * Describes the image width in pixel\n   */\n  width?: number;\n}\n\nexport interface OptionResizedDimensions {\n  /**\n   * Describes the resized height. If omitted, original height will be used.\n   */\n  resizedHeight?: number;\n  /**\n   * Describes resized width - can be accessed via tensor dimensions as well\n   */\n  resizedWidth?: number;\n}\n\nexport interface OptionsNormalizationParameters {\n  /**\n   * Describes normalization parameters when preprocessing the image as model input.\n   *\n   * Data element are ranged from 0 to 255.\n   */\n  norm?: {\n    /**\n     * The 'bias' value for image normalization.\n     * - If omitted, use default value 0.\n     * - If it's a single number, apply to each channel\n     * - If it's an array of 3 or 4 numbers, apply element-wise. Number of elements need to match the number of channels\n     * for the corresponding image format\n     */\n    bias?: number|[number, number, number]|[number, number, number, number];\n    /**\n     * The 'mean' value for image normalization.\n     * - If omitted, use default value 255.\n     * - If it's a single number, apply to each channel\n     * - If it's an array of 3 or 4 numbers, apply element-wise. Number of elements need to match the number of channels\n     * for the corresponding image format\n     */\n    mean?: number | [number, number, number] | [number, number, number, number];\n  };\n}\n\n// #endregion\n\n// #region Options composition\n\nexport interface TensorFromImageDataOptions extends OptionResizedDimensions, OptionsTensorFormat, OptionsTensorLayout,\n                                                    OptionsTensorDataType, OptionsNormalizationParameters {}\n\nexport interface TensorFromImageElementOptions extends OptionResizedDimensions, OptionsTensorFormat,\n                                                       OptionsTensorLayout, OptionsTensorDataType,\n                                                       OptionsNormalizationParameters {}\n\nexport interface TensorFromUrlOptions extends OptionsDimensions, OptionResizedDimensions, OptionsTensorFormat,\n                                              OptionsTensorLayout, OptionsTensorDataType,\n                                              OptionsNormalizationParameters {}\n\nexport interface TensorFromImageBitmapOptions extends OptionResizedDimensions, OptionsTensorFormat, OptionsTensorLayout,\n                                                      OptionsTensorDataType, OptionsNormalizationParameters {}\n\nexport interface TensorFromTextureOptions<T extends Tensor.TextureDataTypes> extends\n    Required<OptionsDimensions>, OptionsFormat, GpuResourceConstructorParameters<T>/* TODO: add more */ {}\n\nexport interface TensorFromGpuBufferOptions<T extends Tensor.GpuBufferDataTypes> extends\n    Pick<Tensor, 'dims'>, GpuResourceConstructorParameters<T> {\n  /**\n   * Describes the data type of the tensor.\n   */\n  dataType?: T;\n}\n\n// #endregion\n\n/**\n * type TensorFactory defines the factory functions of 'Tensor' to create tensor instances from existing data or\n * resources.\n */\nexport interface TensorFactory {\n  /**\n   * create a tensor from an ImageData object\n   *\n   * @param imageData - the ImageData object to create tensor from\n   * @param options - An optional object representing options for creating tensor from ImageData.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(imageData: ImageData, options?: TensorFromImageDataOptions):\n      Promise<TypedTensor<'float32'>|TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from a HTMLImageElement object\n   *\n   * @param imageElement - the HTMLImageElement object to create tensor from\n   * @param options - An optional object representing options for creating tensor from HTMLImageElement.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(imageElement: HTMLImageElement, options?: TensorFromImageElementOptions):\n      Promise<TypedTensor<'float32'>|TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from URL\n   *\n   * @param urlSource - a string as a URL to the image or a data URL containing the image data.\n   * @param options - An optional object representing options for creating tensor from URL.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(urlSource: string, options?: TensorFromUrlOptions): Promise<TypedTensor<'float32'>|TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from an ImageBitmap object\n   *\n   * @param bitmap - the ImageBitmap object to create tensor from\n   * @param options - An optional object representing options for creating tensor from URL.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(bitmap: ImageBitmap, options: TensorFromImageBitmapOptions):\n      Promise<TypedTensor<'float32'>|TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from a WebGL texture\n   *\n   * @param texture - the WebGLTexture object to create tensor from\n   * @param options - An optional object representing options for creating tensor from WebGL texture.\n   *\n   * The options include following properties:\n   * - `width`: the width of the texture. Required.\n   * - `height`: the height of the texture. Required.\n   * - `format`: the format of the texture. If omitted, assume 'RGBA'.\n   * - `download`: an optional function to download the tensor data from GPU to CPU. If omitted, the GPU data\n   * will not be able to download. Usually, this is provided by a GPU backend for the inference outputs. Users don't\n   * need to provide this function.\n   * - `dispose`: an optional function to dispose the tensor data on GPU. If omitted, the GPU data will not be disposed.\n   * Usually, this is provided by a GPU backend for the inference outputs. Users don't need to provide this function.\n   *\n   * @returns a tensor object\n   */\n  fromTexture<T extends Tensor.TextureDataTypes = 'float32'>(\n      texture: Tensor.TextureType, options: TensorFromTextureOptions<T>): TypedTensor<'float32'>;\n\n  /**\n   * create a tensor from a WebGPU buffer\n   *\n   * @param buffer - the GPUBuffer object to create tensor from\n   * @param options - An optional object representing options for creating tensor from WebGPU buffer.\n   *\n   * The options include following properties:\n   * - `dataType`: the data type of the tensor. If omitted, assume 'float32'.\n   * - `dims`: the dimension of the tensor. Required.\n   * - `download`: an optional function to download the tensor data from GPU to CPU. If omitted, the GPU data\n   * will not be able to download. Usually, this is provided by a GPU backend for the inference outputs. Users don't\n   * need to provide this function.\n   * - `dispose`: an optional function to dispose the tensor data on GPU. If omitted, the GPU data will not be disposed.\n   * Usually, this is provided by a GPU backend for the inference outputs. Users don't need to provide this function.\n   *\n   * @returns a tensor object\n   */\n  fromGpuBuffer<T extends Tensor.GpuBufferDataTypes>(\n      buffer: Tensor.GpuBufferType, options: TensorFromGpuBufferOptions<T>): TypedTensor<T>;\n\n  /**\n   * create a tensor from a pre-allocated buffer. The buffer will be used as a pinned buffer.\n   *\n   * @param type - the tensor element type.\n   * @param buffer - a TypedArray corresponding to the type.\n   * @param dims - specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   *\n   * @returns a tensor object\n   */\n  fromPinnedBuffer<T extends Exclude<Tensor.Type, 'string'>>(\n      type: T, buffer: Tensor.DataTypeMap[T], dims?: readonly number[]): TypedTensor<T>;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/**\n * A string that represents a file's URL or path.\n *\n * Path is vailable only in onnxruntime-node or onnxruntime-web running in Node.js.\n */\nexport type FileUrlOrPath = string;\n\n/**\n * A Blob object that represents a file.\n */\nexport type FileBlob = Blob;\n\n/**\n * A Uint8Array, ArrayBuffer or SharedArrayBuffer object that represents a file content.\n *\n * When it is an ArrayBuffer or SharedArrayBuffer, the whole buffer is assumed to be the file content.\n */\nexport type FileData = Uint8Array|ArrayBufferLike;\n\n/**\n * Represents a file that can be loaded by the ONNX Runtime JavaScript API.\n */\nexport type FileType = FileUrlOrPath|FileBlob|FileData;\n\n/**\n * Represents an external data file.\n */\nexport interface ExternalDataFileDescription {\n  /**\n   * Specify the external data file.\n   */\n  data: FileType;\n  /**\n   * Specify the file path.\n   */\n  path: string;\n}\n\n/**\n * Represents an external data file.\n *\n * When using a string, it should be a file URL or path that in the same directory as the model file.\n */\nexport type ExternalDataFileType = ExternalDataFileDescription|FileUrlOrPath;\n\n/**\n * Options for model loading.\n */\nexport interface OnnxModelOptions {\n  /**\n   * Specifying a list of files that represents the external data.\n   */\n  externalData?: readonly ExternalDataFileType[];\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Tensor} from './tensor.js';\n\nexport type NonTensorType = never;\n\n/**\n * Type OnnxValue Represents both tensors and non-tensors value for model's inputs/outputs.\n *\n * NOTE: currently not support non-tensor\n */\nexport type OnnxValue = Tensor|NonTensorType;\n\n/**\n * Type OnnxValueDataLocation represents the location of the data of an OnnxValue.\n */\nexport type OnnxValueDataLocation = Tensor.DataLocation;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {resolveBackendAndExecutionProviders} from './backend-impl.js';\nimport {SessionHandler, TrainingSessionHandler} from './backend.js';\nimport {InferenceSession as InferenceSession} from './inference-session.js';\nimport {OnnxValue} from './onnx-value.js';\nimport {Tensor} from './tensor.js';\nimport {TrainingSession as TrainingSessionInterface, TrainingSessionCreateOptions} from './training-session.js';\n\ntype SessionOptions = InferenceSession.SessionOptions;\ntype FeedsType = InferenceSession.FeedsType;\ntype FetchesType = InferenceSession.FetchesType;\ntype ReturnType = InferenceSession.ReturnType;\ntype RunOptions = InferenceSession.RunOptions;\n\nconst noBackendErrMsg: string = 'Training backend could not be resolved. ' +\n    'Make sure you\\'re using the correct configuration & WebAssembly files.';\n\nexport class TrainingSession implements TrainingSessionInterface {\n  private constructor(handler: TrainingSessionHandler, hasOptimizerModel: boolean, hasEvalModel: boolean) {\n    this.handler = handler;\n    this.hasOptimizerModel = hasOptimizerModel;\n    this.hasEvalModel = hasEvalModel;\n  }\n  private handler: TrainingSessionHandler;\n  private hasOptimizerModel: boolean;\n  private hasEvalModel: boolean;\n\n  get trainingInputNames(): readonly string[] {\n    return this.handler.inputNames;\n  }\n  get trainingOutputNames(): readonly string[] {\n    return this.handler.outputNames;\n  }\n\n  get evalInputNames(): readonly string[] {\n    if (this.hasEvalModel) {\n      return this.handler.evalInputNames;\n    } else {\n      throw new Error('This training session has no evalModel loaded.');\n    }\n  }\n  get evalOutputNames(): readonly string[] {\n    if (this.hasEvalModel) {\n      return this.handler.evalOutputNames;\n    } else {\n      throw new Error('This training session has no evalModel loaded.');\n    }\n  }\n\n  static async create(trainingOptions: TrainingSessionCreateOptions, sessionOptions?: SessionOptions):\n      Promise<TrainingSession> {\n    const evalModel: string|Uint8Array = trainingOptions.evalModel || '';\n    const optimizerModel: string|Uint8Array = trainingOptions.optimizerModel || '';\n    const options: SessionOptions = sessionOptions || {};\n\n    // resolve backend, update session options with validated EPs, and create session handler\n    const [backend, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);\n    if (backend.createTrainingSessionHandler) {\n      const handler = await backend.createTrainingSessionHandler(\n          trainingOptions.checkpointState, trainingOptions.trainModel, evalModel, optimizerModel,\n          optionsWithValidatedEPs);\n      return new TrainingSession(handler, !!trainingOptions.optimizerModel, !!trainingOptions.evalModel);\n    } else {\n      throw new Error(noBackendErrMsg);\n    }\n  }\n\n  /**\n   * Helper function for runTrainStep and future runStep methods that handles the type-narrowing conversion from\n   * the given parameters to SessionHandler.FetchesType and RunOptions.\n   *\n   * @param inputNames the feeds object is checked that they contain all input names in the provided list of input\n   * names.\n   * @param outputNames the fetches object is checked that their keys match up with valid names in the list of output\n   * names.\n   * @param feeds the required input\n   * @param arg1 narrowed & converted into the SessionHandler.FetchesType or RunOptions object\n   * @param arg2 optional RunOptions object.\n   * @returns\n   */\n  typeNarrowingForRunStep(\n      inputNames: readonly string[], outputNames: readonly string[], feeds: FeedsType, arg1?: FetchesType|RunOptions,\n      arg2?: RunOptions): [SessionHandler.FetchesType, RunOptions] {\n    const fetches: {[name: string]: OnnxValue|null} = {};\n    let options: RunOptions = {};\n    // check inputs\n    if (typeof feeds !== 'object' || feeds === null || feeds instanceof Tensor || Array.isArray(feeds)) {\n      throw new TypeError(\n          '\\'feeds\\' must be an object that use input names as keys and OnnxValue as corresponding values.');\n    }\n\n    let isFetchesEmpty = true;\n    // determine which override is being used\n    if (typeof arg1 === 'object') {\n      if (arg1 === null) {\n        throw new TypeError('Unexpected argument[1]: cannot be null.');\n      }\n      if (arg1 instanceof Tensor) {\n        throw new TypeError('\\'fetches\\' cannot be a Tensor');\n      }\n\n      if (Array.isArray(arg1)) {\n        if (arg1.length === 0) {\n          throw new TypeError('\\'fetches\\' cannot be an empty array.');\n        }\n        isFetchesEmpty = false;\n        // output names\n        for (const name of arg1) {\n          if (typeof name !== 'string') {\n            throw new TypeError('\\'fetches\\' must be a string array or an object.');\n          }\n          if (outputNames.indexOf(name) === -1) {\n            throw new RangeError(`'fetches' contains invalid output name: ${name}.`);\n          }\n          fetches[name] = null;\n        }\n\n        if (typeof arg2 === 'object' && arg2 !== null) {\n          options = arg2;\n        } else if (typeof arg2 !== 'undefined') {\n          throw new TypeError('\\'options\\' must be an object.');\n        }\n      } else {\n        // decide whether arg1 is fetches or options\n        // if any output name is present and its value is valid OnnxValue, we consider it fetches\n        let isFetches = false;\n        const arg1Keys = Object.getOwnPropertyNames(arg1);\n        for (const name of outputNames) {\n          if (arg1Keys.indexOf(name) !== -1) {\n            const v = (arg1 as InferenceSession.NullableOnnxValueMapType)[name];\n            if (v === null || v instanceof Tensor) {\n              isFetches = true;\n              isFetchesEmpty = false;\n              fetches[name] = v;\n            }\n          }\n        }\n\n        if (isFetches) {\n          if (typeof arg2 === 'object' && arg2 !== null) {\n            options = arg2;\n          } else if (typeof arg2 !== 'undefined') {\n            throw new TypeError('\\'options\\' must be an object.');\n          }\n        } else {\n          options = arg1 as RunOptions;\n        }\n      }\n    } else if (typeof arg1 !== 'undefined') {\n      throw new TypeError('Unexpected argument[1]: must be \\'fetches\\' or \\'options\\'.');\n    }\n\n    // check if all inputs are in feed\n    for (const name of inputNames) {\n      if (typeof feeds[name] === 'undefined') {\n        throw new Error(`input '${name}' is missing in 'feeds'.`);\n      }\n    }\n\n    // if no fetches is specified, we use the full output names list\n    if (isFetchesEmpty) {\n      for (const name of outputNames) {\n        fetches[name] = null;\n      }\n    }\n\n    return [fetches, options];\n  }\n\n  /**\n   * Helper method for runTrainStep and any other runStep methods. Takes the ReturnType result from the SessionHandler\n   * and changes it into a map of Tensors.\n   *\n   * @param results\n   * @returns\n   */\n  convertHandlerReturnTypeToMapOfTensors(results: SessionHandler.ReturnType): ReturnType {\n    const returnValue: {[name: string]: OnnxValue} = {};\n    for (const key in results) {\n      if (Object.hasOwnProperty.call(results, key)) {\n        const result = results[key];\n        if (result instanceof Tensor) {\n          returnValue[key] = result;\n        } else {\n          returnValue[key] = new Tensor(result.type, result.data, result.dims);\n        }\n      }\n    }\n    return returnValue;\n  }\n\n  async lazyResetGrad(): Promise<void> {\n    await this.handler.lazyResetGrad();\n  }\n\n  runTrainStep(feeds: FeedsType, options?: RunOptions): Promise<ReturnType>;\n  runTrainStep(feeds: FeedsType, fetches: FetchesType, options?: RunOptions): Promise<ReturnType>;\n  async runTrainStep(feeds: FeedsType, arg1?: FetchesType|RunOptions, arg2?: RunOptions): Promise<ReturnType> {\n    const [fetches, options] =\n        this.typeNarrowingForRunStep(this.trainingInputNames, this.trainingOutputNames, feeds, arg1, arg2);\n    const results = await this.handler.runTrainStep(feeds, fetches, options);\n    return this.convertHandlerReturnTypeToMapOfTensors(results);\n  }\n\n  async runOptimizerStep(options?: InferenceSession.RunOptions|undefined): Promise<void> {\n    if (this.hasOptimizerModel) {\n      await this.handler.runOptimizerStep(options || {});\n    } else {\n      throw new Error('This TrainingSession has no OptimizerModel loaded.');\n    }\n  }\n\n  runEvalStep(feeds: FeedsType, options?: RunOptions|undefined): Promise<ReturnType>;\n  runEvalStep(feeds: FeedsType, fetches: FetchesType, options?: RunOptions|undefined): Promise<ReturnType>;\n  async runEvalStep(feeds: FeedsType, arg1?: FetchesType|RunOptions, arg2?: RunOptions): Promise<ReturnType> {\n    if (this.hasEvalModel) {\n      const [fetches, options] =\n          this.typeNarrowingForRunStep(this.evalInputNames, this.evalOutputNames, feeds, arg1, arg2);\n      const results = await this.handler.runEvalStep(feeds, fetches, options);\n      return this.convertHandlerReturnTypeToMapOfTensors(results);\n    } else {\n      throw new Error('This TrainingSession has no EvalModel loaded.');\n    }\n  }\n\n  async getParametersSize(trainableOnly = true): Promise<number> {\n    return this.handler.getParametersSize(trainableOnly);\n  }\n\n  async loadParametersBuffer(array: Uint8Array, trainableOnly = true): Promise<void> {\n    const paramsSize = await this.getParametersSize(trainableOnly);\n    // checking that the size of the Uint8Array is equivalent to the byte length of a Float32Array of the number\n    // of parameters\n    if (array.length !== 4 * paramsSize) {\n      throw new Error(\n          'Size of the buffer passed into loadParametersBuffer must match the number of parameters in ' +\n          'the model. Please use getParametersSize method to check.');\n    }\n    return this.handler.loadParametersBuffer(array, trainableOnly);\n  }\n\n  async getContiguousParameters(trainableOnly = true): Promise<OnnxValue> {\n    return this.handler.getContiguousParameters(trainableOnly);\n  }\n\n  async release(): Promise<void> {\n    return this.handler.dispose();\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {InferenceSession} from './inference-session.js';\nimport {OnnxValue} from './onnx-value.js';\nimport {TrainingSession as TrainingSessionImpl} from './training-session-impl.js';\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\nexport declare namespace TrainingSession {\n  /**\n   * Either URI file path (string) or Uint8Array containing model or checkpoint information.\n   */\n  type UriOrBuffer = string|Uint8Array;\n}\n\n/**\n * Represent a runtime instance of an ONNX training session,\n * which contains a model that can be trained, and, optionally,\n * an eval and optimizer model.\n */\nexport interface TrainingSession {\n  // #region run()\n\n  /**\n   * Lazily resets the gradients of all trainable parameters to zero. Should happen after the invocation of\n   * runOptimizerStep.\n   */\n  lazyResetGrad(): Promise<void>;\n\n  /**\n   * Run TrainStep asynchronously with the given feeds and options.\n   *\n   * @param feeds - Representation of the model input. See type description of `InferenceSession.InputType` for\n   detail.\n   * @param options - Optional. A set of options that controls the behavior of model training.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding values.\n   */\n  runTrainStep(feeds: InferenceSession.FeedsType, options?: InferenceSession.RunOptions):\n      Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Run a single train step with the given inputs and options.\n   *\n   * @param feeds - Representation of the model input.\n   * @param fetches - Representation of the model output.\n   * detail.\n   * @param options - Optional. A set of options that controls the behavior of model training.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding\n   values.\n   */\n  runTrainStep(\n      feeds: InferenceSession.FeedsType, fetches: InferenceSession.FetchesType,\n      options?: InferenceSession.RunOptions): Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Runs a single optimizer step, which performs weight updates for the trainable parameters using the optimizer model.\n   *\n   * @param options - Optional. A set of options that controls the behavior of model optimizing.\n   */\n  runOptimizerStep(options?: InferenceSession.RunOptions): Promise<void>;\n\n  /**\n   * Run a single eval step with the given inputs and options using the eval model.\n   *\n   * @param feeds - Representation of the model input.\n   * @param options - Optional. A set of options that controls the behavior of model eval step.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding\n   values.\n   */\n  runEvalStep(feeds: InferenceSession.FeedsType, options?: InferenceSession.RunOptions):\n      Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Run a single eval step with the given inputs and options using the eval model.\n   *\n   * @param feeds - Representation of the model input.\n   * @param fetches - Representation of the model output.\n   * detail.\n   * @param options - Optional. A set of options that controls the behavior of model eval step.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding\n   values.\n   */\n  runEvalStep(\n      feeds: InferenceSession.FeedsType, fetches: InferenceSession.FetchesType,\n      options?: InferenceSession.RunOptions): Promise<InferenceSession.ReturnType>;\n\n  // #endregion\n\n  // #region copy parameters\n\n  /**\n   * Retrieves the size of all parameters for the training state. Calculates the total number of primitive (datatype of\n   * the parameters) elements of all the parameters in the training state.\n   *\n   * @param trainableOnly - When set to true, the size is calculated for trainable params only. Default value is true.\n   */\n  getParametersSize(trainableOnly: boolean): Promise<number>;\n\n  /**\n   * Copies parameter values from the given buffer to the training state. Currently, only supporting models with\n   * parameters of type Float32.\n   *\n   * @param buffer - A Uint8Array representation of Float32 parameters.\n   * @param trainableOnly - True if trainable parameters only to be modified, false otherwise. Default value is true.\n   */\n  loadParametersBuffer(buffer: Uint8Array, trainableOnly: boolean): Promise<void>;\n\n  /**\n   * Copies the model parameters to a contiguous buffer. Usually used in the context of Federated Learning.\n   * Currently, only supporting models with parameters of type Float32.\n   *\n   * @param trainableOnly - When set to true, only trainable parameters are copied. Trainable parameters are parameters\n   * for which requires_grad is set to true. Default value is true.\n   * @returns A promise that resolves to a Float32 OnnxValue of the requested parameters.\n   */\n  getContiguousParameters(trainableOnly: boolean): Promise<OnnxValue>;\n  // #endregion\n\n  // #region release()\n\n  /**\n   * Release the inference session and the underlying resources.\n   */\n  release(): Promise<void>;\n  // #endregion\n\n  // #region metadata\n\n  /**\n   * Get input names of the loaded training model.\n   */\n  readonly trainingInputNames: readonly string[];\n\n  /**\n   * Get output names of the loaded training model.\n   */\n  readonly trainingOutputNames: readonly string[];\n\n  /**\n   * Get input names of the loaded eval model. Is an empty array if no eval model is loaded.\n   */\n  readonly evalInputNames: readonly string[];\n\n  /**\n   * Get output names of the loaded eval model. Is an empty array if no eval model is loaded.\n   */\n  readonly evalOutputNames: readonly string[];\n\n  // #endregion\n}\n\n/**\n * Represents the optional parameters that can be passed into the TrainingSessionFactory.\n */\nexport interface TrainingSessionCreateOptions {\n  /**\n   * URI or buffer for a .ckpt file that contains the checkpoint for the training model.\n   */\n  checkpointState: TrainingSession.UriOrBuffer;\n  /**\n   * URI or buffer for the .onnx training file.\n   */\n  trainModel: TrainingSession.UriOrBuffer;\n  /**\n   * Optional. URI or buffer for the .onnx optimizer model file.\n   */\n  optimizerModel?: TrainingSession.UriOrBuffer;\n  /**\n   * Optional. URI or buffer for the .onnx eval model file.\n   */\n  evalModel?: TrainingSession.UriOrBuffer;\n}\n\n/**\n * Defines method overload possibilities for creating a TrainingSession.\n */\nexport interface TrainingSessionFactory {\n  // #region create()\n\n  /**\n   * Creates a new TrainingSession and asynchronously loads any models passed in through trainingOptions\n   *\n   * @param trainingOptions specify models and checkpoints to load into the Training Session\n   * @param sessionOptions specify configuration for training session behavior\n   *\n   * @returns Promise that resolves to a TrainingSession object\n   */\n  create(trainingOptions: TrainingSessionCreateOptions, sessionOptions?: InferenceSession.SessionOptions):\n      Promise<TrainingSession>;\n\n  // #endregion\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const TrainingSession: TrainingSessionFactory = TrainingSessionImpl;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/**\n * # ONNX Runtime JavaScript API\n *\n * ONNX Runtime JavaScript API is a unified API for all JavaScript usages, including the following NPM packages:\n *\n * - [onnxruntime-node](https://www.npmjs.com/package/onnxruntime-node)\n * - [onnxruntime-web](https://www.npmjs.com/package/onnxruntime-web)\n * - [onnxruntime-react-native](https://www.npmjs.com/package/onnxruntime-react-native)\n *\n * See also:\n * - [Get Started](https://onnxruntime.ai/docs/get-started/with-javascript/)\n * - [Inference examples](https://github.com/microsoft/onnxruntime-inference-examples/tree/main/js)\n *\n * @packageDocumentation\n */\n\nexport * from './backend.js';\nexport * from './env.js';\nexport * from './inference-session.js';\nexport * from './tensor.js';\nexport * from './tensor-conversion.js';\nexport * from './tensor-factory.js';\nexport * from './trace.js';\nexport * from './onnx-model.js';\nexport * from './onnx-value.js';\nexport * from './training-session.js';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Env} from 'onnxruntime-common';\n\nimport {logLevelStringToEnum} from '../wasm-common';\n\ntype LogLevel = NonNullable<Env['logLevel']>;\ntype MessageString = string;\ntype MessageFunction = () => string;\ntype Message = MessageString|MessageFunction;\n\nconst logLevelPrefix = ['V', 'I', 'W', 'E', 'F'];\n\nconst doLog = (level: number, message: string): void => {\n  // eslint-disable-next-line no-console\n  console.log(`[${logLevelPrefix[level]},${new Date().toISOString()}]${message}`);\n};\n\nlet configLogLevel: LogLevel|undefined;\nlet debug: boolean|undefined;\n\nexport const configureLogger = ($configLogLevel: LogLevel, $debug: boolean): void => {\n  configLogLevel = $configLogLevel;\n  debug = $debug;\n};\n\n/**\n * A simple logging utility to log messages to the console.\n */\nexport const LOG = (logLevel: LogLevel, msg: Message): void => {\n  const messageLevel = logLevelStringToEnum(logLevel);\n  const configLevel = logLevelStringToEnum(configLogLevel);\n  if (messageLevel >= configLevel) {\n    doLog(messageLevel, typeof msg === 'function' ? msg() : msg);\n  }\n};\n\n/**\n * A simple logging utility to log messages to the console. Only logs when debug is enabled.\n */\nexport const LOG_DEBUG: typeof LOG = (...args: Parameters<typeof LOG>) => {\n  if (debug) {\n    LOG(...args);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Tensor} from 'onnxruntime-common';\n\nimport {tensorTypeToTypedArrayConstructor} from '../wasm-common';\n\nexport const createView = (dataBuffer: ArrayBuffer, type: Tensor.Type): Int32Array|Uint32Array|BigInt64Array|\n    BigUint64Array|Uint8Array|Float32Array|Float64Array|Int8Array|Int16Array|Uint16Array =>\n        new (tensorTypeToTypedArrayConstructor(type))(dataBuffer);\n\n/**\n * a TensorView does not own the data.\n */\nexport interface TensorView {\n  readonly data: number;\n  readonly dataType: number;\n  readonly dims: readonly number[];\n\n  /**\n   * get a Float32Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getFloat32Array(): Float32Array;\n\n  /**\n   * get a BigInt64Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getBigInt64Array(): BigInt64Array;\n\n  /**\n   * get a Int32Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getInt32Array(): Int32Array;\n\n  /**\n   * create a new tensor view with the same data but different dimensions.\n   */\n  reshape(newDims: readonly number[]): TensorView;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../wasm-common';\nimport {TensorView} from '../tensor-view';\n\nimport {ShaderHelper} from './ops/common';\n\nexport type SessionState = 'default'|'capturing'|'replaying';\n\nexport enum GpuDataType {\n  default = 0,\n  upload = 1,\n  profile = 2\n}\nexport type GpuDataId = number;\n\nexport type GpuArchitecture = 'ampere';\nexport type GpuVendor = 'amd'|'intel'|'nvidia';\nexport interface AdapterInfo {\n  isArchitecture: (architecture: GpuArchitecture) => boolean;\n  isVendor: (vendor: GpuVendor) => boolean;\n}\n\nexport interface GpuData {\n  type: GpuDataType;\n  id: GpuDataId;\n  buffer: GPUBuffer;\n}\n\nexport interface TensorInfo {\n  dims: readonly number[];\n  dataType: number;\n}\n\nexport interface ProgramUniform {\n  type: DataType;\n  data: number|readonly number[];\n}\n\nexport type ProgramUniformVariableInfo = [type: DataType, length: number];\n\n/**\n * Represent the dependency of a program on a specific input tensor.\n *\n * - 'none': the shader/uniform does not depend on this input's info\n * - 'type': the shader/uniform depends on data type of this input\n * - 'rank': the shader/uniform depends on data type and the rank of this input\n * - 'dims': the shader/uniform depends on data type and the dims of this input\n * - 'data': the shader/uniform depends on data type, the dims and the data of this input\n */\nexport type ProgramInputTensorInfoDependency = 'none'|'type'|'rank'|'dims'|'data';\n\n/**\n * Represent information about a program's cache for shader.\n */\nexport interface ProgramShaderCacheInfo {\n  /**\n   * an optional string as a cache hint in the artifact cache. If this is not specified, the cache hint will be empty.\n   *\n   * This hint string should only contains initializing-time information, such as the attributes or any information of\n   * initializers. It should NOT contain any runtime information, such as the shape of inputs.\n   */\n  hint?: string;\n\n  /**\n   * an optional list of dependencies of the program on the input tensors. If this is not specified, the program depends\n   * on 'dims' of all inputs.\n   */\n  inputDependencies?: ProgramInputTensorInfoDependency[];\n}\n\n/**\n * Represent information about a program's cache for uniform.\n */\nexport interface ProgramUniformCacheInfo {\n  /**\n   * an optional string as a cache hint in the uniform cache. If this is not specified, the cache hint will be empty.\n   *\n   * This hint string should only contains runtime information, such as the shape of inputs.\n   */\n  hint?: string;\n\n  /**\n   * an optional list of dependencies of the program on the input tensors. If this is not specified, the program depends\n   * on 'none' of all inputs.\n   */\n  inputDependencies?: ProgramInputTensorInfoDependency[];\n}\n\n\n/**\n * A set of data that represent a shader program\n */\nexport interface ProgramInfo {\n  /**\n   * the name of the program. used for debugging and profiling\n   */\n  name: string;\n\n  /**\n   * an optional object describing the cache information of the program shader.\n   *\n   * If this is not specified, assume hint is empty and inputDependencies are ['dims'] for all inputs.\n   */\n  shaderCache?: ProgramShaderCacheInfo;\n\n  /**\n   * the shader's processing source code.\n   *\n   * This function will be called when shader cache missed.\n   */\n  getShaderSource: (shaderHelper: ShaderHelper) => string;\n\n  /**\n   * A function to get run data required to run the program.\n   *\n   * This function will be called every time the program is executed. Should keep this function as simple as possible.\n   */\n  getRunData: (inputs: readonly TensorView[]) => {\n    outputs: readonly TensorInfo[];\n    dispatchGroup: {x: number; y?: number; z?: number};\n    programUniforms?: readonly ProgramUniform[];\n  };\n}\n\nexport interface Artifact {\n  programInfo: ProgramInfo;\n  computePipeline: GPUComputePipeline;\n  uniformVariablesInfo: readonly ProgramUniformVariableInfo[]|undefined;\n}\n\nexport interface ComputeContextInputsOutputsMapping {\n  /**\n   * specify the mapping to the program's inputs. the value can be a number or a tensor view.\n   * - if it's a number, it's the index of the kernel's input\n   * - if it's a tensor view, it's an existing tensor view that will be used as the input\n   *\n   * if inputs is not specified, the mapping will be the kernel's inputs in order.\n   */\n  readonly inputs?: ReadonlyArray<TensorView|number>;\n  /**\n   * specify the mapping to the program's outputs. the value must be a number.\n   * - if it's a non-negative number, it's the index of the kernel's output\n   * - if it's -1, it's an output that will be created as a temporary value. this value will be released after\n   * the kernel is executed.\n   * - if it's -2, it's an output that will be created as a persistent value. this value will be released when the\n   * kernel is released.\n   *\n   * if outputs is not specified, the mapping will be the kernel's outputs in order.\n   */\n  readonly outputs?: readonly number[];\n}\n\n/**\n * A ComputeContext instance carries the states that representing the current running of a kernel.\n */\nexport interface ComputeContext {\n  /**\n   * gpu adapter info\n   */\n  readonly adapterInfo: AdapterInfo;\n\n  /**\n   * stores the pointer to OpKernelContext\n   */\n  readonly opKernelContext: number;\n\n  /**\n   * a list of inputs, each input is an instance of TensorView\n   */\n  readonly inputs: readonly TensorView[];\n\n  /**\n   * a custom data object that can be used to store any data that is needed by the kernel\n   */\n  readonly kernelCustomData: {[key: string]: unknown};\n\n  /**\n   * a buffer that can be used to access custom data created each time the kernel is executed\n   */\n  readonly customDataBuffer: Uint8Array;\n\n  /**\n   * a number of outputs for the node\n   */\n  readonly outputCount: number;\n\n  compute(program: ProgramInfo, inputsOutputsMapping?: ComputeContextInputsOutputsMapping): TensorView[];\n  output(index: number, dims: readonly number[]): number;\n  getMaxComputeWorkgroupSizes(): [number, number, number];\n  getMaxComputeWorkgroupStoragesize(): number;\n}\n\nexport type TimestampQuery = 'none'|'inside-passes'|'at-passes';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {WebGpuBackend} from '../backend-webgpu';\nimport {LOG_DEBUG} from '../log';\n\nimport {GpuData, GpuDataId, GpuDataType} from './types';\n\n/**\n * manages GpuDataId -> GpuBuffer\n */\nexport interface GpuDataManager {\n  /**\n   * copy data from CPU to GPU.\n   */\n  upload(id: GpuDataId, data: Uint8Array): void;\n  /**\n   * copy data from GPU to GPU.\n   */\n  memcpy(sourceId: GpuDataId, destinationId: GpuDataId): void;\n  /**\n   * create new data on GPU.\n   */\n  create(size: number, usage?: number): GpuData;\n  /**\n   * get GPU data by ID.\n   */\n  get(id: GpuDataId): GpuData|undefined;\n  /**\n   * release the data on GPU by ID.\n   *\n   * @return size of the data released\n   */\n  release(id: GpuDataId): number;\n  /**\n   * copy data from GPU to CPU.\n   */\n  download(id: GpuDataId, getTargetBuffer: () => Uint8Array): Promise<void>;\n\n  /**\n   * refresh the buffers that marked for release.\n   *\n   * when release() is called, the buffer is not released immediately. this is because we need to wait for the commands\n   * to be submitted to the GPU. this function is called after the commands are submitted so that the buffers can be\n   * actually released.\n   */\n  refreshPendingBuffers(): void;\n\n  /**\n   * register an external buffer for IO Binding. If the buffer is already registered, return the existing GPU data ID.\n   *\n   * GPU data manager only manages a mapping between the buffer and the GPU data ID. It will not manage the lifecycle of\n   * the external buffer.\n   */\n  registerExternalBuffer(buffer: GPUBuffer, originalSize: number, previousBuffer?: GPUBuffer): number;\n\n  /**\n   * unregister an external buffer for IO Binding.\n   */\n  unregisterExternalBuffer(buffer: GPUBuffer): void;\n\n  /**\n   * destroy all gpu buffers.\n   */\n  dispose(): void;\n\n  /**\n   * release session related data.\n   * @param sessionId - specify the session ID.\n   */\n  onReleaseSession(sessionId: number): void;\n}\n\ninterface StorageCacheValue {\n  gpuData: GpuData;\n  originalSize: number;\n}\n\nconst bucketFreelist: Map<number, number> = new Map([\n  [64, 250],\n  [128, 200],\n  [256, 200],\n  [512, 200],\n  [2048, 230],\n  [4096, 200],\n  [8192, 50],\n  [16384, 50],\n  [32768, 50],\n  [65536, 50],\n  [131072, 50],\n  [262144, 50],\n  [524288, 50],\n  [1048576, 50],\n  [2097152, 30],\n  [4194304, 20],\n  [8388608, 10],\n  [12582912, 10],\n  [16777216, 10],\n  [26214400, 15],\n  [33554432, 22],\n  [44236800, 2],\n  [58982400, 6],\n  // we don't want to cache the bucket sizes below but not caching them\n  // results in some major performance hits for models like sd-turbo.\n  [67108864, 6],\n  [134217728, 6],\n  [167772160, 6],\n]);\n\nconst bucketArr: number[] = [];\n\n/**\n * normalize the buffer size so that it fits the 128-bits (16 bytes) alignment.\n */\nconst calcNormalizedBufferSize = (size: number) => Math.ceil(size / 16) * 16;\n\n/**\n * calculate the buffer size so that it fits into buckets.\n */\nconst calcBucketBufferSize = (size: number) => {\n  for (let idx = 0; idx < bucketArr.length; idx++) {\n    const sizeForBucket = bucketArr[idx];\n    if (size <= sizeForBucket) {\n      return sizeForBucket;\n    }\n  }\n  // not in bucket list -> caller will not cache, round up to 16.\n  return Math.ceil(size / 16) * 16;\n};\n\nlet guid = 1;\nconst createNewGpuDataId = () => guid++;\n\n/**\n * exported standard download function. This function is used by the session to download the data from GPU, and also by\n * factory to create GPU tensors with the capacity of downloading data from GPU.\n *\n * @param backend - the WebGPU backend\n * @param gpuBuffer - the GPU buffer to download\n * @param originalSize - the original size of the data\n * @param getTargetBuffer - optional. If provided, the data will be copied to the target buffer. Otherwise, a new buffer\n * will be created and returned.\n */\nexport const downloadGpuData =\n    async(backend: WebGpuBackend, gpuBuffer: GPUBuffer, originalSize: number, getTargetBuffer?: () => Uint8Array):\n        Promise<Uint8Array> => {\n          const bufferSize = calcNormalizedBufferSize(originalSize);\n          const gpuReadBuffer = backend.device.createBuffer(\n              // eslint-disable-next-line no-bitwise\n              {size: bufferSize, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});\n          try {\n            const commandEncoder = backend.getCommandEncoder();\n            backend.endComputePass();\n            commandEncoder.copyBufferToBuffer(\n                gpuBuffer /* source buffer */, 0 /* source offset */, gpuReadBuffer /* destination buffer */,\n                0 /* destination offset */, bufferSize /* size */\n            );\n            backend.flush();\n\n            await gpuReadBuffer.mapAsync(GPUMapMode.READ);\n\n            const arrayBuffer = gpuReadBuffer.getMappedRange();\n            if (getTargetBuffer) {\n              // if we already have a CPU buffer to accept the data, no need to clone the ArrayBuffer.\n              const targetBuffer = getTargetBuffer();\n              targetBuffer.set(new Uint8Array(arrayBuffer, 0, originalSize));\n              return targetBuffer;\n            } else {\n              // the mapped ArrayBuffer will be released when the GPU buffer is destroyed. Need to clone the\n              // ArrayBuffer.\n              return new Uint8Array(arrayBuffer.slice(0, originalSize));\n            }\n          } finally {\n            gpuReadBuffer.destroy();\n          }\n        };\n\nclass GpuDataManagerImpl implements GpuDataManager {\n  // GPU Data ID => GPU Data ( storage buffer )\n  private storageCache: Map<GpuDataId, StorageCacheValue>;\n\n  // pending buffers for uploading ( data is unmapped )\n  private buffersForUploadingPending: GPUBuffer[];\n  // pending buffers for computing\n  private buffersPending: GPUBuffer[];\n\n  // The reusable storage buffers for computing.\n  private freeBuffers: Map<number, GPUBuffer[]>;\n  // The reusable uniform buffers\n  private freeUniformBuffers: Map<number, GPUBuffer[]>;\n\n  // The external buffers registered users for IO Binding.\n  private externalBuffers: Map<GPUBuffer, GpuDataId>;\n\n  // The pendingBuffers for capture graph.\n  // a SessionID -> GPUBuffer[] mapping.\n  private capturedPendingBuffers: Map<number, GPUBuffer[]>;\n\n  constructor(private backend: WebGpuBackend) {\n    this.storageCache = new Map();\n    this.freeBuffers = new Map();\n    this.freeUniformBuffers = new Map();\n    this.buffersForUploadingPending = [];\n    this.buffersPending = [];\n    this.externalBuffers = new Map();\n    this.capturedPendingBuffers = new Map();\n\n    for (const [key, ] of bucketFreelist) {\n      bucketArr.push(key);\n      this.freeBuffers.set(key, []);\n      this.freeUniformBuffers.set(key, []);\n    }\n  }\n\n  upload(id: GpuDataId, data: Uint8Array): void {\n    const srcArrayBuffer = data.buffer;\n    const srcOffset = data.byteOffset;\n    const srcLength = data.byteLength;\n    const size = calcNormalizedBufferSize(srcLength);\n\n    // get destination gpu buffer\n    const gpuDataCache = this.storageCache.get(id);\n    if (!gpuDataCache) {\n      throw new Error('gpu data for uploading does not exist');\n    }\n    if (gpuDataCache.originalSize !== srcLength) {\n      throw new Error(`inconsistent data size. gpu data size=${gpuDataCache.originalSize}, data size=${srcLength}`);\n    }\n\n    // create gpu buffer\n    const gpuBufferForUploading = this.backend.device.createBuffer(\n        // eslint-disable-next-line no-bitwise\n        {mappedAtCreation: true, size, usage: GPUBufferUsage.MAP_WRITE | GPUBufferUsage.COPY_SRC});\n\n    // copy (upload) data\n    const arrayBuffer = gpuBufferForUploading.getMappedRange();\n    new Uint8Array(arrayBuffer).set(new Uint8Array(srcArrayBuffer, srcOffset, srcLength));\n    gpuBufferForUploading.unmap();\n\n\n    // GPU copy\n    const commandEncoder = this.backend.getCommandEncoder();\n    this.backend.endComputePass();\n    commandEncoder.copyBufferToBuffer(gpuBufferForUploading, 0, gpuDataCache.gpuData.buffer, 0, size);\n\n    LOG_DEBUG('verbose', () => `[WebGPU] GpuDataManager.upload(id=${id})`);\n\n    this.buffersForUploadingPending.push(gpuBufferForUploading);\n  }\n\n  memcpy(sourceId: GpuDataId, destinationId: GpuDataId): void {\n    // get source gpu buffer\n    const sourceGpuDataCache = this.storageCache.get(sourceId);\n    if (!sourceGpuDataCache) {\n      throw new Error('source gpu data for memcpy does not exist');\n    }\n    // get destination gpu buffer\n    const destinationGpuDataCache = this.storageCache.get(destinationId);\n    if (!destinationGpuDataCache) {\n      throw new Error('destination gpu data for memcpy does not exist');\n    }\n    if (sourceGpuDataCache.originalSize !== destinationGpuDataCache.originalSize) {\n      throw new Error('inconsistent source and destination gpu data size');\n    }\n\n    const size = calcNormalizedBufferSize(sourceGpuDataCache.originalSize);\n\n    // GPU copy\n    const commandEncoder = this.backend.getCommandEncoder();\n    this.backend.endComputePass();\n    commandEncoder.copyBufferToBuffer(\n        sourceGpuDataCache.gpuData.buffer, 0, destinationGpuDataCache.gpuData.buffer, 0, size);\n  }\n\n  registerExternalBuffer(buffer: GPUBuffer, originalSize: number, previousBuffer?: GPUBuffer): number {\n    let id: number|undefined;\n    if (previousBuffer) {\n      id = this.externalBuffers.get(previousBuffer);\n      if (id === undefined) {\n        throw new Error('previous buffer is not registered');\n      }\n      if (buffer === previousBuffer) {\n        LOG_DEBUG(\n            'verbose',\n            () => `[WebGPU] GpuDataManager.registerExternalBuffer(size=${originalSize}) => id=${\n                id}, buffer is the same, skip.`);\n        return id;\n      } else if (this.backend.capturedCommandList.has(this.backend.currentSessionId!)) {\n        throw new Error(`Registering a different external buffer under graph capture mode is not supported yet.\n             Please use the previous external buffer!`);\n      }\n      this.externalBuffers.delete(previousBuffer);\n    } else {\n      id = createNewGpuDataId();\n    }\n\n    this.storageCache.set(id, {gpuData: {id, type: GpuDataType.default, buffer}, originalSize});\n    this.externalBuffers.set(buffer, id);\n    LOG_DEBUG(\n        'verbose',\n        () => `[WebGPU] GpuDataManager.registerExternalBuffer(size=${originalSize}) => id=${id}, registered.`);\n    return id;\n  }\n\n  unregisterExternalBuffer(buffer: GPUBuffer): void {\n    const id = this.externalBuffers.get(buffer);\n    if (id !== undefined) {\n      this.storageCache.delete(id);\n      this.externalBuffers.delete(buffer);\n      LOG_DEBUG('verbose', () => `[WebGPU] GpuDataManager.unregisterExternalBuffer() => id=${id}`);\n    }\n  }\n\n  // eslint-disable-next-line no-bitwise\n  create(size: number, usage = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST): GpuData {\n    const bufferSize = calcBucketBufferSize(size);\n\n    let gpuBuffer;\n    // Currently, only storage buffers are reused.\n    // eslint-disable-next-line no-bitwise\n    const isStorage = (usage & GPUBufferUsage.STORAGE) === GPUBufferUsage.STORAGE;\n    // eslint-disable-next-line no-bitwise\n    const isUniform = (usage & GPUBufferUsage.UNIFORM) === GPUBufferUsage.UNIFORM;\n    if (isStorage || isUniform) {\n      const freeBuffers = isStorage ? this.freeBuffers : this.freeUniformBuffers;\n      const buffers = freeBuffers.get(bufferSize);\n      if (!buffers) {\n        // no such bucket/freelist - create gpu buffer\n        gpuBuffer = this.backend.device.createBuffer({size: bufferSize, usage});\n      } else {\n        if (buffers.length > 0) {\n          // in freelist, use it\n          gpuBuffer = buffers.pop() as GPUBuffer;\n        } else {\n          // bucket empty, create gpu buffer\n          gpuBuffer = this.backend.device.createBuffer({size: bufferSize, usage});\n        }\n      }\n    } else {\n      // create gpu buffer\n      gpuBuffer = this.backend.device.createBuffer({size: bufferSize, usage});\n    }\n\n    const gpuData = {id: createNewGpuDataId(), type: GpuDataType.default, buffer: gpuBuffer};\n    this.storageCache.set(gpuData.id, {gpuData, originalSize: size});\n\n    LOG_DEBUG('verbose', () => `[WebGPU] GpuDataManager.create(size=${size}) => id=${gpuData.id}`);\n    return gpuData;\n  }\n\n  get(id: GpuDataId): GpuData|undefined {\n    return this.storageCache.get(id)?.gpuData;\n  }\n\n  release(id: GpuDataId): number {\n    const cachedData = this.storageCache.get(id);\n    if (!cachedData) {\n      throw new Error('releasing data does not exist');\n    }\n\n    LOG_DEBUG('verbose', () => `[WebGPU] GpuDataManager.release(id=${id}), gpuDataId=${cachedData.gpuData.id}`);\n\n    this.storageCache.delete(id);\n    this.buffersPending.push(cachedData.gpuData.buffer);\n    // cachedData.gpuData.buffer.destroy();\n\n    return cachedData.originalSize;\n  }\n\n  async download(id: GpuDataId, getTargetBuffer: () => Uint8Array): Promise<void> {\n    const cachedData = this.storageCache.get(id);\n    if (!cachedData) {\n      throw new Error('data does not exist');\n    }\n    await downloadGpuData(this.backend, cachedData.gpuData.buffer, cachedData.originalSize, getTargetBuffer);\n  }\n\n  refreshPendingBuffers(): void {\n    for (const buffer of this.buffersForUploadingPending) {\n      // upload buffer is only useful in the session creation time. So we don't need to reuse them in session running.\n      buffer.destroy();\n    }\n    this.buffersForUploadingPending = [];\n\n    if (this.buffersPending.length === 0) {\n      return;\n    }\n\n    if (this.backend.sessionStatus === 'default') {\n      for (const buffer of this.buffersPending) {\n        const maxInFreeList = bucketFreelist.get(buffer.size);\n\n        // eslint-disable-next-line no-bitwise\n        if ((buffer.usage & GPUBufferUsage.STORAGE) === GPUBufferUsage.STORAGE) {\n          // Put the pending buffer to freeBuffers list instead of really destroying it for buffer reusing.\n          const freelist = this.freeBuffers.get(buffer.size) || [];\n          if (maxInFreeList === undefined || freelist.length >= maxInFreeList) {\n            buffer.destroy();\n          } else {\n            freelist.push(buffer);\n          }\n          // eslint-disable-next-line no-bitwise\n        } else if ((buffer.usage & GPUBufferUsage.UNIFORM) === GPUBufferUsage.UNIFORM) {\n          // Put the pending buffer to freeUniformBuffers list instead of really destroying it for buffer reusing.\n          const freelist = this.freeUniformBuffers.get(buffer.size) || [];\n          if (maxInFreeList === undefined || freelist.length >= maxInFreeList) {\n            buffer.destroy();\n          } else {\n            freelist.push(buffer);\n          }\n        } else {\n          buffer.destroy();\n        }\n      }\n      this.buffersPending = [];\n    } else {\n      // Don't release intermediate tensors in non-default mode.\n      // TODO: reuse the storage buffers in non-default mode.\n      let capturedBuffers = this.capturedPendingBuffers.get(this.backend.currentSessionId!);\n      if (!capturedBuffers) {\n        capturedBuffers = [];\n        this.capturedPendingBuffers.set(this.backend.currentSessionId!, capturedBuffers);\n      }\n      for (const buffer of this.buffersPending) {\n        capturedBuffers.push(buffer);\n      }\n      this.buffersPending = [];\n    }\n  }\n\n  dispose() {\n    this.freeBuffers.forEach((buffers) => {\n      buffers.forEach(buffer => {\n        buffer.destroy();\n      });\n    });\n    this.freeUniformBuffers.forEach((buffers) => {\n      buffers.forEach(buffer => {\n        buffer.destroy();\n      });\n    });\n\n    this.storageCache.forEach((storage) => {\n      storage.gpuData.buffer.destroy();\n    });\n\n    this.capturedPendingBuffers.forEach((buffers) => {\n      buffers.forEach(buffer => {\n        buffer.destroy();\n      });\n    });\n    this.storageCache = new Map();\n    this.freeBuffers = new Map();\n    this.freeUniformBuffers = new Map();\n    this.capturedPendingBuffers = new Map();\n  }\n\n  onReleaseSession(sessionId: number) {\n    // release the captured pending buffers.\n    const pendingBuffers = this.capturedPendingBuffers.get(sessionId);\n    if (pendingBuffers) {\n      pendingBuffers.forEach(buffer => {\n        buffer.destroy();\n      });\n      this.capturedPendingBuffers.delete(sessionId);\n    }\n  }\n}\n\nexport const createGpuDataManager = (...args: ConstructorParameters<typeof GpuDataManagerImpl>): GpuDataManager =>\n    new GpuDataManagerImpl(...args);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nclass AttributeWithCacheKeyImpl {\n  constructor(attribute: Record<string, unknown>) {\n    Object.assign(this, attribute);\n  }\n\n  private key: string;\n  public get cacheKey(): string {\n    if (!this.key) {\n      this.key =\n          Object.getOwnPropertyNames(this).sort().map(name => `${(this as Record<string, unknown>)[name]}`).join(';');\n    }\n    return this.key;\n  }\n}\n\nexport interface AttributeWithCacheKey {\n  readonly cacheKey: string;\n}\n\n/**\n * create a new object from the given attribute, and add a cacheKey property to it\n */\nexport const createAttributeWithCacheKey = <T extends Record<string, unknown>>(attribute: T): T&AttributeWithCacheKey =>\n    new AttributeWithCacheKeyImpl(attribute) as unknown as T & AttributeWithCacheKey;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/* eslint-disable no-param-reassign */\n\nexport class MatMulUtil {\n  /**\n   * Calculate the expected shape when matrix multiplication\n   * @param a The shape of tensor A. Should be a tuple of 2 positive integers\n   * @param b The shape of tensor B. Should be a tuple of 2 positive integers\n   * @returns The expected shape of the result, or undefined if N/A\n   */\n  static calcMatMulShape(a: [number, number], b: [number, number]): [number, number]|undefined {\n    return (a[1] !== b[0]) ? undefined : [a[0], b[1]];\n  }\n}\n\n\nexport class BroadcastUtil {\n  /**\n   * Calculate the expected shape when broadcasting 2 tensors\n   * @param a The shape of tensor A. Should be an array of positive integers\n   * @param b The shape of tensor B. Should be an array of positive integers\n   * @param isMatMul Whether the operation is MatMul\n   * @returns The expected shape of the result, or undefined if N/A\n   */\n  static calcShape(adims: readonly number[], bdims: readonly number[], isMatMul = false): readonly number[]|undefined {\n    const arank = adims.length;\n    const brank = bdims.length;\n    if (arank === 0) {\n      return bdims;\n    }\n    if (brank === 0) {\n      return adims;\n    }\n    const crank = Math.max(adims.length, bdims.length);\n    const cdims = new Array<number>(crank);\n\n    // calculate the last 2 dimension if it is MatMul\n    if (isMatMul) {\n      if (arank < 2 || brank < 2) {\n        return undefined;\n      }\n      const cShapeMatMul =\n          MatMulUtil.calcMatMulShape([adims[arank - 2], adims[arank - 1]], [bdims[brank - 2], bdims[brank - 1]]);\n      if (cShapeMatMul === undefined) {\n        return undefined;\n      }\n      [cdims[crank - 2], cdims[crank - 1]] = cShapeMatMul;\n    }\n\n    for (let i = isMatMul ? 3 : 1; i <= crank; i++) {\n      const aLen = arank - i < 0 ? 1 : adims[arank - i];\n      const bLen = brank - i < 0 ? 1 : bdims[brank - i];\n\n      if (aLen !== bLen && aLen > 1 && bLen > 1) {\n        return undefined;\n      }\n      const max = Math.max(aLen, bLen);\n      if (aLen && bLen) {\n        cdims[crank - i] = Math.max(aLen, bLen);\n      } else {\n        // when either aLen or bLen is 0, the other should be either 0 or 1, otherwise it is not broadcastable.\n        if (max > 1) {\n          return undefined;\n        }\n        cdims[crank - i] = 0;\n      }\n    }\n\n    return cdims;\n  }\n\n  /**\n   * Determine if a shape is unidirectional broadcastable to another shape\n   * @param shape The input shape\n   * @param finalShape The desired shape after broadcasting\n   */\n  static isValidBroadcast(shape: readonly number[], finalShape: readonly number[]): boolean {\n    // align shape to the right\n    const inputRank = shape.length;\n    const finalRank = finalShape.length;\n    if (inputRank > finalRank) {\n      return false;\n    }\n    for (let i = 1; i <= inputRank; i++) {\n      if (shape[inputRank - i] !== 1 && shape[inputRank - i] !== finalShape[finalRank - i]) {\n        return false;\n      }\n    }\n    return true;\n  }\n}\n\n\nexport class ShapeUtil {\n  /**\n   * calculate the size (number of elements)\n   */\n  static size(dims: readonly number[]): number {\n    return ShapeUtil.getSizeFromDimensionRange(dims, 0, dims.length);\n  }\n\n  /**\n   * convert dims corresponding to type change to pack. ex. uint8 data to uint32\n   */\n  static convertShape(dims: readonly number[], size = 4): readonly number[] {\n    const rank = dims.length;\n    if (rank === 0) {\n      return [];\n    }\n    const newDims = new Array(rank);\n    let i = rank - 1;\n    while (i >= 0) {\n      if (dims[i] % size === 0) {\n        newDims[i] = dims[i] / size;\n        break;\n      }\n      if (size % dims[i] !== 0) {\n        throw new Error('cannot convert shape');\n      }\n      newDims[i] = 1;\n      size /= dims[i];\n      i--;\n    }\n    for (i--; i >= 0; i--) {\n      newDims[i] = dims[i];\n    }\n    return newDims;\n  }\n\n  /**\n   * calculate the size (number of elements) from the given axis (inclusive)\n   */\n  static sizeFromDimension(dims: readonly number[], axis: number): number {\n    if (axis < 0 || axis > dims.length) {\n      throw new Error(`invalid dimension of ${axis} for sizeFromDimension as Tensor has ${dims.length} dimensions.`);\n    }\n    return ShapeUtil.getSizeFromDimensionRange(dims, axis, dims.length);\n  }\n\n  /**\n   * calculate the size (number of elements) to the given axis (exclusive)\n   */\n  static sizeToDimension(dims: readonly number[], axis: number): number {\n    if (axis < 0 || axis > dims.length) {\n      throw new Error(`invalid dimension of ${axis} for sizeToDimension as Tensor has ${dims.length} dimensions.`);\n    }\n    return ShapeUtil.getSizeFromDimensionRange(dims, 0, axis);\n  }\n\n  /**\n   * calculate the size (number of elements) from and to the given axis [start, end)\n   */\n  static getSizeFromDimensionRange(dims: readonly number[], start: number, end: number): number {\n    let size = 1;\n    for (let i = start; i < end; i++) {\n      // safety check as this method is called by multiple other methods requiring size.\n      // size cannot be negative.\n      if (dims[i] < 0) {\n        throw new Error(\n            // eslint-disable-next-line max-len\n            'cannot get valid size from specified dimension range. Most likely the range contains negative values in them.');\n      }\n      size *= dims[i];\n    }\n    return size;\n  }\n\n  static computeStrides(dims: readonly number[]): readonly number[] {\n    const rank = dims.length;\n    if (rank === 0) {\n      return [];\n    } else if (rank === 1) {\n      return [1];\n    }\n    const strides = new Array(rank);\n    strides[rank - 1] = 1;\n    strides[rank - 2] = dims[rank - 1];\n    for (let i = rank - 3; i >= 0; --i) {\n      strides[i] = strides[i + 1] * dims[i + 1];\n    }\n    return strides;\n  }\n\n  /**\n   * normailze axis of range [-r, r) into [0, r).\n   */\n  static normalizeAxis(axis: number, tensorRank: number): number {\n    if (axis < -tensorRank && axis >= tensorRank) {\n      throw new Error('unsupported axis for this operation.');\n    }\n    return axis < 0 ? axis + tensorRank : axis;\n  }\n\n  static normalizeAxes(axes: readonly number[], tensorRank?: number): number[] {\n    return axes.map(x => this.normalizeAxis(x, tensorRank ?? axes.length));\n  }\n\n  /**\n   * Sorts a given array based on the indices in the Perm array\n   * Used in Transpose\n   * @param a Array to be sorted such as dims or strides\n   * @param perm Perm given; if null a will be reversed\n   */\n  static sortBasedOnPerm(a: readonly number[], perm?: readonly number[]): readonly number[] {\n    if (perm) {\n      return perm.map((v) => a[v]);\n    } else {\n      return a.slice().reverse();\n    }\n  }\n\n  /**\n   * Pads a given shape according to the padding values\n   * @param dims shape of the Tensor to be padded\n   * @param pad pad values\n   */\n  static padShape(dims: readonly number[], pad: readonly number[]): readonly number[] {\n    const rank = dims.length;\n    return dims.map((v, i) => v + pad[i] + pad[i + rank]);\n  }\n\n  /**\n   * Determines if the two shapes are identical\n   * @param shape1\n   * @param shape2\n   */\n  static areEqual(shape1: readonly number[], shape2: readonly number[]): boolean {\n    if (shape1.length !== shape2.length) {\n      return false;\n    }\n    return shape1.every((v, i) => v === shape2[i]);\n  }\n}\n\nexport class PoolConvUtil {\n  /**\n   * Adjust the kernel, strides, pads to correct rank. Set to default value if not present\n   * @param isGlobalOperator If true, perform global pooling.\n   * @param inputDims The input tensor dimension.\n   * @param kernelShape The size of the kernel along each axis.\n   * @param strides Stride along each axis.\n   * @param dilations Dilation along each axis.\n   * @param pads Padding for the beginning and ending along each axis.\n   */\n  static adjustPoolAttributes(\n      isGlobalOperator: boolean, inputDims: readonly number[], kernelShape: number[], strides: number[],\n      dilations: number[], pads: number[]): void {\n    if (!isGlobalOperator && kernelShape.length !== inputDims.length - 2) {\n      throw new Error('length of specified kernel shapes should be 2 less than length of input dimensions');\n    }\n\n    if (isGlobalOperator) {\n      // adjust kernel shape to cover the input dims\n      for (let dim = 0; dim < inputDims.length - 2; dim++) {\n        if (dim >= kernelShape.length) {\n          kernelShape.push(inputDims[dim + 2]);\n        } else {\n          kernelShape[dim] = inputDims[dim + 2];\n        }\n      }\n    }\n\n    // adjust strides length to match kernel shape length\n    for (let dim = 0; dim < kernelShape.length; dim++) {\n      if (dim < strides.length) {\n        if (strides[dim] < 0) {\n          throw new Error('strides should be greater than or equal to 1');\n        }\n      } else {\n        strides.push(1);\n      }\n    }\n\n    // adjust dilation value\n    for (let dim = 0; dim < kernelShape.length; dim++) {\n      if (dim < dilations.length) {\n        if (dilations[dim] < 0) {\n          throw new Error('dilations should be greater than or equal to 1');\n        }\n      } else {\n        dilations.push(1);\n      }\n    }\n\n    // adjust pads length to match 2 * kernel shape length\n    for (let dim = 0; dim < kernelShape.length * 2; dim++) {\n      if (dim < pads.length) {\n        if (pads[dim] < 0) {\n          throw new Error('pad should be greater than or equal to 1');\n        }\n      } else {\n        pads.push(0);\n      }\n    }\n\n    // sanity checks for values in kernel shapes and pads\n    for (let dim = 0; dim < kernelShape.length; dim++) {\n      if (kernelShape[dim] <= 0) {\n        throw new Error('kernel shapes need to be greater than 0');\n      }\n\n      if (pads[dim] >= kernelShape[dim] || pads[dim + kernelShape.length] >= kernelShape[dim]) {\n        throw new Error('pads should be smaller than kernel');\n      }\n    }\n  }\n\n  // adjust pad values based on 'autoPad' attribute\n  static adjustPadsBasedOnAutoPad(\n      inputDims: readonly number[], strides: readonly number[], dilations: readonly number[],\n      kernelShape: readonly number[], pads: number[], isChannelLast: boolean, autoPad?: string): void {\n    if (!autoPad) {\n      return;\n    }\n\n    if (pads.length !== 2 * (inputDims.length - 2)) {\n      throw new Error('length of pads should be twice the length of data dimensions');\n    }\n\n    if (strides.length !== (inputDims.length - 2)) {\n      throw new Error('length of strides should be the length of data dimensions');\n    }\n\n    if (kernelShape.length !== (inputDims.length - 2)) {\n      throw new Error('length of kernel shapes should be the length of data dimensions');\n    }\n\n    for (let dim = 0; dim < inputDims.length - 2; dim++) {\n      PoolConvUtil.adjustPadAndReturnShape(\n          inputDims[dim + (isChannelLast ? 1 : 2)], strides[dim], dilations[dim], kernelShape[dim], pads, dim,\n          dim + inputDims.length - 2, autoPad);\n    }\n  }\n\n  /**\n   * Calculate the output shape for Pool ops based on input attributes. (Should be used only for Pool ops)\n   * @param isGlobalOperator If true, perform global pooling.\n   * @param inputDims The input tensor dimension. (inputs[0].dims)\n   * @param strides Stride along each axis.\n   * @param dilations Dilation along each axis.\n   * @param kernelShape The size of the kernel along each axis.\n   * @param pads Padding for the beginning and ending along each axis.\n   * @param autoPad DEPRECATED attribute supported for legacy models. Specifies how to implicitly calculate pads in each\n   *     dimension. Can take values NOTSET, SAME_UPPER, SAME_LOWER, or VALID.\n   */\n  static computePoolOutputShape(\n      isGlobalOperator: boolean, inputDims: readonly number[], strides: number[], dilations: number[],\n      kernelShape: number[], pads: number[], autoPad?: string): number[] {\n    if (inputDims.length <= 0) {\n      throw new Error('input shape must be of size greater than 0');\n    }\n\n    // Add batch size and number of channels of output\n    const outputDims = [inputDims[0], inputDims[1]];\n\n    PoolConvUtil.computeShapeHelper(\n        isGlobalOperator, inputDims, outputDims, strides, dilations, kernelShape, pads, autoPad);\n    return outputDims;\n  }\n\n  /**\n   * Calculate the output shape for Conv op based on input attributes. (Should be used only for Conv op)\n   * @param inputDims The input tensor dimension. (inputs[0].dims)\n   * @param filterDims The filter tensor dimension. (inputs[1].dims)\n   * @param strides Stride along each axis.\n   * @param kernelShape The size of the kernel along each axis.\n   * @param pads Padding for the beginning and ending along each axis.\n   * @param autoPad DEPRECATED attribute supported for legacy models. Specifies how to implicitly calculate pads in each\n   *     dimension. Can take values NOTSET, SAME_UPPER, SAME_LOWER, or VALID.\n   */\n  static computeConvOutputShape(\n      inputDims: readonly number[], filterDims: readonly number[], strides: number[], dilations: number[],\n      kernelShape: number[], pads: number[], autoPad?: string): number[] {\n    if (inputDims.length <= 0 || filterDims.length <= 0) {\n      throw new Error('invalid input tensor dims or invalid filter tensor dims');\n    }\n\n    // Add batch size and number of channels of output\n    const outputDims = [inputDims[0], filterDims[0]];\n\n    PoolConvUtil.computeShapeHelper(false, inputDims, outputDims, strides, dilations, kernelShape, pads, autoPad);\n    return outputDims;\n  }\n\n  // will compute output shapes for data dimensions ONLY (i.e.) no batch size and channels\n  // called by computePoolOutputShape() and computeConvOutputShape()\n  // adjust pads based on 'autoPad' attribute prior to shape computation\n  private static computeShapeHelper(\n      isGlobalOperator: boolean, inputDims: readonly number[], outputDims: number[], strides: readonly number[],\n      dilations: readonly number[], kernelShape: readonly number[], pads: number[], autoPad?: string) {\n    if (isGlobalOperator) {\n      for (let dim = 0; dim < inputDims.length - 2; dim++) {\n        outputDims.push(1);\n      }\n    } else {\n      for (let dim = 0; dim < inputDims.length - 2; dim++) {\n        outputDims.push(PoolConvUtil.adjustPadAndReturnShape(\n            inputDims[dim + 2], strides[dim], dilations[dim], kernelShape[dim], pads, dim, dim + inputDims.length - 2,\n            autoPad));\n      }\n    }\n  }\n\n  // helper for computeShapeHelper() and adjustPadsBasedOnAutoPad()\n  // adjusts pad value for given 'autoPad' string and computes output shape along a particular dimension\n  private static adjustPadAndReturnShape(\n      inSize: number, stride: number, dilation: number, kernel: number, pads: number[], padHeadIndex: number,\n      padTailIndex: number, autoPad?: string): number {\n    const dkernel = dilation * (kernel - 1) + 1;\n    if (autoPad && autoPad !== 'NOTSET') {\n      switch (autoPad) {\n        case 'VALID':\n          pads[padHeadIndex] = 0;\n          pads[padTailIndex] = 0;\n          return Math.floor(((inSize - dkernel) / stride) + 1);\n        case 'SAME_LOWER':\n        case 'SAME_UPPER':\n          if (dilation !== 1) {\n            throw new Error('Dilation not supported for SAME_UPPER or SAME_LOWER');\n          } else {\n            const legacyTargetSize = (inSize + stride - 1) / stride;\n            const padNeeded = (legacyTargetSize - 1) * stride + kernel - inSize;\n            pads[padHeadIndex] =\n                (autoPad === 'SAME_LOWER') ? Math.floor((padNeeded + 1) / 2) : Math.floor(padNeeded / 2);\n            pads[padTailIndex] = padNeeded - pads[padHeadIndex];\n            return Math.floor(((inSize + padNeeded - kernel) / stride) + 1);\n          }\n        default:\n          throw new Error('Unsupported AutoPad type');\n      }\n    } else {\n      return Math.floor(((inSize + pads[padHeadIndex] + pads[padTailIndex] - dkernel) / stride) + 1);\n    }\n  }\n}\n\nexport class GemmUtil {\n  // will make sure input shapes are compatible for this op\n  // and return back the shape of the output in the form of a tuple\n  // will throw exception if the input shapes are not compatible\n  static getShapeOfGemmResult(\n      leftShape: readonly number[], transLeft: boolean, rightShape: readonly number[], transRight: boolean,\n      biasShape?: readonly number[]): readonly number[] {\n    if (leftShape.length !== 2 || rightShape.length !== 2) {\n      throw new Error('shape need to be of size 2');\n    }\n\n    let M: number;\n    let K: number;\n    let N: number;\n\n    if (transLeft) {\n      M = leftShape[1];\n      K = leftShape[0];\n    } else {\n      M = leftShape[0];\n      K = leftShape[1];\n    }\n\n    let kDim = -1;\n\n    if (transRight) {\n      N = rightShape[0];\n      kDim = 1;\n    } else {\n      N = rightShape[1];\n      kDim = 0;\n    }\n\n    if (rightShape[kDim] !== K) {\n      throw new Error('dimension mismatch');\n    }\n\n    if (M <= 0 || N <= 0 || K <= 0) {\n      throw new Error('invalid shape specified');\n    }\n\n    if (biasShape && !BroadcastUtil.isValidBroadcast(biasShape, [M, N])) {\n      throw new Error('gemm: invalid bias shape for broadcast');\n    }\n\n    return [M, N, K];\n  }\n}\n\n\nexport const MIN_CLIP = -3.4028234663852886e+38;\nexport const MAX_CLIP = 3.4028234663852886e+38;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {ShapeUtil} from '../../util';\nimport {ProgramUniform, ProgramUniformVariableInfo} from '../types';\n\n/**\n * constant value for a workgroup size.\n *\n * We definitely can do further optimization in future, but for now we use 64.\n *\n * rule of thumb: Use [a workgroup size of] 64 unless you know what GPU you are targeting or that your workload\n *                needs something different.\n *\n * from: https://surma.dev/things/webgpu/\n **/\nexport const WORKGROUP_SIZE = 64;\n\ninterface IndicesHelperTypes {\n  /**\n   * WGSL type of indices expression\n   */\n  readonly indices: string;\n\n  /**\n   * WGSL type of a value\n   */\n  readonly value: string;\n\n  /**\n   * WGSL type of storage type representing a value\n   *\n   * This is usually the same to `value`, but for some type (eg. bool), we need to use `u32` as storage type for\n   * value type `vec4<bool>`\n   */\n  readonly storage: string;\n\n  /**\n   * tensor type as represented in TensorView\n   */\n  readonly tensor: number;\n}\n\n/**\n * A helper class for generating WGSL code for manipulating indices and data for a shader's input or output.\n *\n * This class is designed to offer a unified way to generate WGSL code for manipulating indices and data for a shader's\n * input or output.\n *\n * The following is a list of terminologies used in this class:\n * - `offset`: a uint32 value representing the offset of an element in the data buffer.\n * - `indices`: an abstraction of a multi-dimensional array's indices representing the data's index on each dimension.\n * - `value`: a value of a data element.\n *\n * Users are expected to create an instance of this class for each shader's input or output, and use the instance to\n * generate WGSL code for manipulating indices and data. The following 2 exported functions are for users to call to\n * create an instance of an indices helper:\n * - `inputVariable()`: create an indices helper instance for an input.\n * - `outputVariable()`: create an indices helper instance for an output.\n * - `internalVariable()`: create an indices helper instance for an internal variable.\n *\n * An indices helper instance contains helper functions for the following operations:\n * - access readonly basic information, including: `name`(the name of the input or output), `usage`(whether it's an\n * input, an output or an internal variable) and `shape`(the passed in shape).\n * - `type`: access readonly type information, including: `indices`(the type of indices), `value`(the type of value at\n * runtime), `storage`(the type of value at storage) and `tensor`(the tensor type as represented in TensorView).\n * - generate WGSL code for getting indices from offset. Use `offsetToIndices()` for WGSL code snippet to calculate\n * indices from offset, and use `indicesToOffset()` for WGSL code snippet to calculate offset from indices.\n * - to manipulate an instance of indices, use `setIndices()` and `getIndices()` to set and get the indices on an\n * indices variable.\n * - to manipulate data, use `set()`/`get()` to access data at the given indices from parameter list, use\n * `setByIndices()`/`getByIndices()` to access data at the given indices from an indices variable, and use\n * `setByOffset()`/`getByOffset()` to access data at the given offset.\n * - `impl`: get WGSL code of function implementation for the util functions mentioned above.\n */\nexport interface IndicesHelper {\n  /**\n   * get WGSL code of function implementation for the util functions.\n   *\n   */\n  readonly impl: () => string;\n\n  /**\n   * get type info\n   */\n  readonly type: IndicesHelperTypes;\n\n  /**\n   * WGSL code of a expression for getting indices from offset.\n   *\n   * @param varOffset - a u32 expression representing the offset.\n   *\n   * @returns an `type.indices` expression\n   */\n  readonly offsetToIndices: (varOffset: string) => string;\n\n  /**\n   * WGSL code of an `u32` expression for getting offset from indices.\n   *\n   * @param varIndices - a `type.indices` expression representing the indices.\n   *\n   * @returns an `u32` expression\n   */\n  readonly indicesToOffset: (varIndices: string) => string;\n\n  /**\n   * WGSL code of an `u32` expression for getting original offset from broadcasted indices.\n   *\n   * @param varIndices - a `type.indices` expression representing the output indices.\n   * @param output - output IndicesHelper.\n   *\n   * @returns an `u32` expression\n   */\n  readonly broadcastedIndicesToOffset: (varIndices: string, output: IndicesHelper) => string;\n\n  /**\n   * WGSL code of generating an indices literal\n   *\n   * @param init - initial value.\n   */\n  readonly indices: (...init: ReadonlyArray<number|string>) => string;\n\n  /**\n   * WGSL code of a statement for setting indices.\n   *\n   * @param varIndices - a variable name for the indices.\n   * @param idx - the index of the indices to set. can be a number or a string (WGSL `u32` expression).\n   * @param value - the value to set. can be a number or a string (WGSL `u32` expression).\n   *\n   * @returns a WGSL statement\n   */\n  readonly indicesSet: (varIndices: string, idx: number|string, value: number|string) => void;\n\n  /**\n   * WGSL code of an `u32` expression for getting indices.\n   *\n   * @param varIndices - a variable name for the indices.\n   * @param idx - the index of the indices to get. can be a number or a string (WGSL `u32` expression).\n   *\n   * @returns an `u32` expression\n   */\n  readonly indicesGet: (varIndices: string, idx: number|string) => string;\n\n  /**\n   * WGSL code for a statement for setting data at the given indices.\n   *\n   * @param indicesAndValue - an array of numbers or strings (WGSL `u32` expression) representing the indices, followed\n   *     by the value to set. This array should have exactly `shape.length + 1` elements.\n   */\n  readonly set: (...indicesAndValue: ReadonlyArray<number|string>) => string;\n\n  /**\n   * WGSL code for a statement for setting data at the given indices variable.\n   *\n   * @param varIndices - a variable name for the indices.\n   * @param value - the value to set. should be a WGSL expression.\n   */\n  readonly setByIndices: (varIndices: string, value: string) => string;\n\n  /**\n   * WGSL code for a statement for setting data at the given offset.\n   *\n   * @param offset - a number or a string (WGSL `u32` expression) representing the offset.\n   * @param value - the value to set. should be a WGSL expression.\n   */\n  readonly setByOffset: (offset: number|string, value: string) => string;\n\n  /**\n   * WGSL code for an expression for getting data at the given indices.\n   *\n   * @param indices - an array of numbers or strings (WGSL `u32` expression) representing the indices.\n   */\n  readonly get: (...indices: ReadonlyArray<number|string>) => string;\n\n  /**\n   * WGSL code for an expression for getting data at the given indices variable.\n   *\n   * @param varIndices - a variable name for the indices.\n   */\n  readonly getByIndices: (varIndices: string) => string;\n\n  /**\n   * WGSL code for an expression for getting data at the given offset.\n   *\n   * @param offset - a number or a string (WGSL `u32` expression) representing the offset.\n   */\n  readonly getByOffset: (offset: number|string) => string;\n\n  /**\n   * name of the data variable\n   */\n  readonly name: string;\n\n  /**\n   * whether the helper is for an input, an output or an internal variable.\n   */\n  readonly usage: 'input'|'output'|'internal';\n\n  /**\n   * the rank of the input or output.\n   */\n  readonly rank: number;\n\n  /**\n   * a string representing the variable name for the shape of the input or output.\n   */\n  readonly shape: string;\n\n  /**\n   * a string representing the variable name for the strides of the input or output.\n   */\n  readonly strides: string;\n}\n\nconst getWgslMappedType = (type: number, components: 1|2|3|4): string|[string, string] => {\n  if (components === 3) {\n    throw new Error('vec3 has same alignment as vec4, use vec4 instead');\n  }\n\n  // return type is [ storage type, runtime type ] or a single string for both\n  switch (type) {\n    case DataType.float16:\n      return components > 1 ? `vec${components}<f16>` : 'f16';\n    case DataType.float:\n      return components > 1 ? `vec${components}<f32>` : 'f32';\n    case DataType.int32:\n      return components > 1 ? `vec${components}<i32>` : 'i32';\n    case DataType.uint32:\n      return components > 1 ? `vec${components}<u32>` : 'u32';\n    case DataType.int64:\n      if (components > 1) {\n        throw new Error('currently not supported vecX of uint64 yet');\n      }\n      return ['vec2<u32>', 'i32'];\n    case DataType.uint64:\n      if (components > 1) {\n        throw new Error('currently not supported vecX of uint64 yet');\n      }\n      return ['vec2<u32>', 'u32'];\n    case DataType.bool:\n      if (components !== 4) {\n        throw new Error('bool must be vec4');\n      }\n      return ['u32', 'vec4<bool>'];\n\n    default:\n      throw new Error(`Unknown data type: ${type}`);\n  }\n};\n\nexport const tensorTypeToWsglStorageType = (type: DataType, components: 1|2|3|4 = 1) => {\n  const mappedType = getWgslMappedType(type, components);\n  return typeof mappedType === 'string' ? mappedType : mappedType[0];\n};\n\nexport const tensorTypeToWsglValueType = (type: DataType, components: 1|2|3|4 = 1) => {\n  const mappedType = getWgslMappedType(type, components);\n  return typeof mappedType === 'string' ? mappedType : mappedType[1];\n};\n\nexport const createTensorShapeVariables = (...dims: ReadonlyArray<readonly number[]>): ProgramUniform[] => {\n  const programUniforms: ProgramUniform[] = [];\n  dims.forEach(dim => {\n    if (dim.length !== 0) {\n      programUniforms.push(\n          {type: DataType.uint32, data: dim}, {type: DataType.uint32, data: ShapeUtil.computeStrides(dim)});\n    }\n  });\n  return programUniforms;\n};\n\n/**\n * A helper function to get maximum vector size for specified data length\n * @param size\n */\nexport const getMaxComponents = (size: number) => {\n  // we cannot use vec3 type since it has alignment of 16 bytes\n  if (size % 4 === 0) {\n    return 4;\n  } else if (size % 2 === 0) {\n    return 2;\n  }\n\n  return 1;\n};\n\n/**\n * A helper function that initializes variable as a scalar or vector. e.g. f32(0) or vec4f(0,0,0,0)\n * @param dataType\n * @param components\n * @param value\n */\nexport const fillVector = (dataType = 'f32', components?: number, value = '0') => {\n  if (!components || components === 1) {\n    return `${dataType}(${value})`;\n  }\n\n  return `vec${components}<${dataType}>(${value})`;\n};\n\n/**\n * A helper function that casts value or vector to f32\n * @param dataType\n * @param components\n * @param value\n */\nexport const castToF32 = (dataType: string, components: number, value: string) => {\n  if (dataType === 'f32') {\n    return value;\n  }\n  if (components === 1) {\n    return `f32(${value})`;\n  }\n\n  return `vec${components}<f32>(${value})`;\n};\n\n/**\n * A helper function that returns scalar or sums all components of a vector\n * @param name\n * @param components\n */\nexport const sumVector = (name: string, components: number) => {\n  if (components === 4) {\n    return `(${name}.x + ${name}.y + ${name}.z + ${name}.w)`;\n  } else if (components === 2) {\n    return `(${name}.x + ${name}.y)`;\n  } else if (components === 3) {\n    return `(${name}.x + ${name}.y + ${name}.z)`;\n  }\n\n  return name;\n};\n\n/**\n * A helper function that returns variable element at index.\n * @param name - the name of variable.\n * @param index - the index of variable element.\n * @param length - the length of variable.\n * @param type - the type of variable, optional.\n */\nexport const getElementAt =\n    (name: string, index: number|string, length: number, type?: UniformDataElementType): string => {\n      if (name.startsWith('uniforms.') && length > 4) {\n        if (typeof (index) === 'string') {\n          if (type === 'f16') {\n            return `${name}[(${index}) / 8][(${index}) % 8 / 4][(${index}) % 8 % 4]`;\n          } else {\n            return `${name}[(${index}) / 4][(${index}) % 4]`;\n          }\n        } else {\n          if (type === 'f16') {\n            return `${name}[${Math.floor(index / 8)}][${Math.floor(index % 8 / 4)}][${index % 8 % 4}]`;\n          } else {\n            return `${name}[${Math.floor(index / 4)}][${index % 4}]`;\n          }\n        }\n      } else {\n        return length > 1 ? `${name}[${index}]` : name;\n      }\n    };\n\n/**\n * A helper function to get a IndicesHelper for a given input or output.\n *\n * @param name - the name of the input or output.\n * @param tensorType - the tensor type of the input or output.\n * @param shapeOrRank - the tensor shape or the rank of the input or output.\n * @param usage - the usage of the indices helper.\n * @param components - indicates the number of components of each element. 1 for scalar, 2 for vec2, 3 for vec3, 4 for\n *    vec4.\n */\nconst createIndicesHelper =\n    (name: string, tensorType: number, shapeOrRank: number|readonly number[], usage: IndicesHelper['usage'],\n     components: 1|2|3|4): IndicesHelper => {\n      const useUniform = typeof shapeOrRank === 'number';\n      const rank = useUniform ? shapeOrRank : shapeOrRank.length;\n      const rankIdentity = [...new Array(rank).keys()];\n      const indicesType = rank < 2 ? 'u32' : rank <= 4 ? `vec${rank}<u32>` : `array<u32, ${rank}>`;\n      const mappedType = getWgslMappedType(tensorType, components);\n      const valueType = typeof mappedType === 'string' ? mappedType : mappedType[1];\n      const storageType = typeof mappedType === 'string' ? mappedType : mappedType[0];\n      const type = {indices: indicesType, value: valueType, storage: storageType, tensor: tensorType};\n\n      const normalizeDim = (dim: number|string): string => typeof dim === 'string' ? dim : `${dim}u`;\n\n      const implementationUsed = {\n        offsetToIndices: false,\n        indicesToOffset: false,\n        broadcastedIndicesToOffset: false,\n        set: false,\n        setByIndices: false,\n        get: false,\n        getByIndices: false,\n      };\n\n      const uniformPrefix = useUniform ? 'uniforms.' : '';\n      const shape = `${uniformPrefix}${name}_shape`;\n      const strides = `${uniformPrefix}${name}_strides`;\n\n      let o2iSnippet = '';\n      for (let i = 0; i < rank - 1; i++) {\n        o2iSnippet += `\n    let dim${i} = current / ${getElementAt(strides, i, rank)};\n    let rest${i} = current % ${getElementAt(strides, i, rank)};\n    indices[${i}] = dim${i};\n    current = rest${i};\n    `;\n      }\n      o2iSnippet += `indices[${rank - 1}] = current;`;\n\n      const offsetToIndicesImplementation = rank < 2 ? '' : `\n  fn o2i_${name}(offset: u32) -> ${type.indices} {\n    var indices: ${type.indices};\n    var current = offset;\n    ${o2iSnippet}\n    return indices;\n  }`;\n\n      const offsetToIndices = (varOffset: string) => {\n        implementationUsed.offsetToIndices = true;\n        return rank < 2 ? varOffset : `o2i_${name}(${varOffset})`;\n      };\n\n      const offsets: string[] = [];\n      if (rank >= 2) {\n        for (let i = rank - 1; i >= 0; i--) {\n          offsets.push(`${getElementAt(strides, i, rank)} * (indices[${i}])`);\n        }\n      }\n\n      const indicesToOffsetImplementation = rank < 2 ? '' : `\n  fn i2o_${name}(indices: ${type.indices}) -> u32 {\n    return ${offsets.join('+')};\n  }`;\n\n      const indicesToOffset = (varIndices: string) => {\n        implementationUsed.indicesToOffset = true;\n        return rank < 2 ? varIndices : `i2o_${name}(${varIndices})`;\n      };\n\n      const indices = (...init: ReadonlyArray<number|string>) =>\n          rank === 0 ? '0u' : `${type.indices}(${init.map(normalizeDim).join(',')})`;\n\n      const indicesGet = (varIndices: string, idx: number|string) => {\n        if (rank < 2) {\n          return `${varIndices}`;\n        } else {\n          return `${getElementAt(varIndices, idx, rank)}`;\n        }\n      };\n\n      const indicesSet = (varIndices: string, idx: number|string, value: string) => {\n        if (rank < 2) {\n          return `${varIndices}=${value};`;\n        } else {\n          return `${getElementAt(varIndices, idx, rank)}=${value};`;\n        }\n      };\n\n      const broadcastedIndicesToOffsetImplementation: {[key: string]: string} = {};\n      const broadcastedIndicesToOffset = (varIndices: string, output: IndicesHelper) => {\n        implementationUsed.broadcastedIndicesToOffset = true;\n        const implKey = `${output.name}broadcastedIndicesTo${name}Offset`;\n        if (implKey in broadcastedIndicesToOffsetImplementation) {\n          return `${implKey}(${varIndices})`;\n        }\n        const offsets = [];\n        for (let i = rank - 1; i >= 0; i--) {\n          const idx = output.indicesGet('outputIndices', i + output.rank - rank);\n          offsets.push(`${indicesGet(strides, i)} * (${idx} % ${indicesGet(shape, i)})`);\n        }\n        broadcastedIndicesToOffsetImplementation[implKey] =\n            `fn ${implKey}(outputIndices: ${output.type.indices}) -> u32 {\n             return ${offsets.length > 0 ? offsets.join('+') : '0u'};\n           }`;\n\n        return `${implKey}(${varIndices})`;\n      };\n\n      const setByOffset = (offset: number|string, value: string) => (() => {\n        if (type.storage === type.value) {\n          return `${name}[${offset}]=${value};`;\n        } else if (type.storage === 'vec2<u32>' && type.value === 'i32') {\n          // int64, components === 1\n          return `${name}[${offset}]=vec2<u32>(u32(${value}), select(0u, 0xFFFFFFFFu, ${value} < 0));`;\n        } else if (type.storage === 'vec2<u32>' && type.value === 'u32') {\n          // uint64, components === 1\n          return `${name}[${offset}]=vec2<u32>(u32(${value}), 0u);`;\n        } else if (type.storage === 'u32' && type.value === 'vec4<bool>') {\n          // bool, components === 4\n          return `${name}[${offset}]=dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(${value}));`;\n        } else {\n          throw new Error(`not supported combination of storage type ${type.storage} and value type ${type.value} yet`);\n        }\n      })();\n\n      const getByOffset = (offset: number|string) => (() => {\n        if (type.storage === type.value) {\n          return `${name}[${offset}]`;\n        } else if (type.storage === 'vec2<u32>' && type.value === 'i32') {\n          // int64, components === 1\n          return `i32(${name}[${offset}].x)`;\n        } else if (type.storage === 'vec2<u32>' && type.value === 'u32') {\n          // uint64, components === 1\n          return `u32(${name}[${offset}].x)`;\n        } else if (type.storage === 'u32' && type.value === 'vec4<bool>') {\n          // bool, components === 4\n          return `vec4<bool>(bool(${name}[${offset}] & 0xFFu), bool(${name}[${offset}] & 0xFF00u), bool(${name}[${\n              offset}] & 0xFF0000u), bool(${name}[${offset}] & 0xFF000000u))`;\n        } else {\n          throw new Error(`not supported combination of storage type ${type.storage} and value type ${type.value} yet`);\n        }\n      })();\n\n      const getByIndicesImplementation = rank < 2 ? '' : `\n  fn get_${name}ByIndices(indices: ${type.indices}) -> ${valueType} {\n    return ${getByOffset(`i2o_${name}(indices)`)};\n  }`;\n\n      const getImplementation = rank < 2 ? '' : (() => {\n        const functionParams = rankIdentity.map(i => `d${i}: u32`).join(', ');\n        const dimsParams = rankIdentity.map(i => `d${i}`).join(', ');\n        return `\n  fn get_${name}(${functionParams}) -> ${valueType} {\n    return get_${name}ByIndices(${indices(dimsParams)});\n  }`;\n      })();\n\n      const get = (...indices: ReadonlyArray<number|string>) => {\n        if (indices.length !== rank) {\n          throw new Error(`indices length must be ${rank}`);\n        }\n\n        const normalizedIndices = indices.map(normalizeDim).join(',');\n\n        if (rank === 0) {\n          return getByOffset('0u');\n        } else if (rank === 1) {\n          return getByOffset(normalizedIndices[0]);\n        } else {\n          implementationUsed.get = true;\n          implementationUsed.getByIndices = true;\n          implementationUsed.indicesToOffset = true;\n          return `get_${name}(${normalizedIndices})`;\n        }\n      };\n\n      const getByIndices = (varIndices: string) => {\n        if (rank < 2) {\n          return getByOffset(varIndices);\n        } else {\n          implementationUsed.getByIndices = true;\n          implementationUsed.indicesToOffset = true;\n          return `get_${name}ByIndices(${varIndices})`;\n        }\n      };\n\n      const setByIndicesImplementation = rank < 2 ? '' : `\n  fn set_${name}ByIndices(indices: ${type.indices}, value: ${valueType}) {\n    ${setByOffset(`i2o_${name}(indices)`, 'value')}\n  }`;\n\n      const setImplementation = rank < 2 ? '' : (() => {\n        const functionParams = rankIdentity.map(i => `d${i}: u32`).join(', ');\n        const dimsParams = rankIdentity.map(i => `d${i}`).join(', ');\n        return `\n  fn set_${name}(${functionParams}, value: ${valueType}) {\n    set_${name}ByIndices(${indices(dimsParams)}, value);\n  }`;\n      })();\n\n      const set = (...indicesAndValue: ReadonlyArray<number|string>) => {\n        if (indicesAndValue.length !== rank + 1) {\n          throw new Error(`indices length must be ${rank}`);\n        }\n        const value = indicesAndValue[rank];\n        if (typeof value !== 'string') {\n          throw new Error('value must be string');\n        }\n\n        const normalizedIndices = indicesAndValue.slice(0, rank).map(normalizeDim).join(',');\n\n        if (rank === 0) {\n          return setByOffset('0u', value);\n        } else if (rank === 1) {\n          return setByOffset(normalizedIndices[0], value);\n        } else {\n          implementationUsed.set = true;\n          implementationUsed.setByIndices = true;\n          implementationUsed.indicesToOffset = true;\n          return `set_${name}(${normalizedIndices}, ${value})`;\n        }\n      };\n\n      const setByIndices = (varIndices: string, value: string) => {\n        if (rank < 2) {\n          return setByOffset(varIndices, value);\n        } else {\n          implementationUsed.setByIndices = true;\n          implementationUsed.indicesToOffset = true;\n          return `set_${name}ByIndices(${varIndices}, ${value});`;\n        }\n      };\n\n      const impl = () => {\n        const impls = [];\n        let needShapeStrides = false;\n        if (implementationUsed.offsetToIndices) {\n          impls.push(offsetToIndicesImplementation);\n          needShapeStrides = true;\n        }\n        if (implementationUsed.indicesToOffset) {\n          impls.push(indicesToOffsetImplementation);\n          needShapeStrides = true;\n        }\n        if (implementationUsed.broadcastedIndicesToOffset) {\n          Object.values(broadcastedIndicesToOffsetImplementation).forEach(impl => impls.push(impl));\n          needShapeStrides = true;\n        }\n        if (implementationUsed.set) {\n          impls.push(setImplementation);\n          needShapeStrides = true;\n        }\n        if (implementationUsed.setByIndices) {\n          impls.push(setByIndicesImplementation);\n          needShapeStrides = true;\n        }\n        if (implementationUsed.get) {\n          impls.push(getImplementation);\n          needShapeStrides = true;\n        }\n        if (implementationUsed.getByIndices) {\n          impls.push(getByIndicesImplementation);\n          needShapeStrides = true;\n        }\n        if (!useUniform && needShapeStrides) {\n          impls.unshift(\n              `const ${shape} = ${type.indices}(${shapeOrRank.join(',')});`,\n              `const ${strides} = ${type.indices}(${ShapeUtil.computeStrides(shapeOrRank).join(',')});`);\n        }\n        return impls.join('\\n');\n      };\n\n      return {\n        impl,\n        type,\n        offsetToIndices,\n        indicesToOffset,\n        broadcastedIndicesToOffset,\n        indices,\n        indicesGet,\n        indicesSet,\n        set,\n        setByOffset,\n        setByIndices,\n        get,\n        getByOffset,\n        getByIndices,\n        // isVec4,\n        usage,\n        name,\n        strides,\n        shape,\n        rank\n      };\n    };\n\n/**\n * Create a IndicesHelper for an input.\n *\n * @param name - the name of the input.\n * @param type - the tensor type of the input.\n * @param shapeOrRank - the tensor shape or the rank of the input.\n * @param components - the number of components of the input. available values are 1, 2, 3, 4. default is 1.\n * @returns an IndicesHelper for the input.\n */\nexport const inputVariable =\n    (name: string, type: number, shapeOrRank: number|readonly number[], components: 1|2|3|4 = 1): IndicesHelper =>\n        createIndicesHelper(name, type, shapeOrRank, 'input', components);\n\n/**\n * Create a IndicesHelper for an output.\n *\n * @param name - the name of the output.\n * @param type - the tensor type of the output.\n * @param shapeOrRank - the tensor shape or the rank of the output.\n * @param components - the number of components of the output. available values are 1, 2, 3, 4. default is 1.\n * @returns an IndicesHelper for the output.\n */\nexport const outputVariable =\n    (name: string, type: number, shapeOrRank: number|readonly number[], components: 1|2|3|4 = 1): IndicesHelper =>\n        createIndicesHelper(name, type, shapeOrRank, 'output', components);\n\n/**\n * Create a IndicesHelper for an internal variable.\n *\n * @param name - the name of the variable.\n * @param type - the tensor type of the variable.\n * @param shapeOrRank - the tensor shape or the rank of the variable.\n * @param components - the number of components of the variable. available values are 1, 2, 3, 4. default is 1.\n * @returns an IndicesHelper for the variable.\n */\nexport const internalVariable =\n    (name: string, type: number, shapeOrRank: number|readonly number[], components: 1|2|3|4 = 1): IndicesHelper =>\n        createIndicesHelper(name, type, shapeOrRank, 'internal', components);\n\nexport type UniformDataElementType = 'u32'|'f16'|'f32'|'i32';\nexport type UniformsArrayType = Array<{name: string; type: UniformDataElementType; length?: number}>;\n\n/**\n * A ShaderHelper is a helper class for generating WGSL code.\n */\nexport interface ShaderHelper {\n  /**\n   * A helper function to generate the start of main function in WGSL source code.\n   *\n   * @example\n   * const getShaderSource = (shaderHelper: ShaderHelper) => `\n   *  ...\n   *\n   *  ${shaderHelper.mainStart()}\n   *    // your code here inside main() function\n   *    ...\n   *  }\n   * `;\n   *\n   * @param workgroupSize - an optional workgroup size. default is WORKGROUP_SIZE.\n   */\n  mainStart(workgroupSize?: number|[number, number, number]): string;\n\n  /**\n   * A helper function to generate the code snippet for guarding against out-of-bounds size.\n   *\n   * @example\n   * const getShaderSource = (shaderHelper: ShaderHelper) => `\n   *  ...\n   *\n   *  ${shaderHelper.mainStart()}\n   *    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}\n   *\n   *    // your code here inside main() function\n   *    ...\n   *  }\n   * `;\n   *\n   * @param size - the size of the data to guard against. can be a number or a string (WGSL `u32` expression).\n   */\n  guardAgainstOutOfBoundsWorkgroupSizes(size: unknown): string;\n\n  /**\n   * A helper function to generate the code snippet for declaring multiple inputs or outputs.\n   *\n   * @param variables - an array of IndicesHelper for the variables.\n   */\n  declareVariables(...variables: IndicesHelper[]): string;\n\n  /**\n   * A helper function to register one uniform. Can be called multiple times to register multiple uniforms.\n   *\n   * @param name - the name of the uniform.\n   * @param type - the type of the uniform.\n   * @param length - the length of the uniform, default to 1 when it is not provided.\n   */\n  registerUniform(name: string, type: string, length?: number): ShaderHelper;\n\n  /**\n   * A helper function to register multiple uniforms. Can be called multiple times to register multiple uniforms.\n   *\n   * @param uniforms - an array of uniforms. Each element of the array is an object with 2 properties: `name` and\n   *     `type`.\n   */\n  registerUniforms(uniforms: UniformsArrayType): ShaderHelper;\n\n  /**\n   * A helper function to register multiple internal variables. Can be called multiple times to register multiple\n   * internal variables.\n   *\n   * @param variables - an array of IndicesHelper for the variables.\n   */\n  registerInternalVariables(...variables: IndicesHelper[]): ShaderHelper;\n}\n\nclass ShaderHelperImpl implements ShaderHelper {\n  constructor(private normalizedDispatchGroup: [number, number, number], private limits: GPUSupportedLimits) {}\n\n  guardAgainstOutOfBoundsWorkgroupSizes(size: number|string): string {\n    // Guard against out-of-bounds work group sizes\n    const sizeInCode = typeof size === 'number' ? `${size}u` : size;\n    return `if (global_idx >= ${sizeInCode}) { return; }`;\n  }\n\n  mainStart(workgroupSize: number|[number, number, number] = WORKGROUP_SIZE) {\n    const workgroupSizeX = typeof workgroupSize === 'number' ? workgroupSize : workgroupSize[0];\n    const workgroupSizeY = typeof workgroupSize === 'number' ? 1 : workgroupSize[1];\n    const workgroupSizeZ = typeof workgroupSize === 'number' ? 1 : workgroupSize[2];\n\n    if (workgroupSizeX > this.limits.maxComputeWorkgroupSizeX ||\n        workgroupSizeY > this.limits.maxComputeWorkgroupSizeY ||\n        workgroupSizeZ > this.limits.maxComputeWorkgroupSizeZ) {\n      throw new Error(`workgroup size [${workgroupSizeX}, ${workgroupSizeY}, ${\n          workgroupSizeZ}] exceeds the maximum workgroup size [${this.limits.maxComputeWorkgroupSizeX}, ${\n          this.limits.maxComputeWorkgroupSizeY}, ${this.limits.maxComputeWorkgroupSizeZ}].`);\n    }\n\n    if (workgroupSizeX * workgroupSizeY * workgroupSizeZ > this.limits.maxComputeInvocationsPerWorkgroup) {\n      throw new Error(`workgroup size [${workgroupSizeX}, ${workgroupSizeY}, ${\n          workgroupSizeZ}] exceeds the maximum workgroup invocations ${\n          this.limits.maxComputeInvocationsPerWorkgroup}.`);\n    }\n\n    const is1DimensionDispatch = this.normalizedDispatchGroup[1] === 1 && this.normalizedDispatchGroup[2] === 1;\n    const paramList = is1DimensionDispatch ? `@builtin(global_invocation_id) global_id : vec3<u32>,\n    @builtin(workgroup_id) workgroup_id : vec3<u32>,\n    @builtin(local_invocation_id) local_id : vec3<u32>` :\n                                             `@builtin(global_invocation_id) global_id : vec3<u32>,\n                                             @builtin(local_invocation_id) local_id : vec3<u32>,\n    @builtin(local_invocation_index) local_idx : u32,\n    @builtin(workgroup_id) workgroup_id : vec3<u32>,\n    @builtin(num_workgroups) num_workgroups : vec3<u32>`;\n    const globalIdxDefinition = is1DimensionDispatch ?\n        'let global_idx = global_id.x; let local_idx = local_id.x;' :\n        `let global_idx = (workgroup_id.z * num_workgroups[0] * num_workgroups[1] +\n          workgroup_id.y * num_workgroups[0] + workgroup_id.x) * ${\n            workgroupSizeX * workgroupSizeY * workgroupSizeZ}u + local_idx;`;\n\n    return `@compute @workgroup_size(${workgroupSizeX}, ${workgroupSizeY}, ${workgroupSizeZ})\n  fn main(${paramList}) {\n    ${globalIdxDefinition}\n  `;\n  }\n\n  private appendVariableUniforms(variable: IndicesHelper): void {\n    if (variable.rank !== 0) {\n      if (variable.shape.startsWith('uniforms.')) {\n        this.uniforms.push({name: variable.shape.replace('uniforms.', ''), type: 'u32', length: variable.rank});\n      }\n      if (variable.strides.startsWith('uniforms.')) {\n        this.uniforms.push({name: variable.strides.replace('uniforms.', ''), type: 'u32', length: variable.rank});\n      }\n    }\n  }\n\n  private declareVariable(variable: IndicesHelper, bindingIndex: number): string {\n    if (variable.usage === 'internal') {\n      throw new Error('cannot use internal variable with declareVariable(). use registerInternalVariables() instead.');\n    }\n    this.variables.push(variable);\n    this.appendVariableUniforms(variable);\n\n    const access = variable.usage === 'input' ? 'read' : 'read_write';\n    const storageType = variable.type.storage;\n    return `@group(0) @binding(${bindingIndex}) var<storage, ${access}> ${variable.name}: array<${storageType}>;`;\n  }\n\n  declareVariables(...variables: IndicesHelper[]): string {\n    return variables.map(v => this.declareVariable(v, this.variableIndex++)).join('\\n');\n  }\n\n  private registerInternalVariable(variable: IndicesHelper): void {\n    if (variable.usage !== 'internal') {\n      throw new Error(\n          'cannot use input or output variable with registerInternalVariable(). use declareVariables() instead.');\n    }\n\n    this.internalVariables.push(variable);\n    this.appendVariableUniforms(variable);\n  }\n\n  registerInternalVariables(...variables: IndicesHelper[]): ShaderHelper {\n    variables.forEach(v => this.registerInternalVariable(v));\n    return this;\n  }\n\n  registerUniform(name: string, type: UniformDataElementType, length = 1): ShaderHelper {\n    this.uniforms.push({name, type, length});\n    return this;\n  }\n\n  registerUniforms(additionalUniforms: UniformsArrayType): ShaderHelper {\n    this.uniforms = this.uniforms.concat(additionalUniforms);\n    return this;\n  }\n\n  private internalVariables: IndicesHelper[] = [];\n  private variables: IndicesHelper[] = [];\n  private uniforms: UniformsArrayType = [];\n  private uniformDeclaration(): string {\n    if (this.uniforms.length === 0) {\n      return '';\n    }\n\n    const uniformSnippets: string[] = [];\n    for (const {name, type, length} of this.uniforms) {\n      if (length && length > 4) {\n        if (type === 'f16') {\n          uniformSnippets.push(`@align(16) ${name}:array<mat2x4<${type}>, ${Math.ceil(length / 8)}>`);\n        } else {\n          uniformSnippets.push(`${name}:array<vec4<${type}>, ${Math.ceil(length / 4)}>`);\n        }\n      } else {\n        const typeTemp = length == null || length === 1 ? type : `vec${length}<${type}>`;\n        uniformSnippets.push(`${name}:${typeTemp}`);\n      }\n    }\n\n    return `\n      struct Uniforms { ${uniformSnippets.join(', ')} };\n      @group(0) @binding(${this.variableIndex}) var<uniform> uniforms: Uniforms;`;\n  }\n  private variableIndex = 0;\n\n  /**\n   * Get additional implementation that needs to be added to the shader source.\n   */\n  get additionalImplementations(): string {\n    return this.uniformDeclaration() + this.variables.map(i => i.impl()).join('\\n') +\n        this.internalVariables.map(i => i.impl()).join('\\n');\n  }\n\n  /**\n   * Get the variable info of the shader program.\n   */\n  get variablesInfo(): ProgramUniformVariableInfo[]|undefined {\n    if (this.uniforms.length === 0) {\n      return undefined;\n    }\n\n    const uniformWgslTypeToDataType = (type: UniformDataElementType) =>\n        ([DataType.uint32, DataType.float16, DataType.float,\n          DataType.int32][['u32', 'f16', 'f32', 'i32'].indexOf(type)]);\n    return this.uniforms.map(u => ([uniformWgslTypeToDataType(u.type), u.length ?? 1]));\n  }\n}\n\nexport const createShaderHelper = (dispatchGroup: [number, number, number], limits: GPUSupportedLimits) =>\n    new ShaderHelperImpl(dispatchGroup, limits);\n\n/**\n * This function comes from https://github.com/tensorflow/tfjs/blob/master/tfjs-core/src/ops/broadcast_util.ts#L18-L40\n * Returns the dimensions in the input shape that are broadcasted to\n * produce the provided output shape.\n *\n * The returned dimensions are 0-indexed and sorted. An example:\n * inShape = [4, 1, 3]\n * outShape = [5, 4, 3, 3]\n * result = [1]. Dimension 1 (2nd dimension of input) gets broadcasted 1 => 3.\n */\nexport const getBroadcastDims = (inShape: readonly number[], outShape: readonly number[]): number[] => {\n  const inRank = inShape.length;\n  const dims: number[] = [];\n  for (let i = 0; i < inRank; i++) {\n    const dim = inRank - 1 - i;\n    const a = inShape[dim] || 1;\n    const b = outShape[outShape.length - 1 - i] || 1;\n    if (b > 1 && a === 1) {\n      dims.unshift(dim);\n    }\n  }\n  return dims;\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface TransposeAttributes extends AttributeWithCacheKey {\n  readonly perm: number[];\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Transpose requires 1 input.');\n  }\n};\n\nconst getAdjustedPerm = (inputRank: number, perm: number[]): number[] =>\n    (perm && perm.length !== inputRank) ? [...(new Array(inputRank).keys())].reverse() : perm;\n\nconst getOutputShape = (inputShape: readonly number[], perm: number[]): readonly number[] =>\n    ShapeUtil.sortBasedOnPerm(inputShape, getAdjustedPerm(inputShape.length, perm));\n\nconst permFunctionBody = (perm: number[], rank: number, input: IndicesHelper, output: IndicesHelper): string => {\n  const reverseFunc = [];\n  reverseFunc.push(`fn perm(i: ${output.type.indices}) -> ${input.type.indices} {\n    var a: ${input.type.indices};`);\n  for (let i = 0; i < rank; ++i) {\n    reverseFunc.push(input.indicesSet('a', perm[i], `i[${i}]`));\n  }\n  reverseFunc.push('return a;}');\n  return reverseFunc.join('\\n');\n};\n\nexport const createTransposeProgramInfo = (inputTensor: TensorView, permAttr: number[]): ProgramInfo => {\n  const inputDataType = inputTensor.dataType;\n  const inputRank = inputTensor.dims.length;\n  const perm = getAdjustedPerm(inputRank, permAttr);\n  const outputShape = getOutputShape(inputTensor.dims, perm);\n  const output = outputVariable('output', inputDataType, outputShape.length);\n  const input = inputVariable('a', inputDataType, inputRank);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(input, output)}\n\n  ${permFunctionBody(perm, inputRank, input, output)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n    let indices = ${output.offsetToIndices('global_idx')};\n    let aIndices = perm(indices);\n\n    ${output.setByOffset('global_idx', input.getByIndices('aIndices'))}\n  }`;\n  return {\n    name: 'Transpose',\n    shaderCache: {hint: `${permAttr}`, inputDependencies: ['rank']},\n    getRunData: (inputs) => {\n      const outputSize = ShapeUtil.size(outputShape);\n      return {\n        outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n        dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n        programUniforms:\n            [{type: DataType.uint32, data: outputSize}, ...createTensorShapeVariables(inputs[0].dims, outputShape)],\n      };\n    },\n    getShaderSource,\n  };\n};\n\nexport const transpose = (context: ComputeContext, attributes: TransposeAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createTransposeProgramInfo(context.inputs[0], attributes.perm));\n};\n\nexport const parseTransposeAttributes = (attributes: Record<string, unknown>): TransposeAttributes =>\n    createAttributeWithCacheKey({perm: attributes.perm as number[]});\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramShaderCacheInfo} from '../types';\n\nimport {inputVariable, outputVariable, ShaderHelper} from './common';\nimport {createReduceAttributesFromInputs, ReduceAttributes} from './reduce';\nimport {createTransposeProgramInfo} from './transpose';\n\nconst reduceOps: {[key: string]: string} = {\n  max: 'select(bestValue, candidate, candidate > bestValue)',\n  min: 'select(bestValue, candidate, candidate < bestValue)',\n  mean: 'bestValue + candidate',\n  sum: 'bestValue + candidate',\n  prod: 'bestValue * candidate',\n  sumSquare: 'bestValue + candidate * candidate',\n  logSumExp: 'bestValue + exp(candidate)',\n  l1: 'bestValue + abs(candidate)',\n  l2: 'bestValue + candidate * candidate',\n  logSum: 'bestValue + candidate'\n};\n\nconst reduceSharedOps: {[key: string]: string} = {\n  max: 'select(bestValue, candidate, candidate > bestValue)',\n  min: 'select(bestValue, candidate, candidate < bestValue)',\n  mean: 'bestValue + candidate',\n  sum: 'bestValue + candidate',\n  prod: 'bestValue * candidate',\n  sumSquare: 'bestValue + candidate',\n  logSumExp: 'bestValue + candidate',\n  l1: 'bestValue + candidate',\n  l2: 'bestValue + candidate',\n  logSum: 'bestValue + candidate'\n};\n\nconst reduceInitValues: {[key: string]: string} = {\n  max: '_A[offset]',\n  min: '_A[offset]',\n  mean: '0',\n  sum: '0',\n  prod: '1',\n  sumSquare: '0',\n  logSumExp: '0',\n  l1: '0',\n  l2: '0',\n  logSum: '0'\n};\n\nconst reduceOutputValues: {[key: string]: string} = {\n  max: 'bestValue',\n  min: 'bestValue',\n  sum: 'bestValue',\n  prod: 'bestValue',\n  sumSquare: 'bestValue',\n  logSumExp: 'log(bestValue)',\n  l1: 'bestValue',\n  l2: 'sqrt(bestValue)',\n  logSum: 'log(bestValue)'\n};\n\nconst getInnerMostAxes = (numInnerAxes: number, rank: number): number[] => {\n  const res = [];\n  for (let i = rank - numInnerAxes; i < rank; ++i) {\n    res.push(i);\n  }\n  return res;\n};\n\nconst computeOutAndReduceShapes = (shape: readonly number[], axes: readonly number[]): [number[], number[]] => {\n  const outputShape = [];\n  const rank = shape.length;\n  for (let dim = 0; dim < rank; dim++) {\n    if (axes.indexOf(dim) === -1) {\n      outputShape.push(shape[dim]);\n    }\n  }\n  const reduceShape = axes.map(dim => shape[dim]);\n  return [outputShape, reduceShape];\n};\n\nconst expandShapeToKeepDim = (shape: number[], axes: number[]): number[] => {\n  const rank = shape.length + axes.length;\n  const expandShape = [];\n  let shapeIdx = 0;\n  for (let dim = 0; dim < rank; dim++) {\n    if (axes.indexOf(dim) === -1) {\n      expandShape.push(shape[shapeIdx++]);\n    } else {\n      expandShape.push(1);\n    }\n  }\n  return expandShape;\n};\n\nconst areAxesInnerMostDims = (axes: number[], rank: number): boolean => {\n  for (let i = 0; i < axes.length; ++i) {\n    if (axes[axes.length - i - 1] !== rank - 1 - i) {\n      return false;\n    }\n  }\n  return true;\n};\n\nconst getAxesPermutation = (axes: number[], rank: number): number[] => {\n  const res = [];\n  if (!areAxesInnerMostDims(axes, rank)) {\n    for (let i = 0; i < rank; ++i) {\n      if (axes.indexOf(i) === -1) {\n        res.push(i);\n      }\n    }\n    axes.forEach(axis => res.push(axis));\n  }\n  return res;\n};\n\nexport const createReduceSharedProgramInfo =\n    (name: string, shaderCache: ProgramShaderCacheInfo, inputs: readonly TensorView[], reduceType: string,\n     outputDataType: DataType, outputShape: number[], reduceShape: number[]): ProgramInfo => {\n      const inputShape = inputs[0].dims;\n\n      const outputSize = ShapeUtil.size(outputShape);\n      const reduceSize = ShapeUtil.size(reduceShape);\n\n      const input = inputVariable('_A', inputs[0].dataType, inputShape);\n      const output = outputVariable('output', outputDataType, outputShape);\n\n      const workgroupSize = 32;\n\n      const sharedMemorySnippet = `\n          var<workgroup> aBestValues : array<f32, ${workgroupSize}>;\n       `;\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => `\n        ${shaderHelper.registerUniform('reduceSize', 'u32').declareVariables(input, output)}\n        ${sharedMemorySnippet}\n        fn DIV_CEIL(a : u32, b : u32) -> u32 {\n          return ((a - 1u) / b + 1u);\n         }\n         ${shaderHelper.mainStart(workgroupSize)}\n\n          let outputIndex = global_idx / ${workgroupSize};\n          let offset = outputIndex * uniforms.reduceSize;\n\n          var bestValue = f32(${reduceInitValues[reduceType]});\n          let Length = uniforms.reduceSize;\n          for (var k = local_idx; k < Length; k = k + ${workgroupSize}) {\n           let candidate = f32(${input.getByOffset('offset + k')});\n           bestValue = ${reduceOps[reduceType]};\n          }\n          aBestValues[local_idx] = bestValue;\n          workgroupBarrier();\n\n         var reduceSize = min(Length, ${workgroupSize}u);\n         for (var currentSize = reduceSize / 2u; reduceSize > 1u;\n             currentSize = reduceSize / 2u) {\n           let interval = DIV_CEIL(reduceSize, 2u);\n           if (local_idx < currentSize) {\n            let candidate = aBestValues[local_idx + interval];\n            bestValue = ${reduceSharedOps[reduceType]};\n            aBestValues[local_idx] = bestValue;\n           }\n           reduceSize = interval;\n           workgroupBarrier();\n         }\n\n         if (local_idx == 0u) {\n          ${\n          output.setByOffset(\n              'outputIndex',\n              `${\n                  reduceType === 'mean' ? `${output.type.storage}(bestValue / f32(uniforms.reduceSize))` :\n                                          `${output.type.storage}(${reduceOutputValues[reduceType]})`}`)};\n         }\n        }`;\n\n      // One work group is responsible for only one element of output.\n      return {\n        name,\n        shaderCache,\n        getShaderSource,\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: outputDataType}],\n          dispatchGroup: {x: outputSize},\n          programUniforms: [{type: DataType.uint32, data: reduceSize}]\n        }),\n      };\n    };\n\nconst reduceCommon =\n    (context: ComputeContext, name: string, attributes: ReduceAttributes,\n     reduceType: 'sum'|'sumSquare'|'prod'|'min'|'max'|'mean'|'logSumExp'|'l1'|'l2'|'logSum'): void => {\n      const updatedAttributes: ReduceAttributes =\n          context.inputs.length === 1 ? attributes : createReduceAttributesFromInputs(context.inputs, attributes);\n\n      let updatedAxes = updatedAttributes.axes;\n      if (updatedAxes.length === 0 && !updatedAttributes.noopWithEmptyAxes) {\n        updatedAxes = context.inputs[0].dims.map((_dim, i) => i);\n      }\n      const normalizeAxes = ShapeUtil.normalizeAxes(updatedAxes, context.inputs[0].dims.length);\n\n      let axes = normalizeAxes;\n      let input = context.inputs[0];\n      const permutedAxes = getAxesPermutation(axes, context.inputs[0].dims.length);\n      if (permutedAxes.length > 0) {\n        input = context.compute(\n            createTransposeProgramInfo(context.inputs[0], permutedAxes), {inputs: [0], outputs: [-1]})[0];\n        axes = getInnerMostAxes(axes.length, input.dims.length);\n      }\n\n      const [outputShape, reduceShape] = computeOutAndReduceShapes(input.dims, axes);\n      let finalOutputShape = outputShape;\n      if (updatedAttributes.keepDims) {\n        finalOutputShape = expandShapeToKeepDim(outputShape, normalizeAxes);\n      }\n\n      context.compute(\n          createReduceSharedProgramInfo(\n              name, {hint: updatedAttributes.cacheKey, inputDependencies: ['type']}, [input], reduceType,\n              context.inputs[0].dataType, finalOutputShape, reduceShape),\n          {inputs: [input]});\n    };\n\nexport const reduceMeanShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceMeanShared', attributes, 'mean');\n};\n\nexport const reduceL1Shared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceL1Shared', attributes, 'l1');\n};\n\nexport const reduceL2Shared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceL2Shared', attributes, 'l2');\n};\n\nexport const reduceLogSumExpShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceLogSumExpShared', attributes, 'logSumExp');\n};\n\nexport const reduceMaxShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceMaxShared', attributes, 'max');\n};\n\nexport const reduceMinShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceMinShared', attributes, 'min');\n};\n\nexport const reduceProdShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceProdShared', attributes, 'prod');\n};\n\nexport const reduceSumShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceSumShared', attributes, 'sum');\n};\n\nexport const reduceSumSquareShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceSumSquareShared', attributes, 'sumSquare');\n};\n\nexport const reduceLogSumShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceLogSumShared', attributes, 'logSum');\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramShaderCacheInfo} from '../types';\n\nimport {createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\nimport {reduceL1Shared, reduceL2Shared, reduceLogSumExpShared, reduceLogSumShared, reduceMaxShared, reduceMeanShared, reduceMinShared, reduceProdShared, reduceSumShared, reduceSumSquareShared} from './reduce-shared';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length === 0 || inputs.length > 2) {\n    throw new Error('Reduce op requires 1 or 2 inputs.');\n  }\n\n  if (inputs.length === 2 && inputs[1].dims.length !== 1) {\n    throw new Error('Invalid axes input dims.');\n  }\n};\n\nexport interface ReduceAttributes extends AttributeWithCacheKey {\n  keepDims: boolean;\n  noopWithEmptyAxes: boolean;\n  axes: number[];\n}\n\nexport type ReduceOp =\n    (input: IndicesHelper, output: IndicesHelper,\n     axes: readonly number[]) => [string, string, string, string, ...string[]];\n\nconst noOp: ReduceOp = (input) => ['', '', `var value = ${input.getByIndices('input_indices')};`, ''];\nexport const createReduceProgramInfo =\n    (name: string, shaderCache: ProgramShaderCacheInfo, inputs: readonly TensorView[], reduceOp: ReduceOp,\n     axesInput: number[], outputDataType: DataType, keepDims = false, noopWithEmptyAxes = false): ProgramInfo => {\n      const outputShape: number[] = [];\n      const inputShape = inputs[0].dims;\n      const inputRank = inputShape.length;\n      const axes = ShapeUtil.normalizeAxes(axesInput, inputRank);\n      const reduceOnAllAxes = !noopWithEmptyAxes && axes.length === 0;\n      inputShape.forEach((d, i) => {\n        if (reduceOnAllAxes || axes.indexOf(i) >= 0) {\n          if (keepDims) {\n            outputShape.push(1);\n          }  // else { // skip this axis}\n        } else {\n          outputShape.push(d);\n        }\n      });\n      const outputRank = outputShape.length;\n      const outputSize = ShapeUtil.size(outputShape);\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const idxCopy: string[] = [];  // copy output indexes to input indexes\n\n        const input = inputVariable('_A', inputs[0].dataType, inputRank);\n        const output = outputVariable('output', outputDataType, outputRank);\n        const ops = reduceOp(input, output, axes);\n        let reduceOps = ops[2];\n\n        for (let k = 0, l = 0; k < inputRank; k++) {\n          // if this axis is reduced\n          if (reduceOnAllAxes || axes.indexOf(k) >= 0) {\n            if (keepDims) {\n              l++;\n            }\n            // loop over the d-th axis\n            reduceOps = `for(var j${k}: u32 = 0; j${k} < ${inputShape[k]}; j${k}++) {\n                  ${ops[2].includes('last_index') ? `let last_index = j${k};` : ''}\n                  ${input.indicesSet('input_indices', k, `j${k}`)}\n                  ${reduceOps}\n                }`;\n          } else {\n            idxCopy.push(`${input.indicesSet('input_indices', k, output.indicesGet('output_indices', l))};`);\n            l++;\n          }\n        }\n        return `\n\n        ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(input, output)}\n\n        ${shaderHelper.mainStart()}\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n          var input_indices: ${input.type.indices};\n          let output_indices = ${output.offsetToIndices('global_idx')};\n\n          ${idxCopy.join('\\n')}\n          ${ops[0]}       // init ops for reduce max/min\n          ${ops[1]}\n          ${reduceOps}\n          ${ops[3]}\n          ${ops.length === 4 ? output.setByOffset('global_idx', 'value') : ops.slice(4).join('\\n')}\n        }`;\n      };\n\n      return {\n        name,\n        shaderCache,\n        getShaderSource,\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: outputDataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms:\n              [{type: DataType.uint32, data: outputSize}, ...createTensorShapeVariables(inputShape, outputShape)]\n        }),\n      };\n    };\n\nexport const createReduceAttributesFromInputs =\n    (inputs: readonly TensorView[], attributes: ReduceAttributes): ReduceAttributes => {\n      const axes: number[] = [];\n      if (inputs[1].dims[0] > 0) {\n        inputs[1].getBigInt64Array().forEach(v => axes.push(Number(v)));\n      }\n      return createAttributeWithCacheKey(\n          {axes, keepDims: attributes.keepDims, noopWithEmptyAxes: attributes.noopWithEmptyAxes});\n    };\n\nconst runReduceProgram =\n    (context: ComputeContext, name: string, attributes: ReduceAttributes, reduceOp: ReduceOp): void => {\n      const inputs = context.inputs;\n      const updatedAttributes: ReduceAttributes =\n          inputs.length === 1 ? attributes : createReduceAttributesFromInputs(inputs, attributes);\n\n      context.compute(\n          createReduceProgramInfo(\n              name, {hint: updatedAttributes.cacheKey, inputDependencies: ['rank']}, [inputs[0]],\n              updatedAttributes.noopWithEmptyAxes && updatedAttributes.axes.length === 0 ? noOp : reduceOp,\n              updatedAttributes.axes, inputs[0].dataType, updatedAttributes.keepDims,\n              updatedAttributes.noopWithEmptyAxes),\n          {inputs: [0]});\n    };\n\nconst reduceLogSumNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var value = ${output.type.storage}(0);`,\n       '',\n       `value += ${input.getByIndices('input_indices')};`,\n       'value = log(value);',\n  ];\n  runReduceProgram(context, 'ReduceLogSum', attributes, reduceOp);\n};\n\nconst reduceL1Naive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var value = ${output.type.storage}(0);`,\n       '',\n       `value += abs(${input.getByIndices('input_indices')});`,\n       '',\n  ];\n  runReduceProgram(context, 'ReduceL1', attributes, reduceOp);\n};\n\nconst reduceL2Naive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var t = ${output.type.value}(0); var value = ${output.type.value}(0);`,\n       '',\n       `t = ${input.getByIndices('input_indices')}; value += (t * t);`,\n       'value = sqrt(value);',\n  ];\n  runReduceProgram(context, 'ReduceL2', attributes, reduceOp);\n};\n\nconst reduceLogSumExpNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var value = ${output.type.storage}(0);`,\n       '',\n       `value += exp(${input.getByIndices('input_indices')});`,\n       'value = log(value);',\n  ];\n  runReduceProgram(context, 'ReduceLogSumExp', attributes, reduceOp);\n};\n\nconst reduceMaxNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, _output, axes) => {\n    const idxZero = [];\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(input.indicesSet('input_indices', k, 0));\n      }\n    }\n\n    return [\n      `${idxZero.join('\\n')}`,\n      `var value = ${input.getByIndices('input_indices')};`,\n      `value = max(value, ${input.getByIndices('input_indices')});`,\n      '',\n    ];\n  };\n  runReduceProgram(context, 'ReduceMax', attributes, reduceOp);\n};\n\nconst reduceMeanNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output, axes) => {\n    let size = 1.0;\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        // TODO: this depends on the input dims. If we want to use uniform, this need to be updated.\n        size *= context.inputs[0].dims[k];\n      }\n    }\n\n    return [\n      'var sum = f32(0);',\n      '',\n      `sum += f32(${input.getByIndices('input_indices')});`,\n      `let value = ${output.type.value}(sum / ${size});`,\n    ];\n  };\n  runReduceProgram(context, 'ReduceMean', attributes, reduceOp);\n};\n\nconst reduceMinNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, _output, axes) => {\n    const idxZero = [];\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(`input_indices[${k}] = 0;`);  // first element\n      }\n    }\n\n    return [\n      `${idxZero.join('\\n')}`,\n      `var value = ${input.getByIndices('input_indices')};`,\n      `value = min(value, ${input.getByIndices('input_indices')});`,\n      '',\n    ];\n  };\n  runReduceProgram(context, 'ReduceMin', attributes, reduceOp);\n};\n\nconst reduceProdNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var value = ${output.type.storage}(1);`,\n       '',\n       `value *= ${input.getByIndices('input_indices')};`,\n       '',\n  ];\n  runReduceProgram(context, 'ReduceProd', attributes, reduceOp);\n};\n\nconst reduceSumNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var value = ${output.type.storage}(0);`,\n       '',\n       `value += ${input.getByIndices('input_indices')};`,\n       '',\n  ];\n  runReduceProgram(context, 'ReduceSum', attributes, reduceOp);\n};\n\nconst reduceSumSquareNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) =>\n      [`var t = ${output.type.value}(0); var value = ${output.type.value}(0);`,\n       '',\n       `t = ${input.getByIndices('input_indices')}; value += t * t;`,\n       '',\n  ];\n  runReduceProgram(context, 'ReduceSumSquare', attributes, reduceOp);\n};\n\nconst useNaiveReduceMethod =\n    (shape: readonly number[], axes: readonly number[], noopWithEmptyAxes: boolean): boolean => {\n      if (axes.length === 0) {\n        return noopWithEmptyAxes;\n      }\n\n      let outputSize = 1;\n      let reduceSize = 1;\n      for (let dim = 0; dim < axes.length; dim++) {\n        if (axes.indexOf(dim) === -1) {\n          outputSize *= shape[dim];\n        } else {\n          reduceSize *= shape[dim];\n        }\n      }\n\n      // The condition data is very rough, although considering the count of Execution Unit (EU), the potential\n      // work groups in a EU and the counts of loops in the naive and shared methods, also doing experiments\n      // on some machines.\n      return reduceSize < 32 && outputSize > 1024;\n    };\n\nexport const reduceMean = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceMeanNaive(context, attributes);\n  } else {\n    reduceMeanShared(context, attributes);\n  }\n};\n\nexport const reduceL1 = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceL1Naive(context, attributes);\n  } else {\n    reduceL1Shared(context, attributes);\n  }\n};\n\nexport const reduceL2 = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceL2Naive(context, attributes);\n  } else {\n    reduceL2Shared(context, attributes);\n  }\n};\n\nexport const reduceLogSumExp = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceLogSumExpNaive(context, attributes);\n  } else {\n    reduceLogSumExpShared(context, attributes);\n  }\n};\n\nexport const reduceMax = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceMaxNaive(context, attributes);\n  } else {\n    reduceMaxShared(context, attributes);\n  }\n};\n\nexport const reduceMin = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceMinNaive(context, attributes);\n  } else {\n    reduceMinShared(context, attributes);\n  }\n};\n\nexport const reduceProd = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceProdNaive(context, attributes);\n  } else {\n    reduceProdShared(context, attributes);\n  }\n};\n\nexport const reduceSum = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceSumNaive(context, attributes);\n  } else {\n    reduceSumShared(context, attributes);\n  }\n};\n\nexport const reduceSumSquare = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceSumSquareNaive(context, attributes);\n  } else {\n    reduceSumSquareShared(context, attributes);\n  }\n};\n\nexport const reduceLogSum = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceLogSumNaive(context, attributes);\n  } else {\n    reduceLogSumShared(context, attributes);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// TODO: this is the same naive implementation we use for reduce that has\n// performance limitations when the reduced axis is long. Need to add\n// a optimized codepath for this.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext} from '../types';\n\nimport {createReduceProgramInfo, ReduceOp} from './reduce';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length === 0 || inputs.length > 2) {\n    throw new Error('ArgMinMaxOp op requires 1 or 2 inputs.');\n  }\n  if (inputs[0].dataType !== DataType.float) {\n    throw new Error('Invalid input type.');\n  }\n};\n\nexport interface ArgMinMaxAttributes extends AttributeWithCacheKey {\n  keepDims: boolean;\n  axis: number;\n  selectLastIndex: number;\n}\n\nexport const argMin = (context: ComputeContext, attributes: ArgMinMaxAttributes): void => {\n  validateInputs(context.inputs);\n  const argMinMaxOp: ReduceOp = (input, output, axes) => {\n    const idxZero = [];\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(`input_indices[${k}] = 0;`);  // first element\n      }\n    }\n    return [\n      `${idxZero.join('\\n')}`, `var value = ${input.getByIndices('input_indices')};\\nvar best_index : i32 = 0;`,\n      `if (${input.getByIndices('input_indices')} ${attributes.selectLastIndex > 0 ? '<=' : '<'} value) {\n         value = ${input.getByIndices('input_indices')};\n         best_index = i32(last_index);\n       }`,\n      '', output.setByOffset('global_idx', 'best_index')\n    ];\n  };\n\n  context.compute(\n      createReduceProgramInfo(\n          'ArgMin', {hint: attributes.cacheKey, inputDependencies: ['rank']}, [context.inputs[0]], argMinMaxOp,\n          [attributes.axis], DataType.int64, attributes.keepDims),\n      {inputs: [0]});\n};\n\nexport const argMax = (context: ComputeContext, attributes: ArgMinMaxAttributes): void => {\n  validateInputs(context.inputs);\n  const argMinMaxOp: ReduceOp = (input, output, axes) => {\n    const idxZero = [];\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(`input_indices[${k}] = 0;`);  // first element\n      }\n    }\n    return [\n      `${idxZero.join('\\n')}`, `var value = ${input.getByIndices('input_indices')};\\nvar best_index : i32 = 0;`,\n      `if (${input.getByIndices('input_indices')} ${attributes.selectLastIndex > 0 ? '>=' : '>'} value) {\n         value = ${input.getByIndices('input_indices')};\n         best_index = i32(last_index);\n       }`,\n      '', output.setByOffset('global_idx', 'best_index')\n    ];\n  };\n\n  context.compute(\n      createReduceProgramInfo(\n          'argMax', {hint: attributes.cacheKey, inputDependencies: ['rank']}, [context.inputs[0]], argMinMaxOp,\n          [attributes.axis], DataType.int64, attributes.keepDims),\n      {inputs: [0]});\n};\n\nexport const parseArgMinMaxAttributes = (attributes: Record<string, unknown>): ArgMinMaxAttributes =>\n    createAttributeWithCacheKey(attributes as Omit<ArgMinMaxAttributes, keyof AttributeWithCacheKey>);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface ConcatAttributes extends AttributeWithCacheKey {\n  readonly axis: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[], axis: number): void => {\n  if (!inputs || inputs.length < 1) {\n    throw new Error('too few inputs');\n  }\n  const referenceIndex = 0;\n  const referenceInput = inputs[referenceIndex];\n  const inputType = referenceInput.dataType;\n  const inputRank = referenceInput.dims.length;\n  inputs.forEach((input, i) => {\n    if (i === referenceIndex) {\n      return;\n    }\n    // make sure types of all inputs match\n    if (input.dataType !== inputType) {\n      throw new Error('input tensors should be one type');\n    }\n    // make sure the dimensionality of all inputs are the same\n    if (input.dims.length !== inputRank) {\n      throw new Error('input tensors should have the same shape');\n    }\n    input.dims.forEach((dim, i) => {\n      if (i !== axis && dim !== referenceInput.dims[i]) {\n        throw new Error('non concat dimensions must match');\n      }\n    });\n  });\n};\n\nconst calculateInputIndexImpl = (numberOfTensors: number, sizeInConcatAxisStr: string): string => `\n  fn calculateInputIndex(index: u32) -> u32 {\n    let sizeInConcatAxis = array<u32, ${numberOfTensors}u>(${sizeInConcatAxisStr});\n    for (var i: u32 = 0u; i < ${numberOfTensors}; i += 1u ) {\n      if (index < sizeInConcatAxis[i]) {\n        return i;\n      }\n    }\n    return ${numberOfTensors}u;\n  }`;\n\nconst assignOutputData = (inputs: readonly IndicesHelper[], output: IndicesHelper) => {\n  const numberOfTensors = inputs.length;\n\n  const codeLines: string[] = [];\n  for (let i = 0; i < numberOfTensors; ++i) {\n    const returnSnippet = output.setByOffset('global_idx', inputs[i].getByIndices('indices'));\n    if (numberOfTensors === 1) {\n      codeLines.push(returnSnippet);\n    } else if (i === 0) {\n      codeLines.push(`if (inputIndex == ${i}u) { ${returnSnippet} }`);\n    } else if (i === numberOfTensors - 1) {\n      codeLines.push(`else { ${returnSnippet} }`);\n    } else {\n      codeLines.push(`else if (inputIndex == ${i}) { ${returnSnippet} }`);\n    }\n  }\n  return codeLines.join('\\n');\n};\n\nexport const createConcatProgramInfo =\n    (inputs: readonly TensorView[], adjustedAxis: number, outputShape: number[], dataType: DataType): ProgramInfo => {\n      const outputSize = ShapeUtil.size(outputShape);\n\n      const sizeInConcatAxis = new Array<number>(inputs.length);\n      const inputVars = new Array<IndicesHelper>(inputs.length);\n\n      let previousSum = 0;\n      const inputDependencies: ProgramInputTensorInfoDependency[] = [];\n      const inputRanks = [];\n      const programUniforms: ProgramUniform[] = [{type: DataType.uint32, data: outputSize}];\n      for (let i = 0; i < inputs.length; ++i) {\n        previousSum += inputs[i].dims[adjustedAxis];\n        sizeInConcatAxis[i] = previousSum;\n        inputRanks.push(inputs[i].dims.length);\n        inputVars[i] = inputVariable(`input${i}`, dataType, inputRanks[i]);\n        inputDependencies.push('rank');\n        programUniforms.push({type: DataType.uint32, data: sizeInConcatAxis[i]});\n      }\n      for (let i = 0; i < inputs.length; ++i) {\n        programUniforms.push(...createTensorShapeVariables(inputs[i].dims));\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShape));\n\n      const output = outputVariable('output', dataType, outputShape.length);\n      const indicesAxis = output.indicesGet('indices', adjustedAxis);\n      const sizeInConcatAxisStr =\n          Array.from(Array(sizeInConcatAxis.length).keys()).map(i => `uniforms.sizeInConcatAxis${i}`).join(',');\n      const getShaderSource = (shaderHelper: ShaderHelper) => `\n\n  ${(() => {\n        shaderHelper.registerUniform('outputSize', 'u32');\n        for (let i = 0; i < inputs.length; i++) {\n          shaderHelper.registerUniform(`sizeInConcatAxis${i}`, 'u32');\n        }\n        return shaderHelper.declareVariables(...inputVars, output);\n      })()}\n\n  ${calculateInputIndexImpl(sizeInConcatAxis.length, sizeInConcatAxisStr)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n\n    var indices = ${output.offsetToIndices('global_idx')};\n\n    let inputIndex = calculateInputIndex(${indicesAxis});\n    if (inputIndex != 0u) {\n      let sizeInConcatAxis = array<u32, ${sizeInConcatAxis.length}u>(${sizeInConcatAxisStr});\n      ${indicesAxis} -= sizeInConcatAxis[inputIndex - 1u];\n    }\n\n    ${assignOutputData(inputVars, output)}\n  }`;\n\n      return {\n        name: 'Concat',\n        shaderCache: {hint: `${adjustedAxis}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms,\n        }),\n        getShaderSource,\n      };\n    };\n\nexport const concat = (context: ComputeContext, attributes: ConcatAttributes): void => {\n  const inputs = context.inputs;\n  const inputShape = inputs[0].dims;\n  const adjustedAxis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);\n  validateInputs(inputs, adjustedAxis);\n  const outputShape = inputShape.slice();\n  outputShape[adjustedAxis] =\n      inputs.reduce((sum, input) => sum + (input.dims.length > adjustedAxis ? input.dims[adjustedAxis] : 0), 0);\n  // 0 length tensors are valid for concat, remove them\n  const nonEmptyInputs = inputs.filter(input => ShapeUtil.size(input.dims) > 0);\n  context.compute(\n      createConcatProgramInfo(nonEmptyInputs, adjustedAxis, outputShape, inputs[0].dataType), {inputs: nonEmptyInputs});\n};\n\nexport const parseConcatAttributes = (attributes: Record<string, unknown>): ConcatAttributes =>\n    createAttributeWithCacheKey({axis: attributes.axis as number});\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ComputeContext, GpuDataType, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, getMaxComponents, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, tensorTypeToWsglValueType, UniformDataElementType, UniformsArrayType} from './common';\nimport {createConcatProgramInfo} from './concat';\n\nexport const enum AttentionQkvFormat {\n  unknown,          // enum value not set, or depends on qkv projection implementation details\n  qkvBNSH,          // for non-packed qkv, permuted\n  qkvBSNH,          // for non-packed qkv, not permuted, used by memory efficient attention or MultiHeadAttention\n  qkvBSN3H,         // for TRT fused attention, qkv are packed\n  qkvBNSHqkvBS3NH,  // for TRT fused causal attention, data has two formats (qkv is 3BNSH, gemm_buffer is BS3NH)\n  qKvBSNHxBSN2H,    // for TRT fused cross attention, kv are packed\n  qkvTNH,           // for memory efficient attention, qkv are not packed, and paddings are removed.\n  qkvTN3H,          // for TRT fused attention, qkv are packed and paddings are removed\n}\n\nexport const enum AttentionMaskType {\n  none,                  // No mask\n  mask1dKeySeqLen,       // [batch_size], key sequence length\n  mask1dEndStart,        // [2 * batch_size] with end positions and start positions\n  mask1DKeySeqLenStart,  // [3 * batch_size + 2] with [key_len[0], ..., key_len[batch_size - 1], query_start[0],\n                         // ..., query_start[batch_size - 1], query_end[batch_size - 1], key_start[0], ...,\n                         // key_start[batch_size - 1], key_end[batch_size - 1]]\n  mask2dDummy,           // dummy mask with shape [1, 1] or [batch_size, 1]. It has same effect as no mask.\n  mask2dKeyPadding,      // [batch_size, total_sequence_length]\n  mask3dAttention,       // [batch_size, sequence_length, total_sequence_length]\n  mask4dMegatron,        // Megatron causal mask with shape [batch_size, 1, max_sequence_length, max_sequence_length]\n  maskUnknown\n}\n\nexport interface AttentionParameters {\n  batchSize: number;\n  sequenceLength: number;\n  pastSequenceLength: number;\n  kvSequenceLength: number;\n  totalSequenceLength: number;\n  maxSequenceLength: number;\n  inputHiddenSize: number;\n  hiddenSize: number;\n  vHiddenSize: number;\n  headSize: number;\n  vHeadSize: number;\n  numHeads: number;\n  isUnidirectional: boolean;\n  pastPresentShareBuffer: boolean;\n  maskFilterValue: number;\n  maskType: AttentionMaskType;\n  scale: number;\n  broadcastResPosBias: boolean;\n  passPastInKv: boolean;\n  qkvFormat: AttentionQkvFormat;\n}\n\nexport interface AttentionAttrs {\n  numHeads: number;\n  isUnidirectional: number;\n  maskFilterValue: number;\n  scale: number;\n  doRotary: number;\n  qkvHiddenSizes: number[];\n  pastPresentShareBuffer: boolean;\n}\n\nconst validateAttentionInputs = (inputs: readonly TensorView[], attributes: AttentionAttrs): AttentionParameters => {\n  // Abbreviation and Meanings:\n  //   B:    batch_size\n  //   S:    sequence_length (input sequence length of query)\n  //   P:    past_sequence_length (past sequence length of key or value)\n  //   L:    kv_sequence_length (input sequence length of key or value)\n  //   M:    max_sequence_length\n  //   T:    total_sequence_length = past_sequence_length + kv_sequence_length\n  //   N:    num_heads\n  //   H:    head size for Q and K, aka q_head_size or k_head_size or qk_head_size\n  //   H_v:  v_head_size\n  //   D_i:  input hidden size\n  //   D:    hidden size for Q and K (D = N * H), aka q_hidden_size or k_hidden_size or qk_hidden_size\n  //   D_v:  v_hidden_size = num_heads * v_head_size\n\n  // When past state is used, Q, K and V should have same hidden size (unless we split it into past_key and past_value).\n\n  // Input shapes:\n  //   input        (Q/K/V)    : (B, S, D_i)\n  //   weights      (Q/K/V)    : (D_i, D + D + D_v)\n  //   bias         (Q/K/V)    : (D + D + D_v)\n  //   mask_index              : see below\n  //   past         (K/V)      : (2, B, N, P, H) or NULL\n  //   relative_position_bias            : (B, N, S, T) or NULL\n\n  // For mask_index, the following shapes are supported:\n  //     NULL, (B, 1), (1, 1)\n  //     (B), (2 * B), (3 * B + 2)\n  //     (B, T)\n  //     (B, S, T)\n  //     (B, 1, M, M)\n  //\n  // When a model is pruned (like some attention heads are removed in Q/K/V), input_hidden_size could be larger\n  // than hidden dimension of Q, K and V.\n\n  const input = inputs[0];\n  const weights = inputs[1];\n  const bias = inputs[2];\n  const maskIndex = inputs[3];\n  const past = inputs[4];\n  const relativePositionBias = inputs[5];\n\n  if (past && relativePositionBias) {\n    throw new Error('Attention cannot have both past and relative_position_bias');\n  }\n\n  if (input.dims.length !== 3) {\n    throw new Error('Input \"input\" must have 3 dimensions');\n  }\n\n  const batchSize = input.dims[0];\n  const sequenceLength = input.dims[1];\n  const inputHiddenSize = input.dims[2];\n\n  if (bias.dims.length !== 1) {\n    throw new Error('Input \"bias\" is expected to have 1 dimensions');\n  }\n\n  if (weights.dims.length !== 2) {\n    throw new Error('Input \"weights\" is expected to have 2 dimensions');\n  }\n\n  if (weights.dims[0] !== inputHiddenSize) {\n    throw new Error('Input 1 dimension 0 should have same length as dimension 2 of input 0');\n  }\n\n  if (bias.dims[0] !== weights.dims[1]) {\n    throw new Error('Input \"bias\" dimension 0 should have same length as dimension 1 of input \"weights\"');\n  }\n\n  let qHiddenSize = bias.dims[0] / 3;\n  let kHiddenSize = qHiddenSize;\n  let vHiddenSize = kHiddenSize;\n  if (attributes.qkvHiddenSizes.length > 0) {\n    if (attributes.qkvHiddenSizes.length !== 3) {\n      throw new Error('qkv_hidden_sizes attribute should have 3 elements');\n    }\n    for (const sz of attributes.qkvHiddenSizes) {\n      if (sz % attributes.numHeads !== 0) {\n        throw new Error('qkv_hidden_sizes should be divisible by num_heads');\n      }\n    }\n\n    qHiddenSize = attributes.qkvHiddenSizes[0];\n    kHiddenSize = attributes.qkvHiddenSizes[1];\n    vHiddenSize = attributes.qkvHiddenSizes[2];\n  }\n\n  const kvSequenceLength = sequenceLength;\n\n  if (qHiddenSize !== kHiddenSize) {\n    throw new Error('qkv_hidden_sizes first element should be same as the second');\n  }\n\n  if (bias.dims[0] !== qHiddenSize + kHiddenSize + vHiddenSize) {\n    throw new Error('Input \"bias\" dimension 0 should have same length as sum of Q/K/V hidden sizes');\n  }\n\n  let pastSequenceLength = 0;\n  if (past) {\n    if (kHiddenSize !== vHiddenSize) {\n      throw new Error('Input \"past\" expect k_hidden_size == v_hidden_size');\n    }\n    if (past.dims.length !== 5) {\n      throw new Error('Input \"past\" must have 5 dimensions');\n    }\n    if (past.dims[0] !== 2) {\n      throw new Error('Input \"past\" first dimension must be 2');\n    }\n    if (past.dims[1] !== batchSize) {\n      throw new Error('Input \"past\" second dimension must be batch_size');\n    }\n    if (past.dims[2] !== attributes.numHeads) {\n      throw new Error('Input \"past\" third dimension must be num_heads');\n    }\n    if (past.dims[4] !== kHiddenSize / attributes.numHeads) {\n      throw new Error('Input \"past\" fifth dimension must be k_hidden_size / num_heads');\n    }\n\n    if (!attributes.pastPresentShareBuffer) {\n      pastSequenceLength = past.dims[3];\n    }\n    // TODO: handle past_seq_len\n  }\n\n  const totalSequenceLength = kvSequenceLength + pastSequenceLength;\n  const maxSequenceLength = -1;\n\n  const maskType = AttentionMaskType.none;\n  if (maskIndex) {\n    // maskType = AttentionMaskType.MASK_UNKNOWN;\n    // TODO: handle mask\n    throw new Error('Mask not supported');\n  }\n\n  if (past) {\n    throw new Error('past is not supported');\n  }\n\n  return {\n    batchSize,\n    sequenceLength,\n    pastSequenceLength,\n    kvSequenceLength,\n    totalSequenceLength,\n    maxSequenceLength,\n    inputHiddenSize,\n    hiddenSize: qHiddenSize,\n    vHiddenSize,\n    headSize: Math.floor(qHiddenSize / attributes.numHeads),\n    vHeadSize: Math.floor(vHiddenSize / attributes.numHeads),\n    numHeads: attributes.numHeads,\n    isUnidirectional: false,\n    pastPresentShareBuffer: false,\n    maskFilterValue: attributes.maskFilterValue,\n    maskType,\n    scale: attributes.scale,\n    broadcastResPosBias: false,\n    passPastInKv: false,\n    qkvFormat: AttentionQkvFormat.qkvBNSH,\n  };\n};\n\nconst createInPlaceSoftmaxProgramInfo = (_context: ComputeContext, input: TensorView, n: number, d: number) => {\n  const components = getMaxComponents(d);\n  let WG = 64;\n  const dComp = d / components;\n  if (dComp < WG) {\n    WG = 1;\n  } else if (dComp / 8 < 64) {\n    WG = Math.ceil(dComp / 8);\n  }\n  const elementsPerThread = Math.ceil(d / components / WG);\n  const programUniforms: ProgramUniform[] = [\n    {type: input.dataType, data: 1 / d}, {type: DataType.uint32, data: dComp},\n    {type: DataType.uint32, data: elementsPerThread}\n  ];\n  const dataType = tensorTypeToWsglStorageType(input.dataType, components);\n  const f32Type = tensorTypeToWsglValueType(DataType.float, components);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const inputHelper = outputVariable('x', input.dataType, input.dims, components);\n    const elemValueType = tensorTypeToWsglValueType(input.dataType);\n    const uniforms: UniformsArrayType = [\n      {name: 'd_inv', type: elemValueType as UniformDataElementType}, {name: 'd_comp', type: 'u32'},\n      {name: 'elements_per_thread', type: 'u32'}\n    ];\n\n    return `\n  var<workgroup> thread_max: array<f32, ${WG}>;\n  var<workgroup> thread_sum: array<f32, ${WG}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(inputHelper)}\n  ${shaderHelper.mainStart([\n      WG, 1, 1\n    ])}\n    let local_offset = local_idx * uniforms.elements_per_thread;\n    let offset = workgroup_id.x * uniforms.d_comp + local_offset;\n\n    var thread_max_vector = ${f32Type}(-3.402823e+38f);\n    for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n      thread_max_vector = max(${f32Type}(x[offset + i]), thread_max_vector);\n    }\n    thread_max[local_idx] = ${(() => {\n      switch (components) {\n        case 1:\n          return 'thread_max_vector';\n        case 2:\n          return 'max(thread_max_vector.x, thread_max_vector.y)';\n        case 4:\n          return 'max(max(thread_max_vector.x, thread_max_vector.y), max(thread_max_vector.z, thread_max_vector.w))';\n        default:\n          throw new Error(`Unsupported components: ${components}`);\n      }\n    })()};\n    workgroupBarrier();\n\n    var max_value =  f32(-3.402823e+38f);\n    for (var i = 0u; i < ${WG}; i++) {\n      max_value = max(thread_max[i], max_value);\n    }\n\n    var sum_vector = ${f32Type}(0);\n    for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n      sum_vector += exp(${f32Type}(x[offset + i]) - max_value);\n    }\n    thread_sum[local_idx] = ${(() => {\n      switch (components) {\n        case 1:\n          return 'sum_vector';\n        case 2:\n          return 'sum_vector.x + sum_vector.y';\n        case 4:\n          return 'sum_vector.x + sum_vector.y + sum_vector.z + sum_vector.w';\n        default:\n          throw new Error(`Unsupported components: ${components}`);\n      }\n    })()};\n    workgroupBarrier();\n\n    var sum: f32 = 0;\n    for (var i = 0u; i < ${WG}; i++) {\n      sum += thread_sum[i];\n    }\n\n    if (sum == 0) {\n      for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n        x[offset + i] = ${inputHelper.type.value}(uniforms.d_inv);\n      }\n    } else {\n      for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < uniforms.d_comp; i++) {\n        var f32input = ${f32Type}(x[offset + i]);\n        x[offset + i] = ${inputHelper.type.value}(exp(f32input - max_value) / sum);\n      }\n    }\n  }`;\n  };\n\n  return {\n    name: 'AttentionProbsSoftmax',\n    shaderCache: {hint: `${WG};${dataType};${components}`},\n    getShaderSource,\n    getRunData: () => ({outputs: [], dispatchGroup: {x: n}, programUniforms}),\n  };\n};\n\nconst createAttentionProbsProgramInfo =\n    (_context: ComputeContext, q: TensorView, key: TensorView, relativePositionBias: TensorView|undefined,\n     parameters: AttentionParameters, attributes: AttentionAttrs, pastSequenceLength: number) => {\n      const totalSequenceLength = pastSequenceLength + parameters.kvSequenceLength;\n      const probsShape = [parameters.batchSize, parameters.numHeads, parameters.sequenceLength, totalSequenceLength];\n\n      // TODO: handle mask\n\n      const alpha = attributes.scale === 0 ? 1.0 / Math.sqrt(parameters.headSize) : attributes.scale;\n      const components = getMaxComponents(parameters.headSize);\n      const vectorizedHeadSize = parameters.headSize / components;\n      const TILE_SIZE = 12;\n      const dispatch = {\n        x: Math.ceil(totalSequenceLength / TILE_SIZE),\n        y: Math.ceil(parameters.sequenceLength / TILE_SIZE),\n        z: parameters.batchSize * parameters.numHeads\n      };\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: parameters.sequenceLength}, {type: DataType.uint32, data: vectorizedHeadSize},\n        {type: DataType.uint32, data: totalSequenceLength}, {type: DataType.uint32, data: parameters.numHeads},\n        {type: DataType.float, data: alpha}\n      ];\n\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n      if (relativePositionBias) {\n        inputDependencies.push('rank');\n        programUniforms.push(...createTensorShapeVariables(relativePositionBias.dims));\n      }\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const qInput = inputVariable('q', q.dataType, q.dims, components);\n        const kInput = inputVariable('key', key.dataType, key.dims, components);\n        const inputVars = [qInput, kInput];\n        const relativePositionBiasInput = relativePositionBias ?\n            inputVariable('relative_position_bias', relativePositionBias.dataType, relativePositionBias.dims.length) :\n            undefined;\n        if (relativePositionBiasInput) {\n          inputVars.push(relativePositionBiasInput);\n        }\n        const output = outputVariable('output', q.dataType, probsShape);\n        // const dataType = tensorTypeToWsglStorageType(q.dataType);\n        const f32Type = tensorTypeToWsglValueType(DataType.float, components);\n\n        const uniforms: UniformsArrayType = [\n          {name: 'M', type: 'u32'}, {name: 'K', type: 'u32'}, {name: 'N', type: 'u32'},\n          {name: 'num_heads', type: 'u32'}, {name: 'alpha', type: 'f32' as UniformDataElementType}\n        ];\n        return `\n  const TILE_SIZE = ${TILE_SIZE}u;\n\n  var<workgroup> tileQ: array<${qInput.type.storage}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileK: array<${qInput.type.storage}, ${TILE_SIZE * TILE_SIZE}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}\n  ${shaderHelper.mainStart([\n          TILE_SIZE, TILE_SIZE, 1\n        ])}\n    // x holds the N and y holds the M\n    let headIdx = workgroup_id.z;\n    let m = workgroup_id.y * TILE_SIZE;\n    let n = workgroup_id.x * TILE_SIZE;\n    let qOffset = uniforms.M * uniforms.K * headIdx + m * uniforms.K;\n    let kOffset = uniforms.N * uniforms.K * headIdx + n * uniforms.K;\n\n    var value = ${f32Type}(0);\n    for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n      if (global_id.y < uniforms.M && w + local_id.x < uniforms.K) {\n        tileQ[TILE_SIZE * local_id.y + local_id.x] = q[qOffset + local_id.y * uniforms.K + w + local_id.x];\n      }\n      if (n + local_id.y < uniforms.N && w + local_id.x < uniforms.K) {\n        tileK[TILE_SIZE * local_id.y + local_id.x] = key[kOffset + local_id.y * uniforms.K + w + local_id.x];\n      }\n      workgroupBarrier();\n\n      for (var k: u32 = 0u; k < TILE_SIZE && w+k < uniforms.K; k++) {\n        value += ${f32Type}(tileQ[TILE_SIZE * local_id.y + k] * tileK[TILE_SIZE * local_id.x + k]);\n      }\n\n      workgroupBarrier();\n    }\n\n    let headOffset = headIdx * uniforms.M * uniforms.N;\n    if (global_id.y < uniforms.M && global_id.x < uniforms.N) {\n      let outputIdx = headOffset + global_id.y * uniforms.N + global_id.x;\n      var sum: f32 = ${(() => {\n          switch (components) {\n            case 1:\n              return 'value';\n            case 2:\n              return 'value.x + value.y';\n            case 4:\n              return 'value.x + value.y + value.z + value.w';\n            default:\n              throw new Error(`Unsupported components: ${components}`);\n          }\n        })()};\n\n  ${(() => {\n          if (relativePositionBiasInput) {\n            return `\n      let batch = workgroup_id.z / uniforms.num_heads;\n      let head = workgroup_id.z % uniforms.num_heads;\n      var indices = ${relativePositionBiasInput.type.indices}(batch, head, global_id.y, global_id.x);\n      output[outputIdx] = ${output.type.value}(sum * uniforms.alpha) + ${\n                relativePositionBiasInput.getByIndices('indices')};`;\n          }\n          return `output[outputIdx] = ${output.type.value} (sum * uniforms.alpha);`;\n        })()}\n    }\n  }`;\n      };\n      return {\n        name: 'AttentionProbs',\n        shaderCache: {hint: `${components}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: probsShape, dataType: q.dataType, gpuDataType: GpuDataType.default}],\n          dispatchGroup: dispatch,\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n\n\nconst createVxAttentionScoreProgramInfo =\n    (_context: ComputeContext, probs: TensorView, v: TensorView, params: AttentionParameters,\n     pastSequenceLength: number) => {\n      const totalSequenceLength = pastSequenceLength + params.kvSequenceLength;\n      const outputShape = [params.batchSize, params.sequenceLength, params.vHiddenSize];\n      const TILE_SIZE = 12;\n      const dispatch = {\n        x: Math.ceil(params.vHeadSize / TILE_SIZE),\n        y: Math.ceil(params.sequenceLength / TILE_SIZE),\n        z: params.batchSize * params.numHeads\n      };\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: params.sequenceLength}, {type: DataType.uint32, data: totalSequenceLength},\n        {type: DataType.uint32, data: params.vHeadSize}, {type: DataType.uint32, data: params.numHeads},\n        {type: DataType.uint32, data: params.vHiddenSize}\n      ];\n\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const probsHelper = inputVariable('probs', probs.dataType, probs.dims);\n        const vHelper = inputVariable('v', v.dataType, v.dims);\n        const output = outputVariable('output', probs.dataType, outputShape);\n        const uniforms: UniformsArrayType = [\n          {name: 'M', type: 'u32'}, {name: 'K', type: 'u32'}, {name: 'N', type: 'u32'},\n          {name: 'num_heads', type: 'u32'}, {name: 'v_hidden_size', type: 'u32'}\n        ];\n        return `\n  const TILE_SIZE = ${TILE_SIZE}u;\n  var<workgroup> tileQ: array<${probsHelper.type.value}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileK: array<${probsHelper.type.value}, ${TILE_SIZE * TILE_SIZE}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(probsHelper, vHelper, output)}\n  ${shaderHelper.mainStart([\n          TILE_SIZE, TILE_SIZE, 1\n        ])}\n   let headIdx = workgroup_id.z;\n   let m = global_id.y;\n   let n = global_id.x;\n\n   let offsetA = headIdx * (uniforms.M * uniforms.K) + m * uniforms.K;\n   let offsetB = headIdx * (uniforms.N * uniforms.K) + n;\n\n   var value = ${probsHelper.type.storage}(0);\n   for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n     if (m < uniforms.M && w + local_id.x < uniforms.K) {\n       tileQ[TILE_SIZE * local_id.y + local_id.x] = probs[offsetA + w + local_id.x];\n     }\n     if (n < uniforms.N && w + local_id.y < uniforms.K) {\n       tileK[TILE_SIZE * local_id.y + local_id.x] = v[offsetB + (w + local_id.y) * uniforms.N];\n     }\n     workgroupBarrier();\n     for (var k: u32 = 0u; k < TILE_SIZE && w+k < uniforms.K; k++) {\n       value += tileQ[TILE_SIZE * local_id.y + k] * tileK[TILE_SIZE * k + local_id.x];\n     }\n     workgroupBarrier();\n   }\n\n   // we need to transpose output from BNSH_v to BSND_v\n   let batchIdx = workgroup_id.z / uniforms.num_heads;\n   let currentBatchHeadNumber = workgroup_id.z % uniforms.num_heads;\n   if (m < uniforms.M && n < uniforms.N) {\n     let outputIdx = batchIdx * uniforms.M * uniforms.v_hidden_size + m * uniforms.v_hidden_size\n       + currentBatchHeadNumber * uniforms.N + n;\n     output[outputIdx] = value;\n   }\n  }`;\n      };\n\n      return {\n        name: 'AttentionScore',\n        shaderCache: {inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: probs.dataType, gpuDataType: GpuDataType.default}],\n          dispatchGroup: dispatch,\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n\nexport const applyAttention =\n    (context: ComputeContext, q: TensorView, k: TensorView, v: TensorView, _maskIndex: TensorView|undefined,\n     _past: TensorView|undefined, pastKey: TensorView|undefined, pastValue: TensorView|undefined,\n     relativePositionBias: TensorView|undefined, parameters: AttentionParameters, attributes: AttentionAttrs) => {\n      const outputPresentKey = context.outputCount > 1;\n      const outputPresentValue = context.outputCount > 2;\n      const pastSequenceLength = (outputPresentKey && outputPresentValue) ? parameters.pastSequenceLength : 0;\n      const totalSequenceLength = pastSequenceLength + parameters.kvSequenceLength;\n      // Concatinate pastKey and K to produce presentKey.\n      const presentKeyShape = [parameters.batchSize, parameters.numHeads, totalSequenceLength, parameters.headSize];\n      const concatKeyInputs = pastKey ? [pastKey, k] : [k];\n      const key = outputPresentKey ? context.compute(\n                                         createConcatProgramInfo(concatKeyInputs, 2, presentKeyShape, k.dataType),\n                                         {inputs: concatKeyInputs, outputs: [1]})[0] :\n                                     k;\n\n      // Concatinate pastValue and V to produce presentValue.\n      const presentValueShape = [parameters.batchSize, parameters.numHeads, totalSequenceLength, parameters.headSize];\n      const concatValueInputs = pastValue ? [pastValue, v] : [v];\n      const value = outputPresentValue ?\n          context.compute(\n              createConcatProgramInfo(concatValueInputs, 2, presentValueShape, v.dataType),\n              {inputs: concatValueInputs, outputs: [2]})[0] :\n          v;\n      const inputsK = [q, key];\n      if (relativePositionBias) {\n        inputsK.push(relativePositionBias);\n      }\n\n      // Run AttentionProbs\n      const probs = context.compute(\n          createAttentionProbsProgramInfo(\n              context, q, key, relativePositionBias, parameters, attributes, pastSequenceLength),\n          {inputs: inputsK, outputs: [-1]})[0];\n\n      // Run Softmax\n      context.compute(\n          createInPlaceSoftmaxProgramInfo(\n              context, probs, parameters.batchSize * parameters.numHeads * parameters.sequenceLength,\n              totalSequenceLength),\n          {inputs: [probs], outputs: []});\n\n      // Run AttrionScore\n      const inputsV = [probs, value];\n      context.compute(\n          createVxAttentionScoreProgramInfo(context, probs, value, parameters, pastSequenceLength),\n          {inputs: inputsV, outputs: [0]});\n    };\n\nconst prepare = (context: ComputeContext, parameters: AttentionParameters) => {\n  const outputShape = [\n    parameters.batchSize,\n    parameters.numHeads,\n    parameters.sequenceLength,\n    parameters.headSize,\n  ];\n  const M = parameters.sequenceLength;\n  const K = parameters.inputHiddenSize;\n  const N = parameters.headSize;\n  const TILE_SIZE = 12;\n  const dispatch = {\n    x: Math.ceil(parameters.headSize / TILE_SIZE),\n    y: Math.ceil(parameters.sequenceLength / TILE_SIZE),\n    z: parameters.batchSize * parameters.numHeads\n  };\n  const inputs = [context.inputs[0], context.inputs[1], context.inputs[2]];\n  const programUniforms: ProgramUniform[] = [\n    {type: DataType.uint32, data: M}, {type: DataType.uint32, data: K}, {type: DataType.uint32, data: N},\n    {type: DataType.uint32, data: parameters.numHeads}, {type: DataType.uint32, data: parameters.headSize},\n    {type: DataType.uint32, data: parameters.hiddenSize},\n    {type: DataType.uint32, data: parameters.hiddenSize + parameters.hiddenSize + parameters.vHiddenSize}\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const outputQ = outputVariable('output_q', inputs[0].dataType, outputShape);\n    const outputK = outputVariable('output_k', inputs[0].dataType, outputShape);\n    const outputV = outputVariable('output_v', inputs[0].dataType, outputShape);\n    const input = inputVariable('input', inputs[0].dataType, inputs[0].dims);\n    const weight = inputVariable('weight', inputs[1].dataType, inputs[1].dims);\n    const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims);\n    const dataType = input.type.storage;\n\n    const uniforms: UniformsArrayType = [\n      {name: 'M', type: 'u32'}, {name: 'K', type: 'u32'}, {name: 'N', type: 'u32'}, {name: 'num_heads', type: 'u32'},\n      {name: 'head_size', type: 'u32'}, {name: 'hidden_size', type: 'u32'}, {name: 'ldb', type: 'u32'}\n    ];\n    return `\n  const TILE_SIZE = ${TILE_SIZE}u;\n  var<workgroup> tileInput: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileWeightQ: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileWeightK: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileWeightV: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(input, weight, bias, outputQ, outputK, outputV)}\n  ${shaderHelper.mainStart([\n      TILE_SIZE, TILE_SIZE, 1\n    ])}\n    let batchIndex = workgroup_id.z / uniforms.num_heads;\n    let headNumber = workgroup_id.z % uniforms.num_heads;\n    let m = global_id.y;\n    let n = global_id.x;\n\n    let inputOffset = batchIndex * (uniforms.M * uniforms.K) + m * uniforms.K;\n    let biasOffsetQ = headNumber * uniforms.head_size;\n    let biasOffsetK = uniforms.hidden_size + biasOffsetQ;\n    let biasOffsetV = uniforms.hidden_size + biasOffsetK;\n\n    var valueQ = ${dataType}(0);\n    var valueK = ${dataType}(0);\n    var valueV = ${dataType}(0);\n    for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n      if (m < uniforms.M && w + local_id.x < uniforms.K) {\n        tileInput[TILE_SIZE * local_id.y + local_id.x] = input[inputOffset + w + local_id.x];\n      }\n      if (n < uniforms.N && w + local_id.y < uniforms.K) {\n        let offset = n + (w + local_id.y) * uniforms.ldb;\n        tileWeightQ[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetQ + offset];\n        tileWeightK[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetK + offset];\n        tileWeightV[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetV + offset];\n      }\n      workgroupBarrier();\n      for (var k: u32 = 0u; k<TILE_SIZE && w+k < uniforms.K; k++) {\n        let inputTileOffset = TILE_SIZE * local_id.y + k;\n        let weightTileOffset = TILE_SIZE * k + local_id.x;\n        valueQ += tileInput[inputTileOffset] * tileWeightQ[weightTileOffset];\n        valueK += tileInput[inputTileOffset] * tileWeightK[weightTileOffset];\n        valueV += tileInput[inputTileOffset] * tileWeightV[weightTileOffset];\n      }\n\n      workgroupBarrier();\n    }\n\n    let headOffset = (m * uniforms.N + n) % uniforms.head_size;\n    valueQ += bias[headOffset + biasOffsetQ];\n    valueK += bias[headOffset + biasOffsetK];\n    valueV += bias[headOffset + biasOffsetV];\n\n    let offset = workgroup_id.z * uniforms.M * uniforms.N;\n    if (m < uniforms.M && n < uniforms.N) {\n      let outputIdx = offset + m * uniforms.N + n;\n      output_q[outputIdx] = valueQ;\n      output_k[outputIdx] = valueK;\n      output_v[outputIdx] = valueV;\n    }\n  }`;\n  };\n\n  return context.compute(\n      {\n        name: 'AttentionPrepare',\n        shaderCache: {inputDependencies: ['type', 'type', 'type']},\n        getRunData: () => ({\n          outputs: [\n            {dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: GpuDataType.default},\n            {dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: GpuDataType.default},\n            {dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: GpuDataType.default},\n          ],\n          dispatchGroup: dispatch,\n          programUniforms\n        }),\n        getShaderSource,\n      },\n      {inputs, outputs: [-1, -1, -1]});\n};\n\nexport const attention = (context: ComputeContext, attributes: AttentionAttrs): void => {\n  const params = validateAttentionInputs(context.inputs, attributes);\n\n  const [q, k, v] = prepare(context, params);\n\n  return applyAttention(\n      context, q, k, v, context.inputs[4], undefined, undefined, undefined, context.inputs[5], params, attributes);\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {env} from 'onnxruntime-common';\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, getMaxComponents, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface BatchNormAttributes extends AttributeWithCacheKey {\n  readonly epsilon: number;\n  readonly momentum: number;\n  readonly spatial: boolean;\n  readonly trainingMode: boolean;\n  readonly format: 'NHWC'|'NCHW';\n  readonly outputCount: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: BatchNormAttributes): void => {\n  if (!inputs || inputs.length !== 5) {\n    throw new Error('BatchNormalization requires 5 inputs');\n  }\n\n  const checkShapeEqual = (actual: readonly number[], expected: readonly number[], message: string) => {\n    const r = expected.length;\n    if (r !== actual.length) {\n      throw new Error(`${message}: num dimensions != ${r}`);\n    }\n    expected.forEach((v, i) => {\n      if (v !== actual[i]) {\n        throw new Error(`${message}: dim[${i}] do not match`);\n      }\n    });\n  };\n\n  if (inputs[0].dims.length > 1) {\n    const shape = attributes.format === 'NHWC' ?\n        (attributes.spatial ? inputs[0].dims.slice(-1) :\n                              inputs[0].dims.slice(-1).concat(inputs[0].dims.slice(1, inputs[0].dims.length - 1))) :\n        inputs[0].dims.slice(1, attributes.spatial ? 2 : undefined);\n    checkShapeEqual(inputs[1].dims, shape, 'Invalid input scale');\n    checkShapeEqual(inputs[2].dims, shape, 'Invalid input B');\n    checkShapeEqual(inputs[3].dims, shape, 'Invalid input mean');\n    checkShapeEqual(inputs[4].dims, shape, 'Invalid input var');\n  } else {\n    checkShapeEqual(inputs[1].dims, [1], 'Invalid input scale');\n    checkShapeEqual(inputs[2].dims, [1], 'Invalid input B');\n    checkShapeEqual(inputs[3].dims, [1], 'Invalid input mean');\n    checkShapeEqual(inputs[4].dims, [1], 'Invalid input var');\n  }\n};\n\nconst createBatchNormInferenceProgramInfo =\n    (inputs: readonly TensorView[], attributes: BatchNormAttributes): ProgramInfo => {\n      const {epsilon, spatial, format} = attributes;\n      const yShape = inputs[0].dims;\n      const components = spatial ? getMaxComponents(yShape[yShape.length - 1]) : 1;\n      const cComponents = format === 'NHWC' && yShape.length > 1 ? components : 1;\n      const outputSize = ShapeUtil.size(yShape) / components;\n      // Only support uniforms for opset version >= 9 (spatial = true).\n      const useShapesUniforms = spatial;\n      const shapeOrRank = useShapesUniforms ? yShape.length : yShape;\n      const x = inputVariable('x', inputs[0].dataType, inputs[0].dims, components);\n      const scale = inputVariable('scale', inputs[1].dataType, inputs[1].dims, cComponents);\n      const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims, cComponents);\n      const inputMean = inputVariable('inputMean', inputs[3].dataType, inputs[3].dims, cComponents);\n      const inputVar = inputVariable('inputVar', inputs[4].dataType, inputs[4].dims, cComponents);\n      const y = outputVariable('y', inputs[0].dataType, shapeOrRank, components);\n      // TODO: support inputs with different data type. Current we need to make sure all inputs have the same data type.\n      // Otherwise, the shader compilation will fail.\n      const calcCOffset = (): string => {\n        let cOffset = '';\n        if (spatial) {\n          cOffset = `let cOffset = ${\n              yShape.length === 1   ? '0u' :\n                  format === 'NHWC' ? `outputIndices[${yShape.length - 1}] / ${components}` :\n                                      'outputIndices[1]'};`;\n        } else {\n          if (format === 'NCHW') {\n            cOffset = `\n            ${y.indicesSet('outputIndices', '0', '0')}\n            let cOffset = ${y.indicesToOffset('outputIndices')};`;\n          } else {\n            // update C channel.\n            cOffset = `var cIndices = ${scale.type.indices}(0);\n                       cIndices[0] = outputIndices[${yShape.length - 1}];`;\n            // update D1 x ... x Dn channels.\n            for (let i = 1; i < scale.rank; i++) {\n              cOffset += `cIndices[${i}] = outputIndices[${i}];`;\n            }\n            cOffset += `let cOffset = ${scale.indicesToOffset('cIndices')};`;\n          }\n        }\n        return cOffset;\n      };\n      const getInferenceModeShaderSource = (helper: ShaderHelper) => `\n  const epsilon = ${epsilon};\n  ${helper.registerUniform('outputSize', 'u32').declareVariables(x, scale, bias, inputMean, inputVar, y)}\n  ${helper.mainStart()}\n  ${helper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n    var outputIndices = ${y.offsetToIndices(`global_idx * ${components}`)};\n    ${calcCOffset()}\n    let scale = ${scale.getByOffset('cOffset')};\n    let bias = ${bias.getByOffset('cOffset')};\n    let inputMean = ${inputMean.getByOffset('cOffset')};\n    let inputVar = ${inputVar.getByOffset('cOffset')};\n    let x = ${x.getByOffset('global_idx')};\n    let value = (x - inputMean) * inverseSqrt(inputVar + epsilon) * scale + bias;\n    ${y.setByOffset('global_idx', 'value')}\n  }`;\n      return {\n        name: 'BatchNormalization',\n        shaderCache: {\n          hint: `${attributes.epsilon}_${attributes.format}_${spatial}_${components}`,\n          inputDependencies: useShapesUniforms ? ['rank', 'type', 'type', 'type', 'type'] : undefined,\n        },\n        getShaderSource: getInferenceModeShaderSource,\n        getRunData: () => ({\n          outputs: [{dims: inputs[0].dims, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms: useShapesUniforms ?\n              [\n                {type: DataType.uint32, data: outputSize},\n                ...createTensorShapeVariables(yShape),\n              ] :\n              [\n                {type: DataType.uint32, data: outputSize},\n              ],\n        }),\n      };\n    };\n\nexport const parseBatchNormAttributes = (attributes: Record<string, unknown>): BatchNormAttributes =>\n    createAttributeWithCacheKey(attributes as Omit<BatchNormAttributes, keyof AttributeWithCacheKey>);\n\nexport const batchNorm = (context: ComputeContext, attributes: Record<string, unknown>): void => {\n  const {inputs, outputCount} = context;\n  const updatedAttributes = parseBatchNormAttributes({...attributes, outputCount});\n  if (env.webgpu.validateInputContent) {\n    validateInputs(inputs, updatedAttributes);\n  }\n  if (attributes.trainingMode) {\n    throw new Error('BatchNormalization trainingMode is not supported yet.');\n  } else {\n    context.compute(createBatchNormInferenceProgramInfo(inputs, updatedAttributes));\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {inputVariable, outputVariable, ShaderHelper} from './common';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (inputs[0].dims.length !== 3) {\n    throw new Error('input should have 3 dimensions');\n  }\n\n  if (![320, 640, 1280].includes(inputs[0].dims[2])) {\n    throw new Error('number of channels should be 320, 640 or 1280');\n  }\n\n  if (inputs[1].dims.length !== 1) {\n    throw new Error('bias is expected to have 1 dimensions');\n  }\n\n  if (inputs[0].dims[2] !== inputs[1].dims[0]) {\n    throw new Error('last dimension of input and bias are not the same');\n  }\n};\n\nconst createBiasAddProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const outputShape = inputs[0].dims;\n\n  const channels = inputs[0].dims[2];\n  // since channel number can be only 320/640/1280, it's always divisable by 4\n  const outputSize = ShapeUtil.size(outputShape) / 4;\n\n  const dataType = inputs[0].dataType;\n  const input = inputVariable('input', dataType, outputShape, 4);\n  const bias = inputVariable('bias', dataType, [channels], 4);\n  const residual = inputVariable('residual', dataType, outputShape, 4);\n  const output = outputVariable('output', dataType, outputShape, 4);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  const channels = ${channels}u / 4;\n  ${shaderHelper.declareVariables(input, bias, residual, output)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}\n    let value = ${input.getByOffset('global_idx')}\n      + ${bias.getByOffset('global_idx % channels')} + ${residual.getByOffset('global_idx')};\n    ${output.setByOffset('global_idx', 'value')}\n  }`;\n\n  return {\n    name: 'BiasAdd',\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)}\n    }),\n    getShaderSource,\n  };\n};\n\nexport const biasAdd = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  context.compute(createBiasAddProgramInfo(context.inputs));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {MAX_CLIP, MIN_CLIP, ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglValueType} from './common';\n\ntype BuiltinFunctionName = string;\ntype ElementwiseCustomExpression = (expression: string) => string;\ntype ElementwiseFunctionCall = BuiltinFunctionName|ElementwiseCustomExpression;\n\nconst createElementwiseProgramShader =\n    (shaderHelper: ShaderHelper, datasize: number, inputDataType: number, outputDataType: number,\n     funcCall: ElementwiseFunctionCall, additionalImplementation?: string): string => {\n      const vecSize = Math.ceil(datasize / 4);\n\n      let expression = '';\n      if (typeof funcCall === 'string') {\n        expression = `${funcCall}(a)`;\n      } else {\n        expression = funcCall('a');\n      }\n\n      const input = inputVariable('inputData', inputDataType, [vecSize], 4);\n      const output = outputVariable('outputData', outputDataType, [vecSize], 4);\n\n      return `\n      ${shaderHelper.registerUniform('vec_size', 'u32').declareVariables(input, output)}\n\n  ${additionalImplementation ?? ''}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.vec_size')}\n\n    let a = ${input.getByOffset('global_idx')};\n    ${output.setByOffset('global_idx', expression)}\n  }`;\n    };\n\nconst createElementwiseProgramInfo =\n    (input: TensorView, name: string, funcCall: ElementwiseFunctionCall, additionalImplementation?: string,\n     cacheKey?: string, outputDataType: number = input.dataType): ProgramInfo => ({\n      name,\n      shaderCache: {hint: cacheKey, inputDependencies: ['type']},\n      getShaderSource: shaderHelper => createElementwiseProgramShader(\n          shaderHelper, ShapeUtil.size(input.dims), input.dataType, outputDataType, funcCall, additionalImplementation),\n      getRunData: (inputTensors) => ({\n        outputs: [{dims: input.dims, dataType: outputDataType}],\n        dispatchGroup:\n            {x: Math.ceil(ShapeUtil.size(inputTensors[0].dims) / 64 /* workgroup size */ / 4 /* vec size */)},\n        programUniforms: [\n          {type: DataType.uint32, data: Math.ceil(ShapeUtil.size(input.dims) / 4)},\n        ],\n      })\n    });\n\nexport const abs = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Abs', 'abs'));\n};\n\nexport const acos = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Acos', 'acos'));\n};\n\nexport const acosh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Acosh', 'acosh'));\n};\n\nexport const asin = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Asin', 'asin'));\n};\n\nexport const asinh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Asinh', 'asinh'));\n};\n\nexport const atan = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Atan', 'atan'));\n};\nexport const atanh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Atanh', 'atanh'));\n};\n\nexport interface CastAttributes extends AttributeWithCacheKey {\n  readonly to: number;\n  readonly saturate?: boolean;\n}\n\nexport const parseCastAttributes = (attributes: Record<string, unknown>): CastAttributes =>\n    createAttributeWithCacheKey(attributes as {to: number});\n\n\nexport const cast = (context: ComputeContext, attributes: CastAttributes): void => {\n  let func: ElementwiseFunctionCall;\n  switch (attributes.to) {\n    case DataType.float16:\n      func = 'vec4<f16>';\n      break;\n    case DataType.float:\n      func = 'vec4<f32>';\n      break;\n    case DataType.uint32:\n      func = 'vec4<u32>';\n      break;\n    case DataType.int32:\n      func = 'vec4<i32>';\n      break;\n    case DataType.bool:\n      func = 'vec4<bool>';\n      break;\n    default:\n      throw new RangeError(`not supported type (specified in attribute 'to' from 'Cast' operator): ${attributes.to}`);\n  }\n  context.compute(\n      createElementwiseProgramInfo(context.inputs[0], 'Cast', func, undefined, attributes.cacheKey, attributes.to));\n};\n\nexport interface ClipAttributes extends AttributeWithCacheKey {\n  readonly min: number;\n  readonly max: number;\n}\n\nconst generateClipAttributesFromInputs = (inputs: readonly TensorView[]): ClipAttributes => {\n  const min = (inputs.length >= 2 && inputs[1].data !== 0) ? inputs[1].getFloat32Array()[0] : MIN_CLIP;\n  const max = (inputs.length >= 3 && inputs[2].data !== 0) ? inputs[2].getFloat32Array()[0] : MAX_CLIP;\n  return createAttributeWithCacheKey({min, max});\n};\n\nexport const clip = (context: ComputeContext, clipAttributes: ClipAttributes): void => {\n  const attributes = context.inputs.length === 1 ? clipAttributes : generateClipAttributesFromInputs(context.inputs);\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(\n      createElementwiseProgramInfo(\n          context.inputs[0], 'Clip', a => `clamp(${a}, clip_min_, clip_max_)`, `\n    const clip_min_: vec4<${dataType}> = vec4(${dataType}(${attributes.min}));\n    const clip_max_: vec4<${dataType}> = vec4(${dataType}(${attributes.max}));\n`,\n          attributes.cacheKey),\n      {inputs: [0]});\n};\n\nexport const ceil = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Ceil', 'ceil'));\n};\n\nexport const cos = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Cos', 'cos'));\n};\n\nexport const cosh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Cosh', 'cosh'));\n};\n\nexport interface AlphaAttributes extends AttributeWithCacheKey {\n  readonly alpha: number;\n}\n\nexport const parseAlphaAttributes = (attributes: Record<string, unknown>): AlphaAttributes =>\n    createAttributeWithCacheKey(attributes as {alpha: number});\n\nexport const elu = (context: ComputeContext, attributes: AlphaAttributes): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'Elu', a => `elu_vf32(${a})`, `\n  const elu_alpha_ = ${dataType}(${attributes.alpha});\n\n  fn elu_f32(a: ${dataType}) -> ${dataType} {\n  return select((exp(a) - 1.0) * elu_alpha_, a, a >= 0.0);\n  }\n\n  fn elu_vf32(v: vec4<${dataType}>) -> vec4<${dataType}> {\n  return vec4(elu_f32(v.x), elu_f32(v.y), elu_f32(v.z), elu_f32(v.w));\n  }`,\n      attributes.cacheKey));\n};\n\nexport const erfImpl = (varType = 'f32') => `\nconst r0: ${varType} = 0.3275911;\nconst r1: ${varType} = 0.254829592;\nconst r2: ${varType} = -0.284496736;\nconst r3: ${varType} = 1.421413741;\nconst r4: ${varType} = -1.453152027;\nconst r5: ${varType} = 1.061405429;\n\nfn erf_vf32(v: vec4<${varType}>) -> vec4<${varType}> {\n  let absv = abs(v);\n  let x = 1.0 / (1.0 + r0 * absv);\n  return sign(v) * (1.0 - ((((r5 * x + r4) * x + r3) * x + r2) * x + r1) * x * exp(-absv * absv));\n}`;\n\nexport const erf = (context: ComputeContext): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Erf', a => `erf_vf32(${a})`, erfImpl(dataType)));\n};\n\nexport const exp = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Exp', 'exp'));\n};\n\nexport const floor = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Floor', 'floor'));\n};\n\nexport const gelu = (context: ComputeContext): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'Gelu', a => `0.5 * ${a} * (1.0 + erf_vf32(${a} * 0.7071067811865475))`, erfImpl(dataType)));\n};\n\nexport const leakyRelu = (context: ComputeContext, attributes: AlphaAttributes): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'LeakyRelu', a => `select(leaky_relu_alpha_ * ${a}, ${a}, ${a} >= vec4<${dataType}>(0.0))`,\n      `const leaky_relu_alpha_ = ${dataType}(${attributes.alpha});`, attributes.cacheKey));\n};\n\nexport const not = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Not', a => `!${a}`));\n};\n\nexport const neg = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Neg', a => `-${a}`));\n};\n\nexport const reciprocal = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Reciprocal', a => `1.0/${a}`));\n};\n\nexport const relu = (context: ComputeContext): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'Relu', a => `select(vec4<${dataType}>(0.0), ${a}, ${a} > vec4<${dataType}>(0.0))`));\n};\n\nexport const sigmoid = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Sigmoid', a => `(1.0 / (1.0 + exp(-${a})))`));\n};\n\nexport interface HardSigmoidAttributes extends AttributeWithCacheKey {\n  readonly alpha: number;\n  readonly beta: number;\n}\n\nexport const parseHardSigmoidAttributes = (attributes: Record<string, unknown>): HardSigmoidAttributes =>\n    createAttributeWithCacheKey(attributes as {\n      alpha: number;\n      beta: number;\n    });\n\nexport const hardSigmoid = (context: ComputeContext, attributes: HardSigmoidAttributes): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'HardSigmoid',\n      a => `max(vec4<${dataType}>(0.0), min(vec4<${dataType}>(1.0), ${attributes.alpha} * ${a} + vec4<${dataType}>(${\n          attributes.beta})))`,\n      undefined, attributes.cacheKey));\n};\n\nexport const sin = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Sin', 'sin'));\n};\n\nexport const sinh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Sinh', 'sinh'));\n};\n\nexport const sqrt = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Sqrt', 'sqrt'));\n};\n\nexport const tan = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Tan', 'tan'));\n};\n\nexport const tanhExpression = (a: string) => `sign(${a}) * (1 - exp(-2 * abs(${a}))) / (1 + exp(-2 * abs(${a})))`;\n\nexport const tanh = (context: ComputeContext): void => {\n  // TODO: revisit after https://github.com/gpuweb/gpuweb/issues/4458 is resolved\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Tanh', tanhExpression));\n};\n\nexport const fastGeluImpl = (varType = 'f32') => `\nconst fast_gelu_a: ${varType} = 0.5;\nconst fast_gelu_b: ${varType} = 0.7978845608028654;\nconst fast_gelu_c: ${varType} = 0.035677408136300125;\n\nfn tanh_v(v: vec4<${varType}>) -> vec4<${varType}> {\n  return ${tanhExpression('v')};\n}\n`;\n\nexport const fastGeluExpression = (x: string) =>\n    `(fast_gelu_a + fast_gelu_a * tanh_v(${x} * (fast_gelu_c * ${x} * ${x} + fast_gelu_b))) * ${x}`;\n\nexport const fastGelu = (context: ComputeContext): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'FastGelu', fastGeluExpression, fastGeluImpl(dataType), undefined,\n      context.inputs[0].dataType));\n};\n\nexport const thresholdedRelu = (context: ComputeContext, attributes: AlphaAttributes): number => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(\n      context.inputs[0], 'ThresholdedRelu', a => `select(vec4<${dataType}>(0.0), ${a}, ${a} > thresholded_relu_alpha_)`,\n      `const thresholded_relu_alpha_ = vec4<${dataType}>(${attributes.alpha});`, attributes.cacheKey));\n  return 0;\n};\n\nexport const log = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Log', 'log'));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType} from './common';\nimport {erfImpl} from './unary-op';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (inputs[0].dims.length !== 3) {\n    throw new Error('input should have 3 dimensions');\n  }\n\n  if (![2560, 5120, 10240].includes(inputs[0].dims[2])) {\n    throw new Error('hidden state should be 2560, 5120 or 10240');\n  }\n\n  if (inputs[1].dims.length !== 1) {\n    throw new Error('bias is expected to have 1 dimensions');\n  }\n\n  if (inputs[0].dims[2] !== inputs[1].dims[0]) {\n    throw new Error('last dimension of input and bias are not the same');\n  }\n};\n\nconst createBiasSplitGeluProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const outputShape = inputs[0].dims.slice();\n  outputShape[2] = outputShape[2] / 2;\n\n  const input = inputVariable('input', inputs[0].dataType, inputs[0].dims, 4);\n  const bias = inputVariable('bias', inputs[0].dataType, [inputs[0].dims[2]], 4);\n  const output = outputVariable('output', inputs[0].dataType, outputShape, 4);\n\n  const outputSize = ShapeUtil.size(outputShape) / 4;\n  const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  const M_SQRT2 = sqrt(2.0);\n  const halfChannels = ${inputs[0].dims[2] / 4 / 2}u;\n\n  ${shaderHelper.declareVariables(input, bias, output)}\n\n  ${erfImpl(dataType)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}\n    let biasIdx = global_idx % halfChannels;\n    let batchIndex = global_idx / halfChannels;\n    let inputOffset = biasIdx + batchIndex * halfChannels * 2;\n    let valueLeft = input[inputOffset] + bias[biasIdx];\n    let valueRight = input[inputOffset + halfChannels] + bias[biasIdx + halfChannels];\n    let geluRight = valueRight * 0.5 * (erf_vf32(valueRight / M_SQRT2) + 1);\n\n    ${output.setByOffset('global_idx', 'valueLeft * geluRight')}\n  }`;\n\n  return {\n    name: 'BiasSplitGelu',\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)}\n    }),\n    getShaderSource,\n  };\n};\n\nexport const biasSplitGelu = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  context.compute(createBiasSplitGeluProgramInfo(context.inputs));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {BroadcastUtil, ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\ntype BuiltinFunctionName = string;\ntype BinaryCustomExpression = (expressionA: string, expressionB: string) => string;\ntype BinaryFunctionCall = BuiltinFunctionName|BinaryCustomExpression|{\n  scalar: BinaryCustomExpression;\n  vector: BinaryCustomExpression;\n};\n\nconst createBinaryOpProgramShader =\n    (shaderHelper: ShaderHelper, dimsA: readonly number[], dimsB: readonly number[], dimsOutput: readonly number[],\n     vectorize: boolean, doBroadcast: boolean, sharedDimensionDivisibleBy4: boolean, funcCall: BinaryFunctionCall,\n     typeA: number, typeB: number, typeOutput: number, additionalImplementation?: string) => {\n      let expressionScalar: BinaryCustomExpression;\n      let expressionVector: BinaryCustomExpression;\n      if (typeof funcCall === 'string') {\n        expressionScalar = expressionVector = (a, b) => `${funcCall}((${a}),(${b}))`;\n      } else if (typeof funcCall === 'function') {\n        expressionScalar = expressionVector = funcCall;\n      } else {\n        expressionScalar = funcCall.scalar;\n        expressionVector = funcCall.vector;\n      }\n\n      const output = outputVariable('outputData', typeOutput, dimsOutput.length, 4);\n      const a = inputVariable('aData', typeA, dimsA.length, 4);\n      const b = inputVariable('bData', typeB, dimsB.length, 4);\n\n      let assignment: string;\n      if (vectorize) {\n        if (doBroadcast) {\n          const isAOneElement = ShapeUtil.size(dimsA) === 1;\n          const isBOneElement = ShapeUtil.size(dimsB) === 1;\n          const aLastDimDivisibleBy4 = dimsA.length > 0 && dimsA[dimsA.length - 1] % 4 === 0;\n          const bLastDimDivisibleBy4 = dimsB.length > 0 && dimsB[dimsB.length - 1] % 4 === 0;\n          if (isAOneElement || isBOneElement) {\n            assignment = output.setByOffset(\n                'global_idx',\n                expressionVector(\n                    isAOneElement ? `${a.type.value}(${a.getByOffset('0')}.x)` : a.getByOffset('global_idx'),\n                    isBOneElement ? `${b.type.value}(${b.getByOffset('0')}.x)` : b.getByOffset('global_idx')));\n          } else {\n            assignment = `\n            let outputIndices = ${output.offsetToIndices('global_idx * 4u')};\n            let offsetA = ${a.broadcastedIndicesToOffset('outputIndices', output)};\n            let offsetB = ${b.broadcastedIndicesToOffset('outputIndices', output)};\n            ${\n                output.setByOffset(\n                    'global_idx',\n                    expressionVector(\n                        sharedDimensionDivisibleBy4 || aLastDimDivisibleBy4 ?\n                            a.getByOffset('offsetA / 4u') :\n                            `${a.type.value}(${a.getByOffset('offsetA / 4u')}[offsetA % 4u])`,\n                        sharedDimensionDivisibleBy4 || bLastDimDivisibleBy4 ?\n                            b.getByOffset('offsetB / 4u') :\n                            `${b.type.value}(${b.getByOffset('offsetB / 4u')}[offsetB % 4u])`))}\n          `;\n          }\n        } else {\n          assignment = output.setByOffset(\n              'global_idx', expressionVector(a.getByOffset('global_idx'), b.getByOffset('global_idx')));\n        }\n      } else {\n        if (!doBroadcast) {\n          throw new Error('no necessary to use scalar implementation for element-wise binary op implementation.');\n        }\n\n        const singleAssignment = (resStr: string, x: number, typeCast = '') => {\n          const expressionA = `aData[indexA${x}][componentA${x}]`;\n          const expressionB = `bData[indexB${x}][componentB${x}]`;\n          return `\n            let outputIndices${x} = ${output.offsetToIndices(`global_idx * 4u + ${x}u`)};\n            let offsetA${x} = ${a.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n            let offsetB${x} = ${b.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n            let indexA${x} = offsetA${x} / 4u;\n            let indexB${x} = offsetB${x} / 4u;\n            let componentA${x} = offsetA${x} % 4u;\n            let componentB${x} = offsetB${x} % 4u;\n            ${resStr}[${x}] = ${typeCast}(${expressionScalar(expressionA, expressionB)});\n          `;\n        };\n        if (typeOutput === DataType.bool) {\n          assignment = `\n            var data = vec4<u32>(0);\n            ${singleAssignment('data', 0, 'u32')}\n            ${singleAssignment('data', 1, 'u32')}\n            ${singleAssignment('data', 2, 'u32')}\n            ${singleAssignment('data', 3, 'u32')}\n            outputData[global_idx] = dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(data));`;\n        } else {\n          assignment = `\n            ${singleAssignment('outputData[global_idx]', 0)}\n            ${singleAssignment('outputData[global_idx]', 1)}\n            ${singleAssignment('outputData[global_idx]', 2)}\n            ${singleAssignment('outputData[global_idx]', 3)}\n          `;\n        }\n      }\n\n      return `\n        ${shaderHelper.registerUniform('vec_size', 'u32').declareVariables(a, b, output)}\n\n        ${additionalImplementation ?? ''}\n\n        ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.vec_size')}\n        ${assignment}\n      }`;\n    };\n\nconst createBinaryOpProgramInfo =\n    (name: string, cacheKey: string, a: TensorView, b: TensorView, funcCall: BinaryFunctionCall,\n     additionalImplementation?: string, outputDataType: number = a.dataType): ProgramInfo => {\n      const isBroadcast = !ShapeUtil.areEqual(a.dims, b.dims);\n      let outputShape = a.dims;\n      let outputSize = ShapeUtil.size(a.dims);\n\n      let vectorize = false;\n      let sharedDimensionDivisibleBy4 = false;\n\n      // TODO: deal with zero-sized tensors (eg. dims=[1,0])\n      const cacheKeyAux = [isBroadcast];\n      if (isBroadcast) {\n        const calculatedShape = BroadcastUtil.calcShape(a.dims, b.dims, false);\n        if (!calculatedShape) {\n          throw new Error('Can\\'t perform binary op on the given tensors');\n        }\n        outputShape = calculatedShape;\n        outputSize = ShapeUtil.size(outputShape);\n        const isAOneElement = ShapeUtil.size(a.dims) === 1;\n        const isBOneElement = ShapeUtil.size(b.dims) === 1;\n        const aLastDimDivisibleBy4 = a.dims.length > 0 && a.dims[a.dims.length - 1] % 4 === 0;\n        const bLastDimDivisibleBy4 = b.dims.length > 0 && b.dims[b.dims.length - 1] % 4 === 0;\n        cacheKeyAux.push(isAOneElement);\n        cacheKeyAux.push(isBOneElement);\n        cacheKeyAux.push(aLastDimDivisibleBy4);\n        cacheKeyAux.push(bLastDimDivisibleBy4);\n        // check whether vectorize can be enabled\n        let sharedDimension = 1;\n        for (let i = 1; i < outputShape.length; i++) {\n          const dimA = a.dims[a.dims.length - i] ?? 1;\n          const dimB = b.dims[b.dims.length - i] ?? 1;\n          if (dimA === dimB) {\n            sharedDimension *= dimA;\n          } else {\n            break;\n          }\n        }\n        if (sharedDimension % 4 === 0) {\n          sharedDimensionDivisibleBy4 = true;\n          vectorize = true;\n        } else if (isAOneElement || isBOneElement || aLastDimDivisibleBy4 || bLastDimDivisibleBy4) {\n          vectorize = true;\n        }\n      } else {\n        // element-wise\n        vectorize = true;\n      }\n      cacheKeyAux.push(vectorize);\n\n      return {\n        name,\n        shaderCache: {\n          hint: cacheKey + cacheKeyAux.map((x) => x.toString()).join('_'),\n          inputDependencies: ['rank', 'rank'],\n        },\n        getShaderSource: (shaderHelper) => createBinaryOpProgramShader(\n            shaderHelper, a.dims, b.dims, outputShape, vectorize, isBroadcast, sharedDimensionDivisibleBy4, funcCall,\n            a.dataType, b.dataType, outputDataType, additionalImplementation),\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: outputDataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */ / 4 /* component size */)},\n          programUniforms: [\n            {type: DataType.uint32, data: Math.ceil(ShapeUtil.size(outputShape) / 4)},\n            ...createTensorShapeVariables(a.dims, b.dims, outputShape)\n          ],\n        }),\n      };\n    };\n\nconst runBinaryOp =\n    (context: ComputeContext, name: string, funcCall: BinaryFunctionCall, additionalImplementation?: string,\n     cacheKey?: string, outputDataType?: number): void => {\n      context.compute(createBinaryOpProgramInfo(\n          name, cacheKey ?? '', context.inputs[0], context.inputs[1], funcCall, additionalImplementation,\n          outputDataType));\n    };\n\nexport const add = (context: ComputeContext): void => {\n  runBinaryOp(context, 'Add', (a, b) => `${a}+${b}`);\n};\n\nexport const div = (context: ComputeContext): void => {\n  runBinaryOp(context, 'Div', (a, b) => `${a}/${b}`);\n};\n\nexport const equal = (context: ComputeContext): void => {\n  runBinaryOp(\n      context, 'Equal', ({scalar: (a, b) => `u32(${a}==${b})`, vector: (a, b) => `vec4<u32>(${a}==${b})`}), undefined,\n      undefined, DataType.bool);\n};\n\nexport const mul = (context: ComputeContext): void => {\n  runBinaryOp(context, 'Mul', (a, b) => `${a}*${b}`);\n};\n\nexport const pow = (context: ComputeContext): void => {\n  const type = inputVariable('input', context.inputs[0].dataType, context.inputs[0].dims).type.value;\n  const roundStr = type === 'i32' ? 'round' : '';\n  runBinaryOp(\n      context, 'Pow', ({scalar: (a, b) => `pow_custom(${a},${b})`, vector: (a, b) => `pow_vector_custom(${a},${b})`}),\n      `\n    fn pow_custom(a : ${type}, b : ${type}) -> ${type} {\n      if (b == ${type}(0.0)) {\n        return ${type}(1.0);\n      } else if (a < ${type}(0.0) && f32(b) != floor(f32(b))) {\n        return ${type}(pow(f32(a), f32(b))); // NaN\n      }\n      return select(sign(a), ${type}(1.0), round(f32(abs(b) % ${type}(2.0))) != 1.0) * ${type}(${\n          roundStr}(pow(f32(abs(a)), f32(b))));\n    }\n    fn pow_vector_custom(a : vec4<${type}>, b : vec4<${type}>) -> vec4<${type}> {\n      // TODO: implement vectorized pow\n      return vec4<${type}>(pow_custom(a.x, b.x), pow_custom(a.y, b.y), pow_custom(a.z, b.z), pow_custom(a.w, b.w));\n    }\n      `);\n};\n\nexport const sub = (context: ComputeContext): void => {\n  runBinaryOp(context, 'Sub', (a, b) => `${a}-${b}`);\n};\n\nexport const greater = (context: ComputeContext): void => {\n  runBinaryOp(\n      context, 'Greater', ({scalar: (a, b) => `u32(${a}>${b})`, vector: (a, b) => `vec4<u32>(${a}>${b})`}), undefined,\n      undefined, DataType.bool);\n};\n\nexport const less = (context: ComputeContext): void => {\n  runBinaryOp(\n      context, 'Less', ({scalar: (a, b) => `u32(${a}<${b})`, vector: (a, b) => `vec4<u32>(${a}<${b})`}), undefined,\n      undefined, DataType.bool);\n};\n\nexport const greaterOrEqual = (context: ComputeContext): void => {\n  runBinaryOp(\n      context, 'GreaterOrEqual', ({scalar: (a, b) => `u32(${a}>=${b})`, vector: (a, b) => `vec4<u32>(${a}>=${b})`}),\n      undefined, undefined, DataType.bool);\n};\n\nexport const lessOrEqual = (context: ComputeContext): void => {\n  runBinaryOp(\n      context, 'LessOrEqual', ({scalar: (a, b) => `u32(${a}<=${b})`, vector: (a, b) => `vec4<u32>(${a}<=${b})`}),\n      undefined, undefined, DataType.bool);\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {MAX_CLIP, MIN_CLIP} from '../../util';\nimport {ProgramUniform} from '../types';\n\nimport {UniformsArrayType} from './common';\n\nexport interface InternalActivationAttributes {\n  readonly activation: string;\n  readonly clipMin?: number;\n  readonly clipMax?: number;\n  readonly alpha?: number;\n  readonly beta?: number;\n}\n\nexport const getActivationSnippet =\n    (attributes: InternalActivationAttributes, valueType: string, baseType = 'f32'): string => {\n      switch (attributes.activation) {\n        case 'Relu':\n          return `value = max(value, ${valueType}(0.0));`;\n        case 'Sigmoid':\n          return `value = (${valueType}(1.0) / (${valueType}(1.0) + exp(-value)));`;\n        case 'Clip':\n          return `value = clamp(value, ${valueType}(${baseType}(uniforms.clip_min)), ${valueType}(${\n              baseType}(uniforms.clip_max)));`;\n        case 'HardSigmoid':\n          return `value = max(${valueType}(0.0), min(${valueType}(1.0), ${baseType}(uniforms.alpha) * value + ${\n              baseType}(uniforms.beta)));`;\n        case 'LeakyRelu':\n          return `value = select(${baseType}(uniforms.alpha) * value, value, value >= ${valueType}(0.0));`;\n        case '':\n          return '';\n        // TODO: adding other activations that can be fused.\n        default:\n          throw new Error(`Unsupported activation ${attributes.activation}`);\n      }\n    };\n\nexport const appendActivationUniformsData =\n    (attributes: InternalActivationAttributes, programUniform: ProgramUniform[]) => {\n      if (attributes.activation === 'Clip') {\n        programUniform.push(\n            {type: DataType.float, data: attributes.clipMax!}, {type: DataType.float, data: attributes.clipMin!});\n      } else if (attributes.activation === 'HardSigmoid') {\n        programUniform.push(\n            {type: DataType.float, data: attributes.alpha!}, {type: DataType.float, data: attributes.beta!});\n      } else if (attributes.activation === 'LeakyRelu') {\n        programUniform.push({type: DataType.float, data: attributes.alpha!});\n      }\n    };\n\nexport const appendActivationUniforms = (attributes: InternalActivationAttributes, uniforms: UniformsArrayType) => {\n  if (attributes.activation === 'Clip') {\n    uniforms.push({name: 'clip_max', type: 'f32'}, {name: 'clip_min', type: 'f32'});\n  } else if (attributes.activation === 'HardSigmoid') {\n    uniforms.push({name: 'alpha', type: 'f32'}, {name: 'beta', type: 'f32'});\n  } else if (attributes.activation === 'LeakyRelu') {\n    uniforms.push({name: 'alpha', type: 'f32'});\n  }\n};\n\nexport const parseInternalActivationAttributes =\n    (attributes: Record<string, unknown>|undefined): InternalActivationAttributes => {\n      const activation = attributes?.activation as string || '';\n      if (activation === 'HardSigmoid') {\n        const [alpha, beta] = attributes?.activation_params as [number, number] || [0.2, 0.5];\n        return {activation, alpha, beta};\n      } else if (activation === 'Clip') {\n        const [clipMin, clipMax] = attributes?.activation_params as [number, number] || [MIN_CLIP, MAX_CLIP];\n        return {activation, clipMax, clipMin};\n      } else if (activation === 'LeakyRelu') {\n        const [alpha] = attributes?.activation_params as [number] || [0.01];\n        return {activation, alpha};\n      }\n      return {activation};\n    };\n", "/**\n * @license\n * Copyright 2021 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/activation_util.ts\n//\n// modified to fit the needs of the project\n\nexport const typeSnippet = (component: number, dataType: string) => {\n  switch (component) {\n    case 1:\n      return dataType;\n    case 2:\n      return `vec2<${dataType}>`;\n    case 3:\n      return `vec3<${dataType}>`;\n    case 4:\n      return `vec4<${dataType}>`;\n    default:\n      throw new Error(`${component}-component is not supported.`);\n  }\n};\n\nexport const biasSnippet = (hasBias: boolean): string => `\n      ${hasBias ? 'value = value + getBiasByOutputCoords(coords);' : ''}\n      `;\n", "/**\n * @license\n * Copyright 2020 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-core/src/ops/conv_util.ts\n//\n// modified to fit the needs of the project\n\nexport const utilFunctions = (strideStr: string) => (`\nfn getIndexFromCoords4D(coords : vec4<i32>, shape : vec4<i32>) -> i32 {\n  return dot(coords, vec4<i32>(\n      shape.y * shape.z * shape.w, shape.z * shape.w, shape.w, 1));\n}\nfn getOutputIndexFromCoords(coords : vec4<i32>) -> i32 {\n  return dot(coords, vec4<i32>(\n    i32(${strideStr}.x), i32(${strideStr}.y), i32(${strideStr}.z), 1));\n}\n`);\n", "/**\n * @license\n * Copyright 2019 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/matmul_packed_webgpu.ts\n//\n// modified to fit the needs of the project\n\nimport {DataType} from '../../../../wasm-common';\nimport {TensorView} from '../../../tensor-view';\nimport {ShapeUtil} from '../../../util';\nimport {ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../../types';\nimport {createTensorShapeVariables, getBroadcastDims, IndicesHelper, inputVariable, internalVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from '../common';\nimport {appendActivationUniforms, appendActivationUniformsData, getActivationSnippet, InternalActivationAttributes} from '../fuse-utils';\n\nimport {typeSnippet} from './activation_util';\n\nconst writeDataToSubAVec4Snippet = (transpose: boolean, batchDims?: IndicesHelper) => {\n  if (transpose) {\n    return `\n        mm_Asub[inputRow][inputCol] = mm_readA(batch,\n          kStart + inputRow,\n          globalRowStart / innerElementSize + inputCol${batchDims ? ', batchIndices' : ''});\n        `;\n\n  } else {\n    return `\n        mm_Asub[inputRow][inputCol] = mm_readA(batch,\n          globalRow + innerRow,\n          kStart / innerElementSize + inputCol${batchDims ? ', batchIndices' : ''});\n        `;\n  }\n};\n\nconst calculateResultSnippet = (transposeA: boolean, innerElementSize: number) => {\n  if (transposeA) {\n    return `\n        let ACached0 = mm_Asub[k * innerElementSize][localRow];\n        let ACached1 = mm_Asub[k * innerElementSize + 1][localRow];\n        let ACached2 = mm_Asub[k * innerElementSize + 2][localRow];\n        ${innerElementSize === 3 ? '' : 'let ACached3 = mm_Asub[k * innerElementSize + 3][localRow];'}\n        for (var i = 0; i < rowPerThread; i = i + 1) {\n          acc[i] = BCached0 * ACached0[i] + acc[i];\n          acc[i] = BCached1 * ACached1[i] + acc[i];\n          acc[i] = BCached2 * ACached2[i] + acc[i];\n          ${innerElementSize === 3 ? '' : 'acc[i] = BCached3 * ACached3[i] + acc[i];'}\n        }`;\n  } else {\n    return `\n        for (var i = 0; i < rowPerThread; i = i + 1) {\n          let ACached = mm_Asub[tileRow + i][k];\n          acc[i] = BCached0 * ACached.x + acc[i];\n          acc[i] = BCached1 * ACached.y + acc[i];\n          acc[i] = BCached2 * ACached.z + acc[i];\n          ${innerElementSize === 3 ? '' : 'acc[i] = BCached3 * ACached.w + acc[i];'}\n        }`;\n  }\n};\n\nexport const makeMatMulPackedVec4Source =\n    (workPerThread: number[], workgroupSize: [number, number, number], type = 'f32', batchDims?: IndicesHelper,\n     transposeA = false, tileInner = 32, splitK = false, splitedDimInner = 32): string => {\n      const tileAOuter = workgroupSize[1] * workPerThread[1];\n      const tileBOuter = workgroupSize[0] * workPerThread[0];\n      const tileAWidth = transposeA ? tileAOuter : tileInner;\n      const tileAHight = transposeA ? tileInner : tileAOuter;\n      const innerElementSize = tileAWidth / workgroupSize[0];\n      const rowPerThreadB = tileInner / workgroupSize[1];\n\n      if (!(((transposeA && innerElementSize === 4 && workPerThread[1] === 4) ||\n             (!transposeA && (innerElementSize === 3 || innerElementSize === 4))) &&\n            tileAWidth % workgroupSize[0] === 0 && tileInner % workgroupSize[1] === 0 && workPerThread[0] === 4)) {\n        throw new Error(`If transposeA ${transposeA} is true, innerElementSize ${\n            innerElementSize} and workPerThread[1] ${workPerThread[1]} must be 4.\n      Otherwise, innerElementSize ${innerElementSize} must be 3 or 4.\n  tileAWidth ${tileAWidth} must be divisible by workgroupSize[0]${workgroupSize[0]}. tileInner ${\n            tileInner} must be divisible by workgroupSize[1] ${workgroupSize[1]}. colPerThread ${\n            workPerThread[0]} must be 4.`);\n      }\n      return `\nvar<workgroup> mm_Asub: array<array<vec${innerElementSize}<${type}>, ${tileAWidth / innerElementSize}>, ${tileAHight}>;\nvar<workgroup> mm_Bsub: array<array<vec4<${type}>, ${tileBOuter / workPerThread[0]}>, ${tileInner}>;\n\nconst rowPerThread = ${workPerThread[1]};\nconst colPerThread = ${workPerThread[0]};\nconst innerElementSize = ${innerElementSize};\nconst tileInner = ${tileInner};\n\n@compute @workgroup_size(${workgroupSize[0]}, ${workgroupSize[1]}, ${workgroupSize[2]})\nfn main(@builtin(local_invocation_id) localId : vec3<u32>,\n        @builtin(global_invocation_id) globalId : vec3<u32>,\n        @builtin(workgroup_id) workgroupId : vec3<u32>) {\n  let localRow = i32(localId.y);\n  let tileRow = localRow * rowPerThread;\n  let tileCol = i32(localId.x);\n\n  let globalRow =i32(globalId.y) * rowPerThread;\n  let globalCol = i32(globalId.x);\n  let batch = ${splitK ? '0' : 'i32(globalId.z)'};\n  ${batchDims ? `let batchIndices = ${batchDims.offsetToIndices('u32(batch)')};` : ''}\n  let globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n\n  let num_tiles = ${splitK ? `${Math.ceil(splitedDimInner / tileInner)}` : '(uniforms.dim_inner - 1) / tileInner + 1'};\n  var kStart = ${splitK ? `i32(globalId.z) * ${splitedDimInner}` : '0'};\n\n  var acc: array<vec4<${type}>, rowPerThread>;\n\n  // Loop over shared dimension.\n  let tileRowB = localRow * ${rowPerThreadB};\n  for (var t = 0; t < num_tiles; t = t + 1) {\n      // Load one tile of A into local memory.\n      for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n          let inputRow = tileRow + innerRow;\n          let inputCol = tileCol;\n          ${writeDataToSubAVec4Snippet(transposeA, batchDims)}\n      }\n\n      // Load one tile of B into local memory.\n      for (var innerRow = 0; innerRow < ${rowPerThreadB}; innerRow = innerRow + 1) {\n          let inputRow = tileRowB + innerRow;\n          let inputCol = tileCol;\n          mm_Bsub[inputRow][inputCol] = mm_readB(batch, kStart + inputRow, globalCol${\n          batchDims ? ', batchIndices' : ''});\n      }\n      kStart = kStart + tileInner;\n      workgroupBarrier();\n\n      // Compute acc values for a single thread.\n      for (var k = 0; k < tileInner / innerElementSize; k = k + 1) {\n          let BCached0 = mm_Bsub[k * innerElementSize][tileCol];\n          let BCached1 = mm_Bsub[k * innerElementSize + 1][tileCol];\n          let BCached2 = mm_Bsub[k * innerElementSize + 2][tileCol];\n          ${innerElementSize === 3 ? '' : 'let BCached3 = mm_Bsub[k * innerElementSize + 3][tileCol];'}\n\n          ${calculateResultSnippet(transposeA, innerElementSize)}\n      }\n\n      workgroupBarrier();\n  }\n\n  for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      mm_write(batch, globalRow + innerRow, globalCol, acc[innerRow]);\n  }\n}`;\n    };\n\nconst writeDataToSubASnippet = (transpose: boolean, batchDims?: IndicesHelper) => {\n  if (transpose) {\n    return `\n            mm_Asub[inputRow][inputCol] = mm_readA(batch,\n              kStart + inputRow,\n              globalRowStart + inputCol${batchDims ? ', batchIndices' : ''});\n            `;\n\n  } else {\n    return `\n            mm_Asub[inputRow][inputCol] = mm_readA(batch,\n              globalRowStart + inputRow,\n              kStart + inputCol${batchDims ? ', batchIndices' : ''});\n            `;\n  }\n};\n\nconst readDataFromSubASnippet = (transposeA: boolean) =>\n    transposeA ? 'let ACached = mm_Asub[k][tileRow + innerRow];' : 'let ACached = mm_Asub[tileRow + innerRow][k];';\n\n// sequentialAccessByThreads means sequential data in memory is accessed by\n// threads, instead of a single thread (default behavior).\nexport const makeMatMulPackedSource =\n    (workPerThread: number[], workgroupSize: [number, number, number], type = 'f32', batchDims?: IndicesHelper,\n     transposeA = false, tileInner = 32, splitK = false, splitedDimInner = 32,\n     sequentialAccessByThreads = false): string => {\n      const tileAOuter = workPerThread[1] * workgroupSize[1];\n      const tileBOuter = workPerThread[0] * workgroupSize[0];\n      const tileAWidth = transposeA ? tileAOuter : tileInner;\n      const tileAHight = transposeA ? tileInner : tileAOuter;\n\n      if (!(tileAHight % workgroupSize[1] === 0 && tileAWidth % workgroupSize[0] === 0 &&\n            tileInner % workgroupSize[1] === 0)) {\n        throw new Error(`tileAHight ${tileAHight} must be divisible by workgroupSize[1]${\n            workgroupSize[1]}, tileAWidth ${tileAWidth} must be divisible by workgroupSize[0]${\n            workgroupSize[0]}, tileInner ${tileInner} must be divisible by workgroupSize[1]${workgroupSize[1]}`);\n      }\n      const rowPerThreadA = tileAHight / workgroupSize[1];\n      const colPerThreadA = tileAWidth / workgroupSize[0];\n      const rowPerThreadB = tileInner / workgroupSize[1];\n      const matmulSnippet = sequentialAccessByThreads ?\n          `\n    let localRow = i32(localId.y);\n    let localCol = i32(localId.x);\n    let globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n    let globalColStart = i32(workgroupId.x) * ${tileBOuter};\n\n    // Loop over shared dimension.\n    for (var t = 0; t < num_tiles; t = t + 1) {\n      // Load one tile of A into local memory.\n      for (var inputRow = localRow; inputRow < ${tileAHight}; inputRow = inputRow + ${workgroupSize[1]}) {\n        for (var inputCol = localCol; inputCol < ${tileAWidth}; inputCol = inputCol + ${workgroupSize[0]}) {\n          ${writeDataToSubASnippet(transposeA, batchDims)}\n        }\n      }\n      // Load one tile of B into local memory.\n      for (var inputRow = localRow; inputRow < ${tileInner}; inputRow = inputRow + ${workgroupSize[1]}) {\n            for (var inputCol = localCol; inputCol < ${tileBOuter}; inputCol = inputCol + ${workgroupSize[0]}) {\n          mm_Bsub[inputRow][inputCol] = mm_readB(batch,\n            kStart + inputRow,\n            globalColStart + inputCol${batchDims ? ', batchIndices' : ''});\n        }\n      }\n      kStart = kStart + tileInner;\n      workgroupBarrier();\n\n      // Compute acc values for a single thread.\n      var BCached : array<${type}, colPerThread>;\n      for (var k = 0; k < tileInner; k = k + 1) {\n        for (var inner = 0; inner < colPerThread; inner = inner + 1) {\n          BCached[inner] = mm_Bsub[k][localCol + inner * ${workgroupSize[0]}];\n        }\n        for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n          let ACached = ${\n              transposeA ? `mm_Asub[k][localRow + innerRow * ${workgroupSize[1]}];` :\n                           `mm_Asub[localRow + innerRow * ${workgroupSize[1]}][k];`}\n          for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n            acc[innerRow][innerCol] = acc[innerRow][innerCol] +\n                ACached * BCached[innerCol];\n          }\n        }\n      }\n      workgroupBarrier();\n    }\n    for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      let gRow = globalRowStart + localRow + innerRow * ${workgroupSize[1]};\n      for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n        let gCol = globalColStart + localCol + innerCol * ${workgroupSize[0]};\n        mm_write(batch, gRow, gCol, acc[innerRow][innerCol]);\n      }\n    }\n    ` :\n          `\nlet tileRow = i32(localId.y) * rowPerThread;\nlet tileCol = i32(localId.x) * colPerThread;\n\nlet globalRow = i32(globalId.y) * rowPerThread;\nlet globalCol = i32(globalId.x) * colPerThread;\nlet globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n\nlet tileRowA = i32(localId.y) * ${rowPerThreadA};\nlet tileColA = i32(localId.x) * ${colPerThreadA};\nlet tileRowB = i32(localId.y) * ${rowPerThreadB};\n// Loop over shared dimension.\nfor (var t = 0; t < num_tiles; t = t + 1) {\n  // Load one tile of A into local memory.\n  for (var innerRow = 0; innerRow < ${rowPerThreadA}; innerRow = innerRow + 1) {\n    for (var innerCol = 0; innerCol < ${colPerThreadA}; innerCol = innerCol + 1) {\n      let inputRow = tileRowA + innerRow;\n      let inputCol = tileColA + innerCol;\n      ${writeDataToSubASnippet(transposeA, batchDims)}\n    }\n  }\n\n  // Load one tile of B into local memory.\n  for (var innerRow = 0; innerRow < ${rowPerThreadB}; innerRow = innerRow + 1) {\n    for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n      let inputRow = tileRowB + innerRow;\n      let inputCol = tileCol + innerCol;\n      mm_Bsub[inputRow][inputCol] = mm_readB(batch,\n        kStart + inputRow,\n        globalCol + innerCol${batchDims ? ', batchIndices' : ''});\n    }\n  }\n  kStart = kStart + tileInner;\n  workgroupBarrier();\n\n  // Compute acc values for a single thread.\n  var BCached : array<${type}, colPerThread>;\n  for (var k = 0; k < tileInner; k = k + 1) {\n    for (var inner = 0; inner < colPerThread; inner = inner + 1) {\n      BCached[inner] = mm_Bsub[k][tileCol + inner];\n    }\n\n    for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      ${readDataFromSubASnippet(transposeA)}\n      for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n        acc[innerRow][innerCol] = acc[innerRow][innerCol] + ACached * BCached[innerCol];\n      }\n    }\n  }\n\n  workgroupBarrier();\n}\n\nfor (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n  for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n    mm_write(batch, globalRow + innerRow, globalCol + innerCol,\n        acc[innerRow][innerCol]);\n  }\n}\n`;\n\n      return `\n  var<workgroup> mm_Asub : array<array<${type}, ${tileAWidth}>, ${tileAHight}>;\n  var<workgroup> mm_Bsub : array<array<${type}, ${tileBOuter}>, ${tileInner}>;\n  const rowPerThread = ${workPerThread[1]};\n  const colPerThread = ${workPerThread[0]};\n  const tileInner = ${tileInner};\n\n@compute @workgroup_size(${workgroupSize[0]}, ${workgroupSize[1]}, ${workgroupSize[2]})\nfn main(@builtin(local_invocation_id) localId : vec3<u32>,\n        @builtin(global_invocation_id) globalId : vec3<u32>,\n        @builtin(workgroup_id) workgroupId : vec3<u32>) {\n    let batch = ${splitK ? '0' : 'i32(globalId.z)'};\n    ${batchDims ? `let batchIndices = ${batchDims.offsetToIndices('u32(batch)')};` : ''}\n    let num_tiles = ${\n          splitK ? `${Math.ceil(splitedDimInner / tileInner)}` : '(uniforms.dim_inner - 1) / tileInner + 1'};\n    var kStart = ${splitK ? `i32(globalId.z) * ${splitedDimInner}` : '0'};\n\n    var acc : array<array<${type}, colPerThread>, rowPerThread>;\n\n    // Without this initialization strange values show up in acc.\n    for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n        acc[innerRow][innerCol] = 0.0;\n      }\n    }\n    ${matmulSnippet}\n  }\n`;\n    };\n\nconst matMulReadWriteFnSource =\n    (component: number, hasBias: boolean, applyActivation: string, variables: IndicesHelper[],\n     batchShapes: Array<readonly number[]>, isChannelsLast = false): string => {\n      const [batchAShape, batchBShape, batchShape] = batchShapes;\n      const [batchVariable, aVariable, bVariable, outputVariable] = variables;\n      const broadCastADims = getBroadcastDims(batchAShape, batchShape);\n      const broadCastBDims = getBroadcastDims(batchBShape, batchShape);\n      const dataType = tensorTypeToWsglStorageType(variables[0].type.tensor);\n      const getAIndices = () => {\n        const aRank = aVariable.rank;\n        const batchRank = batchVariable.rank;\n        let resStr = `var aIndices: ${aVariable.type.indices};`;\n        for (let i = aRank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) {\n          resStr += `\\naIndices[${i}] = ${batchRank > 1 ? `batchIndices[${j}]` : 'batchIndices'};`;\n        }\n        broadCastADims.forEach(i => {\n          resStr += `\\naIndices[${i}] = 0;`;\n        });\n        resStr += `\\naIndices[${aRank - 2}] = u32(row);\n                   aIndices[${aRank - 1}] = u32(colIn);`;\n        return resStr;\n      };\n      const getBIndices = () => {\n        const bRank = bVariable.rank;\n        const batchRank = batchVariable.rank;\n        let resStr = `var bIndices: ${bVariable.type.indices};`;\n        for (let i = bRank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) {\n          resStr += `\\nbIndices[${i}] = ${batchRank > 1 ? `batchIndices[${j}]` : 'batchIndices'};`;\n        }\n        broadCastBDims.forEach(i => {\n          resStr += `\\nbIndices[${i}] = 0;`;\n        });\n        resStr += `\\nbIndices[${bRank - 2}] = u32(row);\n                   bIndices[${bRank - 1}] = u32(colIn);`;\n        return resStr;\n      };\n      const source = `\n    fn mm_readA(batch: i32, row: i32, colIn: i32, batchIndices: ${batchVariable.type.indices}) -> ${\n          typeSnippet(component, dataType)} {\n      var value = ${typeSnippet(component, dataType)}(0.0);\n      let col = colIn * ${component};\n      if(row < uniforms.dim_a_outer && col < uniforms.dim_inner)\n      {\n        ${getAIndices()}\n        value = ${aVariable.getByIndices('aIndices')};\n      }\n      return value;\n    }\n\n    fn mm_readB(batch: i32, row: i32, colIn: i32, batchIndices: ${batchVariable.type.indices}) -> ${\n          typeSnippet(component, dataType)} {\n      var value = ${typeSnippet(component, dataType)}(0.0);\n      let col = colIn * ${component};\n      if(row < uniforms.dim_inner && col < uniforms.dim_b_outer)\n      {\n        ${getBIndices()}\n        value = ${bVariable.getByIndices('bIndices')};\n      }\n      return value;\n    }\n\n    fn mm_write(batch: i32, row: i32, colIn: i32, valueIn: ${typeSnippet(component, dataType)}) {\n      let col = colIn * ${component};\n      if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer) {\n        var value = valueIn;\n        let coords = vec3<i32>(batch, row, colIn);\n        ${\n          hasBias ?\n              `value = value + ${isChannelsLast ? 'bias[colIn]' : `${typeSnippet(component, dataType)}(bias[row])`};` :\n                                                  ''                                    }\n        ${applyActivation}\n        ${outputVariable.setByIndices('vec3<u32>(coords)', 'value')}\n      }\n    }\n    `;\n      return source;\n    };\n\nexport const createMatmulProgramInfo =\n    (inputs: readonly TensorView[], activationAttributes: InternalActivationAttributes, outputShape: readonly number[],\n     reshapedOutputShape?: readonly number[],\n     isChannelsLast = false /* only used for conv2dByMatMul*/): ProgramInfo => {\n      const aShape = inputs[0].dims;\n      const bShape = inputs[1].dims;\n      const outerDimsA = aShape.slice(0, -2);\n      const outerDimsB = bShape.slice(0, -2);\n      const outerDims = reshapedOutputShape ? reshapedOutputShape.slice(0, -2) : outputShape.slice(0, -2);\n      const batchSize = ShapeUtil.size(outerDims);\n      const dimAOuter = aShape[aShape.length - 2];\n      const dimInner = aShape[aShape.length - 1];\n      const dimBOuter = bShape[bShape.length - 1];\n      const isVec4 = dimInner % 4 === 0 && dimBOuter % 4 === 0;\n\n      // TODO: fine tune size\n      const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];\n      const workgroupSize: [number, number, number] = [8, 8, 1];\n      const dispatch = [\n        Math.ceil(dimBOuter / workgroupSize[0] / elementsPerThread[0]),\n        Math.ceil(dimAOuter / workgroupSize[1] / elementsPerThread[1]),\n        Math.ceil(batchSize / workgroupSize[2] / elementsPerThread[2])\n      ];\n\n      const components = isVec4 ? 4 : 1;\n      const aShapeTemp = [...outerDimsA, dimAOuter, dimInner / components];\n      const aRank = aShapeTemp.length;\n      const bShapeTemp = [...outerDimsB, dimInner, dimBOuter / components];\n      const bRank = bShapeTemp.length;\n      const outputShapeTemp = [batchSize, dimAOuter, dimBOuter / components];\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.int32, data: dimAOuter}, {type: DataType.int32, data: dimBOuter},\n        {type: DataType.int32, data: dimInner}\n      ];\n      appendActivationUniformsData(activationAttributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(outerDims, aShapeTemp, bShapeTemp));\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n\n      const hasBias = inputs.length > 2;\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n        inputDependencies.push('rank');\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShapeTemp));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const batchRank = outerDims.length;\n        const batchDims = internalVariable('batchDims', inputs[0].dataType, batchRank, 1);\n        const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n\n        const A = inputVariable('a', inputs[0].dataType, aRank, components);\n        const B = inputVariable('b', inputs[1].dataType, bRank, components);\n        const output = outputVariable('result', inputs[0].dataType, outputShapeTemp.length, components);\n        const inputVariables = [A, B];\n        if (hasBias) {\n          const biasComponents = isChannelsLast ? components : 1;\n          inputVariables.push(inputVariable('bias', inputs[2].dataType, inputs[2].dims.length, biasComponents));\n        }\n        const uniforms: UniformsArrayType =\n            [{name: 'dim_a_outer', type: 'i32'}, {name: 'dim_b_outer', type: 'i32'}, {name: 'dim_inner', type: 'i32'}];\n        appendActivationUniforms(activationAttributes, uniforms);\n        const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n        const applyActivation = getActivationSnippet(activationAttributes, output.type.value, baseType);\n        const declareFunctions = matMulReadWriteFnSource(\n            components, hasBias, applyActivation, [batchDims, A, B, output], [outerDimsA, outerDimsB, outerDims],\n            isChannelsLast);\n        return `\n  ${\n            shaderHelper.registerUniforms(uniforms).registerInternalVariables(batchDims).declareVariables(\n                ...inputVariables, output)}\n  ${declareFunctions}\n  ${\n            isVec4 ? makeMatMulPackedVec4Source(elementsPerThread, workgroupSize, dataType, batchDims) :\n                     makeMatMulPackedSource(elementsPerThread, workgroupSize, dataType, batchDims)}\n                   `;\n      };\n      return {\n        name: 'MatMul',\n        shaderCache: {\n          hint: `${elementsPerThread};${activationAttributes.activation};${isVec4};${isChannelsLast}`,\n          inputDependencies\n        },\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: dispatch[0], y: dispatch[1], z: dispatch[2]},\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n", "/**\n * @license\n * Copyright 2019 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/conv2d_mm_webgpu.ts\n//\n// modified to fit the needs of the project\n\nimport {DataType} from '../../../../wasm-common';\nimport {LOG_DEBUG} from '../../../log';\nimport {TensorView} from '../../../tensor-view';\nimport {ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../../types';\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from '../common';\nimport {ConvAttributes} from '../conv';\nimport {appendActivationUniforms, appendActivationUniformsData, getActivationSnippet} from '../fuse-utils';\n\nimport {biasSnippet, typeSnippet} from './activation_util';\nimport {utilFunctions} from './conv_util';\nimport {makeMatMulPackedSource, makeMatMulPackedVec4Source} from './matmul_packed_webgpu';\n\nconst conv2dCommonSnippet =\n    (isChannelsLast: boolean, fitAOuter: boolean, fitBOuter: boolean, fitInner: boolean, addBias = false,\n     attributes: ConvAttributes, innerElementSizeX = 4, innerElementSizeW = 4, innerElementSize = 4,\n     dataType = 'f32'): string => {\n      const getXSnippet = (innerElementSize: number) => {\n        switch (innerElementSize) {\n          case 1:\n            return 'resData = x[xIndex];';\n          case 3:\n            return `resData = vec3<${dataType}>(x[xIndex], x[xIndex + 1], x[xIndex + 2]);`;\n          case 4:\n            return 'resData = x[xIndex / 4];';\n          default:\n            throw new Error(`innerElementSize ${innerElementSize} is not supported.`);\n        }\n      };\n      const getWSnippet = (innerElementSize: number) => {\n        switch (innerElementSize) {\n          case 1:\n            return 'return w[row * i32(uniforms.w_shape[3]) + colIn];';\n          case 4:\n            return 'return w[row * i32(uniforms.w_shape[3]) / 4 + colIn];';\n          default:\n            throw new Error(`innerElementSize ${innerElementSize} is not supported.`);\n        }\n      };\n      const coordASnippet = isChannelsLast ? `\n    let coord = vec4<i32>(batch, xRow, xCol, xCh);\n    ` :\n                                             `\n    let coord = vec4<i32>(batch, xCh, xRow, xCol);\n    `;\n\n      const coordResSnippet = isChannelsLast ? `\n    let coords = vec4<i32>(\n      batch,\n      row / outWidth,\n      row % outWidth,\n      col);\n    ` :\n                                               `\n    let coords = vec4<i32>(\n      batch,\n      row,\n      col / outWidth,\n      col % outWidth);\n    `;\n\n      const xHeight = isChannelsLast ? 'i32(uniforms.x_shape[1])' : 'i32(uniforms.x_shape[2])';\n      const xWidth = isChannelsLast ? 'i32(uniforms.x_shape[2])' : 'i32(uniforms.x_shape[3])';\n      const row = isChannelsLast ? 'row' : 'col';\n      const col = isChannelsLast ? 'col' : 'row';\n      const readXSnippet = `\n    let inChannels = i32(uniforms.w_shape[2]);\n    let outWidth = ${isChannelsLast ? 'i32(uniforms.result_shape[2])' : 'i32(uniforms.result_shape[3])'};\n    let outRow = ${row} / outWidth;\n    let outCol = ${row} % outWidth;\n\n    let WRow = ${col} / (i32(uniforms.w_shape[1]) * inChannels);\n    let WCol = ${col} / inChannels % i32(uniforms.w_shape[1]);\n    let xRow = outRow * uniforms.stride[0] + uniforms.dilation[0] * WRow - uniforms.pad[0];\n    let xCol = outCol * uniforms.stride[1] + uniforms.dilation[1] * WCol - uniforms.pad[1];\n    let xCh = ${col} % inChannels;\n    var resData = ${typeSnippet(innerElementSizeX, dataType)}(0.0);\n    // The bounds checking is always needed since we use it to pad zero for\n    // the 'same' padding type.\n    if (xRow >= 0 && xRow < ${xHeight} && xCol >= 0 && xCol < ${xWidth}) {\n      ${coordASnippet}\n      let xIndex = getIndexFromCoords4D(coord, vec4<i32>(uniforms.x_shape));\n      ${getXSnippet(innerElementSizeX)}\n    }\n    return resData;`;\n\n      const sampleX = isChannelsLast ? (fitAOuter && fitInner ? `\n    let col = colIn * ${innerElementSizeX};\n    ${readXSnippet}` :\n                                                                `\n    let col = colIn * ${innerElementSizeX};\n    if (row < uniforms.dim_a_outer && col < uniforms.dim_inner) {\n      ${readXSnippet}\n    }\n    return ${typeSnippet(innerElementSizeX, dataType)}(0.0);`) :\n                                       (fitInner && fitBOuter ? `\n    let col = colIn * ${innerElementSizeX};\n    ${readXSnippet}` :\n                                                                `\n    let col = colIn * ${innerElementSizeX};\n    if (row < uniforms.dim_inner && col < uniforms.dim_b_outer) {\n      ${readXSnippet}\n    }\n    return ${typeSnippet(innerElementSizeX, dataType)}(0.0);`);\n\n      const sampleW = `${getWSnippet(innerElementSizeW)}`;\n\n      const resType = typeSnippet(innerElementSize, dataType);\n      const aType =\n          isChannelsLast ? typeSnippet(innerElementSizeX, dataType) : typeSnippet(innerElementSizeW, dataType);\n      const bType =\n          isChannelsLast ? typeSnippet(innerElementSizeW, dataType) : typeSnippet(innerElementSizeX, dataType);\n      const applyActivation = getActivationSnippet(attributes, resType, dataType);\n      const userCode = `\n    fn mm_readA(batch: i32, row : i32, colIn : i32) -> ${aType} {\n      ${isChannelsLast ? sampleX : sampleW}\n    }\n\n    fn mm_readB(batch: i32, row : i32, colIn : i32) -> ${bType} {\n      ${isChannelsLast ? sampleW : sampleX}\n    }\n\n    fn mm_write(batch: i32, row : i32, colIn : i32, valueIn : ${resType}) {\n      let col = colIn * ${innerElementSize};\n      if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer)\n      {\n      var value = valueIn;\n      let outWidth = ${isChannelsLast ? 'i32(uniforms.result_shape[2])' : 'i32(uniforms.result_shape[3])'};\n      ${coordResSnippet}\n      ${biasSnippet(addBias)}\n      ${applyActivation}\n      setOutputAtCoords(coords[0], coords[1], coords[2], coords[3], value);\n      }\n    }`;\n      return userCode;\n    };\n\nexport const createConv2DMatMulProgramInfo =\n    (inputs: readonly TensorView[], attributes: ConvAttributes, outputShape: readonly number[], dimAOuter: number,\n     dimBOuter: number, dimInner: number, hasBias: boolean, sequentialAccessByThreads: boolean): ProgramInfo => {\n      const isChannelsLast = attributes.format === 'NHWC';\n      const inChannels = isChannelsLast ? inputs[0].dims[3] : inputs[0].dims[1];\n      const batchSize = outputShape[0];\n      const outWidth = isChannelsLast ? outputShape[2] : outputShape[3];\n      const outHeight = isChannelsLast ? outputShape[1] : outputShape[2];\n      const outChannels = isChannelsLast ? outputShape[3] : outputShape[1];\n      // TODO: enable vec4 for NCHW\n      const isVec4 = isChannelsLast && (inChannels % 4 === 0 || inChannels % 3 === 0) && outChannels % 4 === 0;\n\n      // TODO: fine tune size\n      const dispatchX = isChannelsLast ? outChannels : outWidth * outHeight;\n      const dispatchY = isChannelsLast ? outWidth * outHeight : outChannels;\n      const workGroupSize: [number, number, number] = [8, 8, 1];\n      const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];\n      const dispatch = [\n        Math.ceil(dispatchX / workGroupSize[0] / elementsPerThread[0]),\n        Math.ceil(dispatchY / workGroupSize[1] / elementsPerThread[1]),\n        Math.ceil(batchSize / workGroupSize[2] / elementsPerThread[2])\n      ];\n\n      LOG_DEBUG('verbose', () => `[conv2d_mm_webgpu] dispatch = ${dispatch}`);\n\n      const innerElementSize = isVec4 ? (isChannelsLast && inChannels % 4 !== 0 ? 3 : 4) : 1;\n      const tileAOuter = workGroupSize[1] * elementsPerThread[1];\n      const tileBOuter = workGroupSize[0] * elementsPerThread[0];\n      const tileInner = Math.max(workGroupSize[0] * innerElementSize, workGroupSize[1]);\n      const fitAOuter = dimAOuter % tileAOuter === 0;\n      const fitBOuter = dimBOuter % tileBOuter === 0;\n      const fitInner = dimInner % tileInner === 0;\n      const elementsSize = isVec4 ? [innerElementSize, 4, 4] : [1, 1, 1];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.int32, data: dimAOuter}, {type: DataType.int32, data: dimBOuter},\n        {type: DataType.int32, data: dimInner}, {type: DataType.int32, data: [attributes.pads[0], attributes.pads[1]]},\n        {type: DataType.int32, data: attributes.strides}, {type: DataType.int32, data: attributes.dilations}\n      ];\n      appendActivationUniformsData(attributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(inputs[0].dims, inputs[1].dims));\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n        inputDependencies.push('rank');\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShape));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const uniforms: UniformsArrayType = [\n          {name: 'dim_a_outer', type: 'i32'}, {name: 'dim_b_outer', type: 'i32'}, {name: 'dim_inner', type: 'i32'},\n          {name: 'pad', type: 'i32', length: 2}, {name: 'stride', type: 'i32', length: 2},\n          {name: 'dilation', type: 'i32', length: 2}\n        ];\n        appendActivationUniforms(attributes, uniforms);\n\n        // TODO: support component 2, 3.\n        const components = isVec4 ? 4 : 1;\n        const t = tensorTypeToWsglStorageType(inputs[0].dataType);\n        let declareFunctions = `\n      fn setOutputAtIndex(flatIndex : i32, value : ${isVec4 ? `vec4<${t}>` : t}) {\n        result[flatIndex] = ${isVec4 ? `vec4<${t}>` : t}(value);\n      }\n      fn setOutputAtCoords(d0 : i32, d1 : i32, d2 : i32, d3 : i32, value : ${isVec4 ? `vec4<${t}>` : t}) {\n        let flatIndex = getOutputIndexFromCoords(vec4<i32>(d0, d1, d2, d3));\n        setOutputAtIndex(flatIndex ${isVec4 ? '/ 4' : ''}, value);\n      }`;\n        const x = inputVariable(\n            'x', inputs[0].dataType, inputs[0].dims.length, innerElementSize === 3 ? 1 : innerElementSize);\n        const w = inputVariable('w', inputs[1].dataType, inputs[1].dims.length, components);\n        const inputVariables = [x, w];\n        const output = outputVariable('result', inputs[0].dataType, outputShape.length, components);\n        if (hasBias) {\n          const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims.length, components);\n          inputVariables.push(bias);\n          declareFunctions += `\n        fn getBiasByOutputCoords(coords : vec4<i32>) -> ${isVec4 ? `vec4<${t}>` : t} {\n          return bias[coords.${isChannelsLast ? 'w' : 'y'}${isVec4 ? '/ 4' : ''}];\n        }`;\n        }\n\n        return `\n        ${utilFunctions('uniforms.result_strides')}\n        //struct Uniforms { xShape : vec4<i32>, wShape : vec4<i32>, outShape : vec4<i32>,\n        //  outShapeStrides: vec3<i32>, filterDims : vec2<i32>, pad : vec2<i32>, stride : vec2<i32>,\n        //  dilation : vec2<i32>, dimAOuter : i32, dimBOuter : i32, dimInner : i32 };\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n        ${declareFunctions}\n        ${\n            conv2dCommonSnippet(\n                isChannelsLast, fitAOuter, fitBOuter, fitInner, hasBias, attributes, elementsSize[0], elementsSize[1],\n                elementsSize[2], t)}\n        ${\n            isVec4 ?\n                makeMatMulPackedVec4Source(elementsPerThread, workGroupSize, t, undefined, !isChannelsLast, tileInner) :\n                makeMatMulPackedSource(\n                    elementsPerThread, workGroupSize, t, undefined, !isChannelsLast, tileInner, false, undefined,\n                    sequentialAccessByThreads)}`;\n      };\n      return {\n        name: 'Conv2DMatMul',\n        shaderCache: {\n          hint: `${attributes.cacheKey};${innerElementSize};${isVec4};${fitAOuter};${fitBOuter};${fitInner};${\n              tileAOuter};${tileBOuter};${tileInner}`,\n          inputDependencies\n        },\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: dispatch[0], y: dispatch[1], z: dispatch[2]},\n          programUniforms,\n        }),\n        getShaderSource\n      };\n    };\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, getMaxComponents, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from './common';\nimport {calculateOutputShape, ConvAttributes} from './conv';\nimport {appendActivationUniforms, appendActivationUniformsData, getActivationSnippet} from './fuse-utils';\n\n/**\n * naive grouped conv implementation, supports 1d/2d conv\n * @param squeezeOutputShapeFunction - an optional function to squeeze the output shape, only used in conv1d\n */\nexport const createGroupedConvProgramInfo =\n    (inputs: readonly TensorView[], attributes: ConvAttributes,\n     squeezeOutputShapeFunction?: (shape: readonly number[]) => number[]): ProgramInfo => {\n      const hasBias = inputs.length > 2;\n      const processBias = hasBias ? 'value += b[output_channel];' : '';\n      const xShape = inputs[0].dims;\n      const wShape = inputs[1].dims;\n      const outputChannelsPerGroup = wShape[0] / attributes.group;\n\n      const isChannelLast = attributes.format === 'NHWC';\n      const outputShape = calculateOutputShape(\n          xShape, wShape, attributes.dilations, attributes.pads, attributes.strides, isChannelLast);\n      const outputSize = ShapeUtil.size(outputShape);\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: attributes.dilations},\n        {type: DataType.uint32, data: [attributes.strides[0], attributes.strides[1]]},\n        {type: DataType.uint32, data: [attributes.pads[0], attributes.pads[1]]},\n        {type: DataType.uint32, data: outputChannelsPerGroup}\n      ];\n      appendActivationUniformsData(attributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(xShape, wShape));\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n        inputDependencies.push('rank');\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShape));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n        const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n        const applyActivation = getActivationSnippet(attributes, output.type.value, baseType);\n        const x = inputVariable('x', inputs[0].dataType, xShape.length);\n        const w = inputVariable('w', inputs[1].dataType, wShape.length);\n        const inputVars = [x, w];\n        if (hasBias) {\n          inputVars.push(inputVariable('b', inputs[2].dataType, inputs[2].dims.length));\n        }\n\n        const uniforms: UniformsArrayType = [\n          {name: 'output_size', type: 'u32'}, {name: 'dilations', type: 'u32', length: attributes.dilations.length},\n          {name: 'strides', type: 'u32', length: 2}, {name: 'pads', type: 'u32', length: 2},\n          {name: 'output_channels_per_group', type: 'u32'}\n        ];\n        appendActivationUniforms(attributes, uniforms);\n        return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n    let outputIndices = ${output.offsetToIndices('global_idx')};\n    let batch: u32 = outputIndices[0];\n    let output_channel: u32 = outputIndices[${isChannelLast ? 3 : 1}];\n    let xRCCorner: vec2<u32> = vec2<u32>(outputIndices[${isChannelLast ? 1 : 2}], outputIndices[${\n            isChannelLast ? 2 : 3}]) * uniforms.strides - uniforms.pads;\n    let group_id: u32 = output_channel / uniforms.output_channels_per_group;\n\n    var value: ${output.type.value} = ${output.type.value}(0);\n    for (var wInChannel: u32 = 0u; wInChannel < uniforms.w_shape[1]; wInChannel++) {\n      let input_channel = group_id * uniforms.w_shape[1] + wInChannel;\n      for (var wHeight: u32 = 0u; wHeight < uniforms.w_shape[2]; wHeight++) {\n        let xHeight = xRCCorner.x + wHeight * uniforms.dilations[0];\n\n        if (xHeight < 0u || xHeight >= uniforms.x_shape[${isChannelLast ? 1 : 2}]) {\n          continue;\n        }\n\n        for (var wWidth: u32 = 0u; wWidth < uniforms.w_shape[3]; wWidth++) {\n          let xWidth = xRCCorner.y + wWidth * uniforms.dilations[1];\n          if (xWidth < 0u || xWidth >= uniforms.x_shape[${isChannelLast ? 2 : 3}]) {\n            continue;\n          }\n\n          let xVal = ${\n            isChannelLast ? x.get('batch', 'xHeight', 'xWidth', 'input_channel') :\n                            x.get('batch', 'input_channel', 'xHeight', 'xWidth')};\n          let wVal = ${w.get('output_channel', 'wInChannel', 'wHeight', 'wWidth')};\n          value += xVal*wVal;\n        }\n      }\n    }\n    ${processBias}\n    ${applyActivation}\n    ${output.setByOffset('global_idx', 'value')}\n  }`;\n      };\n      return {\n        name: 'GroupedConv',\n        shaderCache: {hint: attributes.cacheKey, inputDependencies},\n        getRunData: () => ({\n          outputs: [{\n            dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,\n            dataType: inputs[0].dataType\n          }],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n\nexport const createGroupedConvVectorizeProgramInfo =\n    (inputs: readonly TensorView[], attributes: ConvAttributes, outputShape: readonly number[]): ProgramInfo => {\n      const hasBias = inputs.length > 2;\n      const components = getMaxComponents(outputShape[3]);\n      const outputNumber = getMaxComponents(outputShape[2]);\n      const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;\n      const xShape = [inputs[0].dims[0], inputs[0].dims[1], inputs[0].dims[2], inputs[0].dims[3] / components];\n      const wShape = [inputs[1].dims[0], inputs[1].dims[1], inputs[1].dims[2], inputs[1].dims[3] / components];\n      const outputShapeInShader = [outputShape[0], outputShape[1], outputShape[2], outputShape[3] / components];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize},\n        {type: DataType.int32, data: [attributes.strides[0], attributes.strides[1]]},\n        {type: DataType.int32, data: [attributes.pads[0], attributes.pads[1]]}\n      ];\n      appendActivationUniformsData(attributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(xShape, wShape, outputShapeInShader));\n      const xNumber = (outputNumber - 1) * attributes.strides[1] + wShape[1];\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const output = outputVariable('output', inputs[0].dataType, outputShapeInShader.length, components);\n        const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n        const applyActivation = getActivationSnippet(attributes, output.type.value, baseType);\n        const x = inputVariable('x', inputs[0].dataType, xShape.length, components);\n        const w = inputVariable('w', inputs[1].dataType, wShape.length, components);\n        const inputVars = [x, w];\n        if (hasBias) {\n          inputVars.push(inputVariable('b', inputs[2].dataType, inputs[2].dims, components));\n        }\n        const processBias = hasBias ? 'value += b[output_channel];' : '';\n        const uniforms: UniformsArrayType = [\n          {name: 'output_size', type: 'u32'},\n          {name: 'strides', type: 'i32', length: 2},\n          {name: 'pads', type: 'i32', length: 2},\n        ];\n        appendActivationUniforms(attributes, uniforms);\n        return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n    let width0 = uniforms.output_shape[3];\n    let output_channel = global_idx % width0;\n    var index1 = global_idx / width0;\n    let width1 = uniforms.output_shape[2] / ${outputNumber}u;\n    let col = (index1 % width1) * ${outputNumber}u;\n    index1 = index1 / width1;\n    let row = index1 % uniforms.output_shape[1];\n    let batch = index1 / uniforms.output_shape[1];\n\n    let x_corner = vec2<i32>(i32(row), i32(col)) * uniforms.strides - uniforms.pads;\n\n    var x_vals: array<${x.type.value}, ${xNumber}>;\n    var values: array<${output.type.value}, ${outputNumber}>;\n    let input_channel = output_channel;\n    // Use constant instead of uniform can give better performance for w's height/width.\n    for (var w_height: u32 = 0u; w_height < ${wShape[0]}; w_height++) {\n      let x_height = x_corner.x + i32(w_height);\n      if (x_height >= 0 && u32(x_height) < uniforms.x_shape[1]) {\n        for (var i = 0; i < ${xNumber}; i++) {\n          let x_width = x_corner.y + i;\n          if (x_width >= 0 && u32(x_width) < uniforms.x_shape[2]) {\n            x_vals[i] = ${x.get('batch', 'u32(x_height)', 'u32(x_width)', 'input_channel')};\n          } else {\n            x_vals[i] = ${x.type.value}(0);\n          }\n        }\n        for (var w_width: u32 = 0u; w_width < ${wShape[1]}; w_width++) {\n          let w_val = ${w.get('w_height', 'w_width', '0', 'output_channel')};\n          for (var i = 0u; i < ${outputNumber}u; i++) {\n            values[i] = fma(x_vals[i * u32(uniforms.strides[1]) + w_width], w_val, values[i]);\n          }\n        }\n      }\n    }\n\n    for (var i = 0u; i < ${outputNumber}u; i++) {\n      var value = values[i];\n      ${processBias}\n      ${applyActivation}\n      ${output.set('batch', 'row', 'col + i', 'output_channel', 'value')};\n    }\n  }`;\n      };\n\n      return {\n        name: 'GroupedConv-Vectorize',\n        shaderCache: {\n          hint: `${attributes.cacheKey};${components};${outputNumber};${xNumber};${wShape[0]};${wShape[1]}`,\n          inputDependencies: hasBias ? ['rank', 'rank', 'type'] : ['rank', 'rank']\n        },\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {BroadcastUtil, ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createMatmulProgramInfo} from './3rd-party/matmul_packed_webgpu';\nimport {createTensorShapeVariables, getBroadcastDims, getMaxComponents, IndicesHelper, inputVariable, internalVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from './common';\nimport {appendActivationUniforms, appendActivationUniformsData, getActivationSnippet, InternalActivationAttributes} from './fuse-utils';\n\nexport const createNaiveMatmulProgramInfo =\n    (inputs: readonly TensorView[], activationAttributes: InternalActivationAttributes, outputShape: readonly number[],\n     reshapedOutputShape?: readonly number[],\n     isChannelsLast = false /* only used for conv2dByMatMul*/): ProgramInfo => {\n      const aShape = inputs[0].dims;\n      const bShape = inputs[1].dims;\n\n      const M = aShape[aShape.length - 2];\n      const N = bShape[bShape.length - 1];\n      const K = aShape[aShape.length - 1];\n      const components = getMaxComponents(N);\n      const aComponents = getMaxComponents(K);\n      const outputNumber = getMaxComponents(M);\n      const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;\n      const hasBias = inputs.length > 2;\n      const outerDims = reshapedOutputShape ? reshapedOutputShape.slice(0, -2) : outputShape.slice(0, -2);\n      const batchSize = ShapeUtil.size(outerDims);\n      const outputShapeInShader = [batchSize, M, N];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: M}, {type: DataType.uint32, data: N},\n        {type: DataType.uint32, data: K}\n      ];\n      appendActivationUniformsData(activationAttributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(outerDims, aShape, bShape));\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShapeInShader));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const batchDims = internalVariable('batch_dims', inputs[0].dataType, outerDims.length);\n        const a = inputVariable('a', inputs[0].dataType, aShape.length, aComponents);\n        const b = inputVariable('b', inputs[1].dataType, bShape.length, components);\n        const output = outputVariable('output', inputs[0].dataType, outputShapeInShader.length, components);\n        const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n        const applyActivation = getActivationSnippet(activationAttributes, output.type.value, baseType);\n        const inputVariables = [a, b];\n        let processBias = '';\n        if (hasBias) {\n          const biasComponents = isChannelsLast ? components : 1;\n          inputVariables.push(inputVariable('bias', inputs[2].dataType, inputs[2].dims.length, biasComponents));\n          processBias = `${\n              isChannelsLast ? `value += bias[col / ${biasComponents}];` :\n                               `value += ${output.type.value}(bias[row + i]);`}`;\n        }\n\n        const outerDimsA = aShape.slice(0, -2);\n        const outerDimsB = bShape.slice(0, -2);\n        const broadCastADims = getBroadcastDims(outerDimsA, outerDims);\n        const broadCastBDims = getBroadcastDims(outerDimsB, outerDims);\n        const uniforms: UniformsArrayType = [\n          {name: 'output_size', type: 'u32'}, {name: 'M', type: 'u32'}, {name: 'N', type: 'u32'},\n          {name: 'K', type: 'u32'}\n        ];\n        appendActivationUniforms(activationAttributes, uniforms);\n\n        const getIndices = (variable: IndicesHelper, broadCastDims: number[]) => {\n          const rank = variable.rank;\n          const name = variable.name;\n          if (rank === 2) {\n            return `var ${name}_indices = ${variable.type.indices}(0u, 0u);`;\n          }\n          const batchRank = batchDims.rank;\n          let resStr = `var ${name}_indices: ${variable.type.indices};`;\n          for (let i = rank - 2 - 1, j = batchRank - 1; i >= 0; i--, j--) {\n            resStr += `\\n${name}_indices[${i}] = ${batchRank > 1 ? `batch_indices[${j}]` : 'batch_indices'};`;\n          }\n          broadCastDims.forEach(i => {\n            resStr += `\\n${name}_indices[${i}] = 0;`;\n          });\n          resStr += `${name}_indices[${rank - 2}] = 0u;\n                     ${name}_indices[${rank - 1}] = 0u;`;\n          return resStr;\n        };\n\n        const calcResult = (): string => {\n          let calcStr = `var a_data: ${a.type.value};`;\n          for (let i = 0; i < aComponents; i++) {\n            calcStr += `\n              let b_data${i} = b[(b_offset + (k + ${i}) * uniforms.N + col) / ${components}];`;\n          }\n          for (let i = 0; i < outputNumber; i++) {\n            calcStr += `a_data = a[(a_offset + (row + ${i}) * uniforms.K + k) / ${aComponents}];`;\n\n            for (let j = 0; j < aComponents; j++) {\n              calcStr += `\n            values[${i}] = fma(${b.type.value}(a_data${aComponents === 1 ? '' : `[${j}]`}), b_data${j}, values[${\n                  i}]);\\n`;\n            }\n          }\n          return calcStr;\n        };\n\n        return `\n  ${\n            shaderHelper.registerUniforms(uniforms).registerInternalVariables(batchDims).declareVariables(\n                ...inputVariables, output)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n    let col = (global_idx % (uniforms.N / ${components})) * ${components};\n    var index1 = global_idx / (uniforms.N / ${components});\n    let stride1 = uniforms.M / ${outputNumber};\n    let row = (index1 % stride1) * ${outputNumber};\n    let batch = index1 / stride1;\n\n    ${outputShape.length === 2 ? '' : `let batch_indices = ${batchDims.offsetToIndices('batch')};`}\n    ${getIndices(a, broadCastADims)}\n    let a_offset = ${a.indicesToOffset('a_indices')};\n    ${getIndices(b, broadCastBDims)}\n    let b_offset = ${b.indicesToOffset('b_indices')};\n    var values: array<${output.type.value}, ${outputNumber}>;\n    for (var k: u32 = 0u; k < uniforms.K; k = k + ${aComponents}) {\n      ${calcResult()}\n    }\n    for (var i = 0u; i < ${outputNumber}u; i++) {\n      var value = values[i];\n      ${processBias}\n      ${applyActivation}\n      let cur_indices = ${output.type.indices}(batch, row + i, col);\n      let offset = ${output.indicesToOffset('cur_indices')};\n      ${output.setByOffset(`offset / ${components}`, 'value')};\n    }\n  }\n  `;\n      };\n      return {\n        name: 'MatMulNaive',\n        shaderCache: {\n          hint: `${activationAttributes.activation};${components};${aComponents};${outputNumber};${isChannelsLast}`,\n          inputDependencies: hasBias ? ['rank', 'rank', 'rank'] : ['rank', 'rank']\n        },\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource\n      };\n    };\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('MatMul requires 2 inputs.');\n  }\n\n  if (inputs[0].dims[inputs[0].dims.length - 1] !== inputs[1].dims[inputs[1].dims.length - 2]) {\n    throw new Error('shared dimension does not match.');\n  }\n};\n\nexport const matMul = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  const outputShape = BroadcastUtil.calcShape(context.inputs[0].dims, context.inputs[1].dims, true);\n  if (!outputShape) {\n    throw new Error('Can\\'t use matmul on the given tensors');\n  }\n  const N = outputShape[outputShape.length - 1];\n  const K = context.inputs[0].dims[context.inputs[0].dims.length - 1];\n  if (N < 8 && K < 8) {\n    context.compute(createNaiveMatmulProgramInfo(context.inputs, {activation: ''}, outputShape));\n  } else {\n    context.compute(createMatmulProgramInfo(context.inputs, {activation: ''}, outputShape));\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorView} from '../../tensor-view';\nimport {PoolConvUtil} from '../../util';\nimport {AttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext} from '../types';\n\nimport {createConv2DMatMulProgramInfo} from './3rd-party/conv2d_mm_webgpu';\nimport {createMatmulProgramInfo} from './3rd-party/matmul_packed_webgpu';\nimport {createGroupedConvProgramInfo, createGroupedConvVectorizeProgramInfo} from './conv-grouped';\nimport {InternalActivationAttributes, parseInternalActivationAttributes} from './fuse-utils';\nimport {createNaiveMatmulProgramInfo} from './matmul';\nimport {createTransposeProgramInfo} from './transpose';\n\nexport const calculateOutputShape =\n    (inputShape: readonly number[], kernelShape: readonly number[], dilations: readonly number[],\n     adjustPads: readonly number[], strides: readonly number[], isChannelLast: boolean): number[] => {\n      const batchSize = inputShape[0];\n      const inputSpatialShape = inputShape.slice(isChannelLast ? 1 : 2, isChannelLast ? 3 : 4);\n      const spatialRank = inputSpatialShape.length;\n      const outChannels = kernelShape[0];\n      const kernelSpatialShape = kernelShape.slice(2);\n      const dilatedKernelShape = kernelSpatialShape.map((v, i) => v + (v - 1) * (dilations[i] - 1));\n      const inputSpatialShapeWithPad = inputSpatialShape.map((v, i) => v + adjustPads[i] + adjustPads[i + spatialRank]);\n      const outputShape =\n          inputSpatialShapeWithPad.map((v, i) => Math.floor((v - dilatedKernelShape[i] + strides[i]) / strides[i]));\n      outputShape.splice(0, 0, batchSize);\n      outputShape.splice(isChannelLast ? 3 : 1, 0, outChannels);\n      return outputShape;\n    };\n\nexport interface ConvAttributes extends InternalActivationAttributes, AttributeWithCacheKey {\n  readonly autoPad: string;\n  readonly dilations: readonly number[];\n  readonly format: 'NHWC'|'NCHW';\n  readonly group: number;\n  readonly kernelShape: readonly number[];\n  readonly pads: readonly number[];\n  readonly strides: readonly number[];\n  readonly wIsConst: boolean;\n}\n\n// for transposing weight tensor from [M, C/group, KH, KW] to [KH, KW, C/group, M]\nconst weightTransposeAttribute = [2, 3, 1, 0];\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: ConvAttributes): void => {\n  // Refer to the below link for all input checks\n  // https://github.com/onnx/onnx/blob/master/docs/Operators.md#Conv\n  if (!inputs || (inputs.length !== 2 && inputs.length !== 3)) {\n    throw new Error('Conv requires 2 or 3 inputs');\n  }\n\n  // TODO : Need to add support for multi-dimensional conv\n  if (inputs[0].dims.length !== 4 && inputs[0].dims.length !== 3) {\n    throw new Error('currently only support conv 1D and 2D');\n  }\n\n  if (inputs[0].dims.length !== inputs[1].dims.length) {\n    throw new Error('filter does not have same dimension as input');\n  }\n\n  // FILTER_IN_CHANNEL should be equal to DATA_CHANNEL\n  const dataChannel = inputs[0].dims[attributes.format === 'NHWC' ? inputs[0].dims.length - 1 : 1];\n  const filterInChannel = inputs[1].dims[1] * attributes.group;\n  if (dataChannel !== filterInChannel) {\n    throw new Error('FILTER_IN_CHANNEL should be equal to DATA_CHANNEL');\n  }\n\n  // if bias is provided it should be 1D and the number of elements should be equal to the number of feature maps\n  if (inputs.length === 3 && (inputs[2].dims.length !== 1 || inputs[1].dims[0] !== inputs[2].dims[0])) {\n    throw new Error('invalid bias');\n  }\n\n  const spatialRank = inputs[0].dims.length - 2;\n  // wrong dilations dimension\n  if (attributes.dilations.length !== spatialRank) {\n    throw new Error(`dilations should be ${spatialRank}D`);\n  }\n\n  // Wrong strides dimension\n  if (attributes.strides.length !== spatialRank) {\n    throw new Error(`strides should be ${spatialRank}D`);\n  }\n\n  // Wrong pads dimension\n  if (attributes.pads.length !== spatialRank * 2) {\n    throw new Error(`pads should be ${spatialRank * 2}D`);\n  }\n\n  // if kernelShape is specified, it's data length must be 2 less than dims length of the weights tensor\n  // (the first 2 dims are batch_size and channels)\n  if (attributes.kernelShape.length !== 0 && attributes.kernelShape.length !== inputs[1].dims.length - 2) {\n    throw new Error('invalid kernel shape');\n  }\n};\n\nconst getAdjustedConvAttributes = <T extends ConvAttributes>(attributes: T, inputs: readonly TensorView[]): T => {\n  const kernelShape = attributes.kernelShape.slice();\n  // if kernelShape is not specified in the attributes of this op, infer it from the weight tensor dims\n  for (let i = 2; i < inputs[1].dims.length; ++i) {\n    if (kernelShape[i - 2] === 0) {\n      kernelShape[i - 2] = inputs[1].dims[i];\n    }\n  }\n  const pads = attributes.pads.slice();\n  PoolConvUtil.adjustPadsBasedOnAutoPad(\n      inputs[0].dims, attributes.strides, attributes.dilations, kernelShape, pads, attributes.format === 'NHWC',\n      attributes.autoPad);\n\n  // always return a new object so does not modify the original attributes\n  const newAttributes: T = Object.assign({}, attributes);\n  Object.assign(newAttributes, {kernelShape, pads});\n  return newAttributes;\n};\n\nexport const parseConvAttributes = (attributes: Record<string, unknown>): ConvAttributes => {\n  const activationAttributes = parseInternalActivationAttributes(attributes);\n  // TODO : Make this generic enough to compute default attributes for multi-dimensional conv\n  const format = attributes.format as 'NHWC' | 'NCHW';\n  const autoPad = ['NOTSET', 'VALID', 'SAME_UPPER', 'SAME_LOWER'][attributes.auto_pad as number];\n  const dilations = attributes.dilations as [number, number];\n  const group = attributes.group as number;\n  const kernelShape = attributes.kernel_shape as [number, number];\n  const pads = attributes.pads as [number, number, number, number];\n  const strides = attributes.strides as [number, number];\n  const wIsConst = (attributes.w_is_const as () => boolean)();\n\n  return {\n    autoPad,\n    format,\n    dilations,\n    group,\n    kernelShape,\n    pads,\n    strides,\n    wIsConst,\n    ...activationAttributes,\n    cacheKey: `${attributes.format};${activationAttributes.activation};`\n  };\n};\n\nconst conv2d = (context: ComputeContext, inputs: readonly TensorView[], attributes: ConvAttributes): void => {\n  const adjustedAttributes = getAdjustedConvAttributes(attributes, inputs);\n\n  // check attributes\n\n  // const hasPreluActivationWeights = false; /* TODO: add support for prelu activation weights */\n  const isChannelsLast = attributes.format === 'NHWC';\n  if (attributes.group !== 1) {\n    // NVIDIA GPU with ampere architecture fails with below 2 cases, but we couldn't repro them with any other\n    // GPUs. So just disable vectorize on NVIDIA ampere to ensure always correct outputs.\n    // [webgpu]Conv - conv - vectorize group - B\n    // [webgpu]Conv - conv - vectorize group - D\n    const enableGroupedConvVectorize = !context.adapterInfo.isArchitecture('ampere');\n    if (enableGroupedConvVectorize && isChannelsLast && inputs[1].dims[0] === attributes.group &&\n        inputs[1].dims[1] === 1 && attributes.dilations[0] === 1 && attributes.dilations[1] === 1) {\n      const outputShape = calculateOutputShape(\n          inputs[0].dims, inputs[1].dims, attributes.dilations, adjustedAttributes.pads, attributes.strides,\n          isChannelsLast);\n      const transposedWeight = (context.kernelCustomData.wT as TensorView | undefined) ??\n          context.compute(\n              createTransposeProgramInfo(inputs[1], weightTransposeAttribute),\n              {inputs: [1], outputs: [attributes.wIsConst ? -2 : -1]})[0];\n      if (attributes.wIsConst && !context.kernelCustomData.wT) {\n        context.kernelCustomData.wT = transposedWeight;\n      }\n      const convInputs = [inputs[0], transposedWeight];\n      if (inputs.length === 3) {\n        convInputs.push(inputs[2]);\n      }\n      context.compute(\n          createGroupedConvVectorizeProgramInfo(convInputs, adjustedAttributes, outputShape), {inputs: convInputs});\n    } else {\n      context.compute(createGroupedConvProgramInfo(inputs, adjustedAttributes));\n    }\n    return;\n  }\n\n  const hasBias = inputs.length === 3;\n  const inputHeight = inputs[0].dims[isChannelsLast ? 1 : 2];\n  const inputWidth = inputs[0].dims[isChannelsLast ? 2 : 3];\n  const inputChannels = inputs[0].dims[isChannelsLast ? 3 : 1];\n  const weightHeight = inputs[1].dims[2];\n  const weightWidth = inputs[1].dims[3];\n\n  const outputShape = calculateOutputShape(\n      inputs[0].dims, inputs[1].dims, attributes.dilations, adjustedAttributes.pads, attributes.strides,\n      isChannelsLast);\n  const outHeight = outputShape[isChannelsLast ? 1 : 2];\n  const outWidth = outputShape[isChannelsLast ? 2 : 3];\n  const outChannels = outputShape[isChannelsLast ? 3 : 1];\n\n  const sameSize = isChannelsLast && weightHeight === inputHeight && weightWidth === inputWidth &&\n      attributes.pads[0] === 0 && attributes.pads[1] === 0;\n  if (sameSize ||\n      (weightHeight === 1 && weightWidth === 1 && attributes.dilations[0] === 1 && attributes.dilations[1] === 1 &&\n       attributes.strides[0] === 1 && attributes.strides[1] === 1 && attributes.pads[0] === 0 &&\n       attributes.pads[1] === 0)) {\n    // conv2dByMatMul\n    const batch = outputShape[0];\n    let xReshaped, wReshaped, matmulOutputShape;\n    const matmulInputs = [];\n    if (isChannelsLast) {\n      const transposedWeight = (context.kernelCustomData.wT as TensorView | undefined) ??\n          context.compute(\n              createTransposeProgramInfo(inputs[1], weightTransposeAttribute),\n              {inputs: [1], outputs: [attributes.wIsConst ? -2 : -1]})[0];\n      if (attributes.wIsConst && !context.kernelCustomData.wT) {\n        context.kernelCustomData.wT = transposedWeight;\n      }\n      if (sameSize) {\n        const sharedDim = inputHeight * inputWidth * inputChannels;\n        xReshaped = inputs[0].reshape([1, batch, sharedDim]);\n        wReshaped = transposedWeight.reshape([1, sharedDim, outChannels]);\n        matmulOutputShape = [1, batch, outChannels];\n      } else {\n        xReshaped = inputs[0].reshape([batch, inputHeight * inputWidth, inputChannels]);\n        wReshaped = transposedWeight.reshape([1, inputChannels, outChannels]);\n        matmulOutputShape = [batch, outHeight * outWidth, outChannels];\n      }\n      matmulInputs.push(xReshaped);\n      matmulInputs.push(wReshaped);\n    } else {\n      xReshaped = inputs[0].reshape([batch, inputChannels, inputHeight * inputWidth]);\n      wReshaped = inputs[1].reshape([1, outChannels, inputChannels]);\n      matmulOutputShape = [batch, outChannels, outHeight * outWidth];\n      matmulInputs.push(wReshaped);\n      matmulInputs.push(xReshaped);\n    }\n    if (hasBias) {\n      matmulInputs.push(inputs[2]);\n    }\n    const N = matmulOutputShape[2];\n    const K = matmulInputs[0].dims[matmulInputs[0].dims.length - 1];\n    // Tune the threshold.\n    if (N < 8 && K < 8) {\n      context.compute(\n          createNaiveMatmulProgramInfo(\n              matmulInputs, adjustedAttributes, outputShape, matmulOutputShape, isChannelsLast),\n          {inputs: matmulInputs});\n    } else {\n      context.compute(\n          createMatmulProgramInfo(matmulInputs, adjustedAttributes, outputShape, matmulOutputShape, isChannelsLast),\n          {inputs: matmulInputs});\n    }\n    return;\n  }\n\n  // TODO: implement conv2dWithIm2Col()\n\n  const sequentialAccessByThreads = /* backend.adapterInfo.isIntel() */ true;\n\n  // STEP.1: transpose weight\n  const transposedWeight = (context.kernelCustomData.wT as TensorView | undefined) ??\n      context.compute(\n          createTransposeProgramInfo(inputs[1], weightTransposeAttribute),\n          {inputs: [1], outputs: [attributes.wIsConst ? -2 : -1]})[0];\n  if (attributes.wIsConst && !context.kernelCustomData.wT) {\n    context.kernelCustomData.wT = transposedWeight;\n  }\n\n  // STEP.2: prepare reshaped inputs\n  const convInputs = [inputs[0], transposedWeight];\n  if (hasBias) {\n    convInputs.push(inputs[2]);\n  }\n\n  // STEP.3: compute matmul\n  const dimAOuter = isChannelsLast ? outHeight * outWidth : outChannels;\n  const dimBOuter = isChannelsLast ? outChannels : outHeight * outWidth;\n  const dimInner = weightHeight * weightWidth * inputChannels;\n  context.compute(\n      createConv2DMatMulProgramInfo(\n          convInputs, adjustedAttributes, outputShape, dimAOuter, dimBOuter, dimInner, hasBias,\n          sequentialAccessByThreads),\n      {inputs: convInputs});\n};\n\nconst conv1d = (context: ComputeContext, attributes: ConvAttributes): void => {\n  // extend the input to 2D by adding H dimension\n  const isChannelLast = attributes.format === 'NHWC';\n  const inputs = [\n    context.inputs[0].reshape(\n        isChannelLast ?\n            // [N, W, C] -> [N, H=1, W, C]\n            [context.inputs[0].dims[0], 1, context.inputs[0].dims[1], context.inputs[0].dims[2]] :\n            // [N, C, W] -> [N, C, H=1, W]\n            [context.inputs[0].dims[0], context.inputs[0].dims[1], 1, context.inputs[0].dims[2]]),\n    //[FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kW] -> [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kH=1, kW]\n    context.inputs[1].reshape([context.inputs[1].dims[0], context.inputs[1].dims[1], 1, context.inputs[1].dims[2]])\n  ];\n  if (context.inputs.length === 3) {\n    inputs.push(context.inputs[2]);\n  }\n  const pads = [0, attributes.pads[0], 0, attributes.pads[1]];\n  const strides = [1].concat(attributes.strides);\n  const dilations = [1].concat(attributes.dilations);\n  const kernelShape = [1].concat(attributes.kernelShape);\n  const adjustedAttributes = getAdjustedConvAttributes({...attributes, pads, strides, dilations, kernelShape}, inputs);\n  context.compute(createGroupedConvProgramInfo(\n      inputs, adjustedAttributes,\n      outputShape => isChannelLast ? [outputShape[0], outputShape[2], outputShape[3]] : []));\n};\n\nexport const conv = (context: ComputeContext, attributes: ConvAttributes): void => {\n  validateInputs(context.inputs, attributes);  // currently will fail if not conv1D/2D\n  if (context.inputs[0].dims.length === 3) {\n    conv1d(context, attributes);\n  } else {\n    conv2d(context, context.inputs, attributes);\n  }\n};\n", "/**\n * @license\n * Copyright 2021 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/conv_backprop_mm_webgpu.ts\n//\n// modified to fit the needs of the project\n\nimport {DataType} from '../../../../wasm-common';\nimport {LOG_DEBUG} from '../../../log';\nimport {TensorView} from '../../../tensor-view';\nimport {ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../../types';\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from '../common';\nimport {ConvTransposeAttributes} from '../conv-transpose';\nimport {appendActivationUniforms, appendActivationUniformsData, getActivationSnippet} from '../fuse-utils';\n\nimport {biasSnippet} from './activation_util';\nimport {utilFunctions} from './conv_util';\nimport {makeMatMulPackedSource, makeMatMulPackedVec4Source} from './matmul_packed_webgpu';\n\nconst conv2dTransposeCommonSnippet =\n    (isChannelsLast: boolean, addBias = false, attributes: ConvTransposeAttributes, type: string,\n     innerElementSize = 4): string => {\n      const getWSnippet = (innerElementSize: number) => {\n        switch (innerElementSize) {\n          case 1:\n            return 'return w[getIndexFromCoords4D(coord, vec4<i32>(uniforms.w_shape))];';\n          case 4:\n            return `\n            let coord1 = vec4<i32>(coordX, coordY, col + 1, rowInner);\n            let coord2 = vec4<i32>(coordX, coordY, col + 2, rowInner);\n            let coord3 = vec4<i32>(coordX, coordY, col + 3, rowInner);\n            let v0 = w[getIndexFromCoords4D(coord, vec4<i32>(uniforms.w_shape))];\n            let v1 = w[getIndexFromCoords4D(coord1, vec4<i32>(uniforms.w_shape))];\n            let v2 = w[getIndexFromCoords4D(coord2, vec4<i32>(uniforms.w_shape))];\n            let v3 = w[getIndexFromCoords4D(coord3, vec4<i32>(uniforms.w_shape))];\n            return ${type}(v0, v1, v2, v3);\n            `;\n          default:\n            throw new Error(`innerElementSize ${innerElementSize} is not supported.`);\n        }\n      };\n      const coordASnippet = isChannelsLast ? `\n      let coord = vec4<i32>(batch, iXR, iXC, xCh);\n      ` :\n                                             `\n      let coord = vec4<i32>(batch, xCh, iXR, iXC);\n      `;\n\n      const coordResSnippet = isChannelsLast ? `\n    let coords = vec4<i32>(\n      batch,\n      row / outWidth,\n      row % outWidth,\n      col);\n    ` :\n                                               `\n    let coords = vec4<i32>(\n      batch,\n      row,\n      col / outWidth,\n      col % outWidth);\n    `;\n\n      const xHeight = isChannelsLast ? 'i32(uniforms.x_shape[1])' : 'i32(uniforms.x_shape[2])';\n      const xWidth = isChannelsLast ? 'i32(uniforms.x_shape[2])' : 'i32(uniforms.x_shape[3])';\n      const row = isChannelsLast ? 'row' : 'col';\n      const col = isChannelsLast ? 'col' : 'row';\n\n      const readASnippet = `\n      let inChannels = ${isChannelsLast ? 'i32(uniforms.x_shape[3])' : 'i32(uniforms.x_shape[1])'};\n      let outWidth = ${isChannelsLast ? 'i32(uniforms.result_shape[2])' : 'i32(uniforms.result_shape[3])'};\n      let outRow = ${row} / outWidth;\n      let outCol = ${row} % outWidth;\n\n      let WRow = ${col} / (uniforms.filter_dims[1] * inChannels);\n      let WCol = ${col} / inChannels % uniforms.filter_dims[1];\n      let xR = f32(outRow - uniforms.pads[0] + uniforms.dilations[0] * WRow) / f32(uniforms.strides[0]);\n      let xC = f32(outCol - uniforms.pads[1] + uniforms.dilations[1] * WCol) / f32(uniforms.strides[1]);\n      if (xR < 0.0 || xR >= f32(${xHeight}) || fract(xR) > 0.0) {\n        return ${type}(0.0);\n      }\n      if (xC < 0.0 || xC >= f32(${xWidth}) || fract(xC) > 0.0) {\n        return ${type}(0.0);\n      }\n      let iXR = i32(xR);\n      let iXC = i32(xC);\n      let xCh = ${col} % inChannels;\n      ${coordASnippet}\n      return x[getIndexFromCoords4D(coord, vec4<i32>(uniforms.x_shape))/${innerElementSize}];`;\n\n      const sampleA = isChannelsLast ? `\n      let col = colIn * ${innerElementSize};\n      if (row < uniforms.dim_a_outer && col < uniforms.dim_inner) {\n        ${readASnippet}\n      }\n      return ${type}(0.0);` :\n                                       `\n      let col = colIn * ${innerElementSize};\n      if (row < uniforms.dim_inner && col < uniforms.dim_b_outer) {\n        ${readASnippet}\n      }\n      return ${type}(0.0);`;\n\n      const sampleW = `\n      let col = colIn * ${innerElementSize};\n      let inChannels = ${isChannelsLast ? 'i32(uniforms.x_shape[3])' : 'i32(uniforms.x_shape[1])'};\n      let coordX = uniforms.filter_dims[0] - 1 - row / (uniforms.filter_dims[1] * inChannels);\n      let coordY = uniforms.filter_dims[1] - 1 - (row / inChannels) % uniforms.filter_dims[1];\n      if (${\n          isChannelsLast ? 'row < uniforms.dim_inner && col < uniforms.dim_b_outer' :\n                           'row < uniforms.dim_inner && col < uniforms.dim_a_outer'}  && coordX >= 0 && coordY >= 0) {\n        let rowInner = row % inChannels;\n        let coord = vec4<i32>(coordX, coordY, col, rowInner);\n        ${getWSnippet(innerElementSize)}\n      }\n      return ${type}(0.0);\n      `;\n\n      const applyActivation = getActivationSnippet(attributes, type);\n      const userCode = `\n  fn mm_readA(batch: i32, row : i32, colIn : i32) -> ${type} {\n    ${isChannelsLast ? sampleA : sampleW}\n  }\n\n  fn mm_readB(batch: i32, row : i32, colIn : i32) -> ${type} {\n    ${isChannelsLast ? sampleW : sampleA}\n  }\n\n  fn mm_write(batch: i32, row : i32, colIn : i32, valueInput : ${type}) {\n    let col = colIn * ${innerElementSize};\n    if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer) {\n      var value = valueInput;\n      let outWidth = ${isChannelsLast ? 'i32(uniforms.result_shape[2])' : 'i32(uniforms.result_shape[3])'};\n      ${coordResSnippet}\n      ${biasSnippet(addBias)}\n      ${applyActivation}\n      result[getIndexFromCoords4D(coords, vec4<i32>(uniforms.result_shape))/${innerElementSize}] = value;\n    }\n  }`;\n      return userCode;\n    };\n\nexport const createConv2DTransposeMatMulProgramInfo =\n    (inputs: readonly TensorView[], attributes: ConvTransposeAttributes, outputShape: readonly number[],\n     dimAOuter: number, dimBOuter: number, dimInner: number, hasBias: boolean,\n     sequentialAccessByThreads: boolean): ProgramInfo => {\n      const isChannelsLast = attributes.format === 'NHWC';\n      const inChannels = isChannelsLast ? inputs[0].dims[3] : inputs[0].dims[1];\n      const batchSize = outputShape[0];\n      const outWidth = isChannelsLast ? outputShape[2] : outputShape[3];\n      const outHeight = isChannelsLast ? outputShape[1] : outputShape[2];\n      const outChannels = isChannelsLast ? outputShape[3] : outputShape[1];\n      // TODO: enable vec4 for NCHW\n      const isVec4 = isChannelsLast && (inChannels % 4 === 0 && inChannels % 3) && outChannels % 4 === 0;\n\n      // TODO: fine tune size\n      const dispatchX = isChannelsLast ? outChannels : outWidth * outHeight;\n      const dispatchY = isChannelsLast ? outWidth * outHeight : outChannels;\n      const workGroupSize: [number, number, number] = [8, 8, 1];\n      const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];\n      const dispatch = [\n        Math.ceil(dispatchX / workGroupSize[0] / elementsPerThread[0]),\n        Math.ceil(dispatchY / workGroupSize[1] / elementsPerThread[1]),\n        Math.ceil(batchSize / workGroupSize[2] / elementsPerThread[2])\n      ];\n\n      LOG_DEBUG('verbose', () => `[conv_backprop_mm_webgpu] dispatch = ${dispatch}`);\n\n      const innerElementSize = isVec4 ? 4 : 1;\n      const tileInner = Math.max(workGroupSize[0] * innerElementSize, workGroupSize[1]);\n      const components = isVec4 ? 4 : 1;\n      const filterDims =\n          [attributes.kernelShape[isChannelsLast ? 1 : 2], attributes.kernelShape[isChannelsLast ? 2 : 3]];\n      const effectiveFilterDims = [\n        filterDims[0] + (attributes.dilations[0] <= 1 ? 0 : (filterDims[0] - 1) * (attributes.dilations[0] - 1)),\n        filterDims[1] + (attributes.dilations[1] <= 1 ? 0 : (filterDims[1] - 1) * (attributes.dilations[1] - 1))\n      ];\n      const pads = [\n        effectiveFilterDims[0] - 1 - Math.floor((attributes.pads[0] + attributes.pads[2]) / 2),\n        effectiveFilterDims[1] - 1 - Math.floor((attributes.pads[1] + attributes.pads[3]) / 2)\n      ];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.int32, data: dimAOuter}, {type: DataType.int32, data: dimBOuter},\n        {type: DataType.int32, data: dimInner}, {type: DataType.int32, data: attributes.strides},\n        {type: DataType.int32, data: attributes.dilations}, {type: DataType.int32, data: filterDims},\n        {type: DataType.int32, data: pads}\n      ];\n      appendActivationUniformsData(attributes, programUniforms);\n      programUniforms.push(...createTensorShapeVariables(inputs[0].dims, inputs[1].dims));\n\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n        inputDependencies.push('rank');\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShape));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const x = inputVariable('x', inputs[0].dataType, inputs[0].dims.length, components);\n        const w = inputVariable('w', inputs[1].dataType, inputs[1].dims.length, 1);\n        const output = outputVariable('result', inputs[0].dataType, outputShape.length, components);\n        const inputVariables = [x, w];\n\n        let declareFunctions = '';\n        if (hasBias) {\n          const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims.length, components);\n          inputVariables.push(bias);\n          declareFunctions += `\n          fn getBiasByOutputCoords(coords : vec4<i32>) -> ${bias.type.value} {\n            return bias[coords.${isChannelsLast ? 'w' : 'y'}${isVec4 ? '/ 4' : ''}];\n          }`;\n        }\n\n        const uniforms: UniformsArrayType = [\n          {name: 'dim_a_outer', type: 'i32'}, {name: 'dim_b_outer', type: 'i32'}, {name: 'dim_inner', type: 'i32'},\n          {name: 'strides', type: 'i32', length: 2}, {name: 'dilations', type: 'i32', length: 2},\n          {name: 'filter_dims', type: 'i32', length: filterDims.length},\n          {name: 'pads', type: 'i32', length: pads.length}\n        ];\n        appendActivationUniforms(attributes, uniforms);\n        const elemType = tensorTypeToWsglStorageType(inputs[0].dataType, 1);\n        if (elemType !== 'f16' && elemType !== 'f32') {\n          throw new Error(`elemType ${elemType} is not supported.`);\n        }\n        return `\n        ${utilFunctions('uniforms.result_strides')}\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)};\n        ${declareFunctions}\n        ${conv2dTransposeCommonSnippet(isChannelsLast, hasBias, attributes, x.type.value, innerElementSize)}\n        ${\n            isVec4 ? makeMatMulPackedVec4Source(\n                         elementsPerThread, workGroupSize, elemType, undefined, !isChannelsLast, tileInner) :\n                     makeMatMulPackedSource(\n                         elementsPerThread, workGroupSize, elemType, undefined, !isChannelsLast, tileInner, false,\n                         undefined, sequentialAccessByThreads)}`;\n      };\n\n      return {\n        name: 'Conv2DTransposeMatMul',\n        shaderCache:\n            {hint: `${attributes.cacheKey};${elementsPerThread};${workGroupSize};${isVec4}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: dispatch[0], y: dispatch[1], z: dispatch[2]},\n          programUniforms\n        }),\n        getShaderSource\n      };\n    };\n", "/**\n * @license\n * Copyright 2021 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/conv_backprop_webgpu.ts\n\nimport {DataType} from '../../../../wasm-common';\nimport {LOG_DEBUG} from '../../../log';\nimport {TensorView} from '../../../tensor-view';\nimport {ShapeUtil} from '../../../util';\nimport {ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../../types';\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from '../common';\nimport {ConvTransposeAttributes} from '../conv-transpose';\n\nconst createConvTranspose2DOpProgramShaderSource =\n    (shaderHelper: ShaderHelper, inputs: readonly TensorView[], outputShape: readonly number[], hasBias: boolean,\n     is1DimensionDispatch: boolean, isVec4 = false, dataType: string, uniforms: UniformsArrayType,\n     isChannelsLast = false): string => {\n      const rowDim = isChannelsLast ? 1 : 2;\n      const colDim = isChannelsLast ? 2 : 3;\n      const channelDim = isChannelsLast ? 3 : 1;\n      const workPerThread = isVec4 ? 2 : 1;\n\n      let declareFunctions = `\n  fn setOutputAtIndex(flatIndex : u32, value : ${isVec4 ? `vec4<${dataType}>` : dataType}) {\n    result[flatIndex] = ${isVec4 ? `vec4<${dataType}>` : dataType}(value);\n  }`;\n      if (hasBias) {\n        declareFunctions += `\n    fn getBiasByOutputCoords(coords : vec4<u32>) -> ${isVec4 ? `vec4<${dataType}>` : dataType} {\n      return bias[coords.${isChannelsLast ? 'w' : 'y'}${isVec4 ? '/ 4' : ''}];\n    }`;\n      }\n      const components = isVec4 ? 4 : 1;\n      const w = inputVariable('W', inputs[1].dataType, inputs[1].dims.length, components);\n      const dy = inputVariable('Dy', inputs[0].dataType, inputs[0].dims.length, components);\n      const inputVariables = [dy, w];\n      if (hasBias) {\n        inputVariables.push(inputVariable('bias', inputs[2].dataType, [outputShape[channelDim]].length, components));\n      }\n      const output = outputVariable('result', inputs[0].dataType, outputShape.length, components);\n\n      const codeSnippet4 = `{\n        let batch: u32 = ${is1DimensionDispatch ? 'global_id.z' : 'workgroup_id.z'} / uniforms.result_shape[1];\n        let r = ${is1DimensionDispatch ? 'global_id.z' : 'workgroup_id.z'} % uniforms.result_shape[1];\n        let c = ${is1DimensionDispatch ? 'global_id.y' : 'workgroup_id.y'} * ${workPerThread};\n        let d1: u32 = ${is1DimensionDispatch ? 'global_id.x' : 'workgroup_id.x'} * 4;\n\n        let dyCorner = vec2<i32>(i32(r), i32(c)) - vec2<i32>(uniforms.pads);\n\n        // Convolve dy(?, ?, d2) with w(:, :, d1, d2) to compute dx(xR, xC, d1).\n        // ? = to be determined. : = across all values in that axis.\n        var dotProd: array<vec4<${dataType}>, ${workPerThread}>;\n        for (var i = 0; i < ${workPerThread}; i++) {\n          dotProd[i] = vec4<${dataType}>(0.0);\n        }\n        for (var wR: u32 = 0; wR < uniforms.filter_dims[0]; wR = wR + 1) {\n          var dyR = (${dataType}(dyCorner.x) + ${dataType}(wR)) / ${dataType}(uniforms.strides.x);\n          let wRPerm = uniforms.filter_dims[0] - 1 - wR;\n          if (dyR < 0.0 || dyR >= ${dataType}(uniforms.Dy_shape[1]) ||\n              fract(dyR) > 0.0 || wRPerm < 0) {\n            continue;\n          }\n          let idyR: u32 = u32(dyR);\n\n          for (var wC: u32 = 0; wC < uniforms.filter_dims[1]; wC = wC + 1) {\n            let dyC = (${dataType}(dyCorner.y) + ${dataType}(wC)) / ${dataType}(uniforms.strides.y);\n            let dyC2 = (${dataType}(dyCorner.y) + 1.0 + ${dataType}(wC)) / ${dataType}(uniforms.strides.y);\n            let wCPerm = uniforms.filter_dims[1] - 1 - wC;\n            if (wCPerm < 0) {\n              continue;\n            }\n            var bDyCVal = true;\n            var bDyCVal2 = true;\n            if (dyC < 0.0 || dyC >= ${dataType}(uniforms.Dy_shape[2]) ||\n                fract(dyC) > 0.0) {\n              bDyCVal = false;\n            }\n            if (dyC2 < 0.0 || dyC2 >= ${dataType}(uniforms.Dy_shape[2]) ||\n                fract(dyC2) > 0.0) {\n              bDyCVal2 = false;\n            }\n\n            let idyC: u32 = u32(dyC);\n            let idyC2: u32 = u32(dyC2);\n            if (bDyCVal && bDyCVal2) {\n              let d2Length = uniforms.Dy_shape[3];\n              for (var d2 :u32 = 0; d2 < d2Length; d2 = d2 + 4) {\n                let wValue0 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1', 'd2')};\n                let wValue1 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 1', 'd2')};\n                let wValue2 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 2', 'd2')};\n                let wValue3 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 3', 'd2')};\n\n                var xValue = ${dy.get('batch', 'idyR', 'idyC', 'd2')};\n                let tmpval = vec4<${dataType}>(dot(xValue, wValue0),\n                                      dot(xValue, wValue1),\n                                      dot(xValue, wValue2),\n                                      dot(xValue, wValue3));\n                dotProd[0] = dotProd[0] + tmpval;\n\n                xValue =  ${dy.get('batch', 'idyR', 'idyC2', 'd2')};\n\n                dotProd[1] = dotProd[1] + vec4<${dataType}>(dot(xValue, wValue0),\n                                                    dot(xValue, wValue1),\n                                                    dot(xValue, wValue2),\n                                                    dot(xValue, wValue3));\n              }\n            } else if (bDyCVal) {\n              let d2Length = uniforms.Dy_shape[${channelDim}];\n              for (var d2: u32 = 0; d2 < d2Length; d2 = d2 + 4) {\n                let wValue0 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1', 'd2')};\n                let wValue1 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 1', 'd2')};\n                let wValue2 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 2', 'd2')};\n                let wValue3 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 3', 'd2')};\n\n                var xValue = ${dy.get('batch', 'idyR', 'idyC', 'd2')};\n                let tmpval = vec4<${dataType}>(dot(xValue, wValue0),\n                                      dot(xValue, wValue1),\n                                      dot(xValue, wValue2),\n                                      dot(xValue, wValue3));\n                dotProd[0] = dotProd[0] + tmpval;\n              }\n            } else if (bDyCVal2) {\n              let d2Length = uniforms.Dy_shape[3];\n              for (var d2: u32 = 0; d2 < d2Length; d2 = d2 + 4) {\n                let wValue0 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1', 'd2')};\n                let wValue1 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 1', 'd2')};\n                let wValue2 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 2', 'd2')};\n                let wValue3 = ${w.get('u32(wRPerm)', 'u32(wCPerm)', 'd1 + 3', 'd2')};\n\n                var xValue = ${dy.get('batch', 'idyR', 'idyC2', 'd2')};\n                let tmpval = vec4<${dataType}>(dot(xValue, wValue0),\n                                      dot(xValue, wValue1),\n                                      dot(xValue, wValue2),\n                                      dot(xValue, wValue3));\n                dotProd[1] = dotProd[1] + tmpval;\n              }\n            }\n          }\n        }\n\n        for (var i: u32 = 0; i < ${workPerThread}; i = i + 1) {\n          let value = dotProd[i] + ${hasBias ? 'bias[c+i]' : `vec4<${dataType}>(0.0)`};\n          ${output.set('batch', 'r', 'c + i', 'd1', 'value')};\n        }\n      }`;\n      const codeSnippet = `\n          let outputIndices = ${output.offsetToIndices('global_idx')};\n          let batch = ${output.indicesGet('outputIndices', 0)};\n          let d1 = ${output.indicesGet('outputIndices', channelDim)};\n          let r = ${output.indicesGet('outputIndices', rowDim)};\n          let c = ${output.indicesGet('outputIndices', colDim)};\n          let dyCorner = vec2<i32>(i32(r), i32(c)) - uniforms.pads;\n          let dyRCorner = dyCorner.x;\n          let dyCCorner = dyCorner.y;\n          let groupId = d1 / uniforms.output_channels_per_group;\n          let wOutChannel = d1 - groupId * uniforms.output_channels_per_group;\n          // Convolve dy(?, ?, d2) with w(:, :, d1, d2) to compute dx(xR, xC, d1).\n          // ? = to be determined. : = across all values in that axis.\n          var dotProd = ${dataType}(0.0);\n          for (var wR: u32 = 0; wR < uniforms.effective_filter_dims.x; wR = wR + 1) {\n            if (wR % uniforms.dilations.x != 0) {\n              continue;\n            }\n            let dyR = (${dataType}(dyRCorner) + ${dataType}(wR)) / ${dataType}(uniforms.strides[0]);\n            let wRPerm = uniforms.filter_dims.x - 1 - wR / uniforms.dilations.x;\n            if (dyR < 0.0 || dyR >= ${dataType}(uniforms.Dy_shape[${rowDim}]) || fract(dyR) > 0.0 ||\n                wRPerm < 0) {\n              continue;\n            }\n            let idyR: u32 = u32(dyR);\n\n            for (var wC: u32 = 0; wC < uniforms.effective_filter_dims.y; wC = wC + 1) {\n              if (wC % uniforms.dilations.y != 0) {\n                continue;\n              }\n              let dyC = (${dataType}(dyCCorner) + ${dataType}(wC)) / ${dataType}(uniforms.strides.y);\n              let wCPerm = uniforms.filter_dims.y - 1 - wC / uniforms.dilations.y;\n              if (dyC < 0.0 || dyC >= ${dataType}(uniforms.Dy_shape[${colDim}]) ||\n                  fract(dyC) > 0.0 || wCPerm < 0) {\n                continue;\n              }\n              let idyC: u32 = u32(dyC);\n              var inputChannel = groupId * uniforms.input_channels_per_group;\n              for (var d2: u32 = 0; d2 < uniforms.input_channels_per_group; d2 = d2 + 1) {\n                let xValue = ${\n          isChannelsLast ? dy.get('batch', 'idyR', 'idyC', 'inputChannel') :\n                           dy.get('batch', 'inputChannel', 'idyR', 'idyC')};\n                let wValue = ${w.get('inputChannel', 'wOutChannel', 'u32(wRPerm)', 'u32(wCPerm)')};\n                dotProd = dotProd + xValue * wValue;\n                inputChannel = inputChannel + 1;\n              }\n            }\n          }\n          let value = dotProd + ${hasBias ? 'bias[d1]' : `${dataType}(0.0)`};\n          ${output.setByOffset('global_idx', 'value')};\n        `;\n\n      return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n  ${declareFunctions}\n\n    ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')};\n  ${isVec4 ? codeSnippet4 : codeSnippet}}`;\n    };\n\nexport const createConvTranspose2DProgramInfo =\n    (inputs: readonly TensorView[], attributes: ConvTransposeAttributes,\n     squeezeOutputShapeFunction?: (shape: readonly number[]) => number[]): ProgramInfo => {\n      const hasBias = inputs.length > 2;\n      // const isChannelsLast = attributes.format === 'NHWC';\n      const outputShape = attributes.outputShape;\n      const outputSize = ShapeUtil.size(outputShape);\n\n      // const inChannels = inputs[0].dims[isChannelsLast ? 3 : 1];\n      // TODO Enable isVec4 for performance\n      // Disabled due to weight matrix layout issue\n      // const isVec4 = attributes.group === 1 && isChannelsLast && inChannels % 4 === 0 && outChannels % 4 === 0;\n      const dispatch = [\n        Math.ceil(outputSize / 64),\n        1,\n        1,\n      ];\n      LOG_DEBUG('verbose', () => `[conv2d_backprop_webgpu] dispatch = ${dispatch}`);\n\n      const isChannelsLast = attributes.format === 'NHWC';\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n      const strides = [attributes.strides[0], attributes.strides[1]];\n      const filterDims =\n          [attributes.kernelShape[isChannelsLast ? 1 : 2], attributes.kernelShape[isChannelsLast ? 2 : 3]];\n      const dilations = [attributes.dilations[0], attributes.dilations[1]];\n      const effectiveFilterDims = [\n        filterDims[0] +\n            (attributes.dilations[0] <= 1 ?\n                 0 :\n                 (attributes.kernelShape[isChannelsLast ? 1 : 2] - 1) * (attributes.dilations[0] - 1)),\n        filterDims[1] +\n            (attributes.dilations[1] <= 1 ?\n                 0 :\n                 (attributes.kernelShape[isChannelsLast ? 2 : 3] - 1) * (attributes.dilations[1] - 1))\n      ];\n      const pads = [\n        effectiveFilterDims[0] - 1 - Math.floor((attributes.pads[0] + attributes.pads[2]) / 2),\n        effectiveFilterDims[1] - 1 - Math.floor(attributes.pads[1] + attributes.pads[3]) / 2\n      ];\n\n      const isVec4 = false;\n      const group = attributes.group;\n      const wShape = inputs[1].dims;\n      const inputChannelsPerGroup = wShape[0] / group;\n      const outputChannelsPerGroup = wShape[1];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: strides},\n        {type: DataType.uint32, data: filterDims}, {type: DataType.uint32, data: dilations},\n        {type: DataType.uint32, data: effectiveFilterDims}, {type: DataType.int32, data: pads},\n        {type: DataType.uint32, data: inputChannelsPerGroup}, {type: DataType.uint32, data: outputChannelsPerGroup},\n        ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims)\n      ];\n      if (hasBias) {\n        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n        inputDependencies.push('rank');\n      }\n      programUniforms.push(...createTensorShapeVariables(outputShape));\n\n      const is1DimensionDispatch = dispatch[1] === 1 && dispatch[2] === 1;\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const uniforms: UniformsArrayType = [\n          {name: 'output_size', type: 'u32'}, {name: 'strides', type: 'u32', length: strides.length},\n          {name: 'filter_dims', type: 'u32', length: filterDims.length},\n          {name: 'dilations', type: 'u32', length: filterDims.length},\n          {name: 'effective_filter_dims', type: 'u32', length: effectiveFilterDims.length},\n          {name: 'pads', type: 'i32', length: pads.length}, {name: 'input_channels_per_group', type: 'u32'},\n          {name: 'output_channels_per_group', type: 'u32'}\n        ];\n        const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n        return `${\n            createConvTranspose2DOpProgramShaderSource(\n                shaderHelper, inputs, outputShape, hasBias, is1DimensionDispatch, isVec4, dataType, uniforms,\n                isChannelsLast)}`;\n      };\n      return {\n        name: 'ConvTranspose2D',\n        shaderCache: {hint: `${attributes.cacheKey};`, inputDependencies},\n        getRunData: () => ({\n          dispatchGroup: {x: dispatch[0], y: dispatch[1], z: dispatch[2]},\n          outputs: [{\n            dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,\n            dataType: inputs[0].dataType\n          }],\n          programUniforms\n        }),\n        getShaderSource\n      };\n    };\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TensorView} from '../../tensor-view';\nimport {ComputeContext} from '../types';\n\nimport {createConv2DTransposeMatMulProgramInfo} from './3rd-party/conv_backprop_mm_webgpu';\nimport {createConvTranspose2DProgramInfo} from './3rd-party/conv_backprop_webgpu';\nimport {ConvAttributes} from './conv';\nimport {parseInternalActivationAttributes} from './fuse-utils';\nimport {createTransposeProgramInfo} from './transpose';\n\nconst computeTotalPad =\n    (inDim: number, stride: number, adj: number, kernel: number, dilation: number, outSize: number) =>\n        (inDim - 1) * stride + adj + (kernel - 1) * dilation + 1 - outSize;\n\nconst distributePadding = (totalPad: number, autoPad: string, pads: number[], head: number, tail: number) => {\n  const smallPad = Math.floor(totalPad / 2);\n  if (autoPad === 'SAME_UPPER') {\n    pads[head] = smallPad;\n    pads[tail] = totalPad - smallPad;\n  } else if (autoPad === 'SAME_LOWER') {\n    pads[head] = totalPad - smallPad;\n    pads[tail] = smallPad;\n  }\n};\n\nconst calculateOutputShapeAndPads =\n    (inputShape: readonly number[], kernelShape: readonly number[], dilations: readonly number[], autoPad: string,\n     group: number, pads: number[], strides: readonly number[], isChannelLast: boolean, outputPadding: number[],\n     outputShape: number[]) => {\n      const spatialRank = inputShape.length - 2;\n      const updateOutputShape = outputShape.length === 0;\n      if (outputPadding.length === 0) {\n        for (let i = 0; i < spatialRank; ++i) {\n          outputPadding.push(0);\n        }\n      }\n      const batchSize = inputShape[0];\n      const outChannels = kernelShape[isChannelLast ? 3 : 1] * group;\n      for (let i = 0, j = inputShape.length - spatialRank - (isChannelLast ? 1 : 0); i < spatialRank; ++i, ++j) {\n        const inSize = inputShape[j];\n        const outSize = updateOutputShape ? inSize * strides[i] : outputShape[i];\n        const totalPad = computeTotalPad(inSize, strides[i], pads[i], kernelShape[j], dilations[i], outSize);\n        distributePadding(totalPad, autoPad, pads, i, i + spatialRank);\n        if (updateOutputShape) {\n          outputShape.push(\n              strides[i] * (inSize - 1) + outputPadding[i] + (kernelShape[j] - 1) * dilations[i] + 1 - pads[i] -\n              pads[i + spatialRank]);\n        }\n      }\n      outputShape.splice(0, 0, batchSize);\n      outputShape.splice(isChannelLast ? 3 : 1, 0, outChannels);\n    };\n\nexport interface ConvTransposeAttributes extends ConvAttributes {\n  readonly outputPadding: readonly number[];\n  readonly outputShape: readonly number[];\n}\n\nconst getAdjustedConvTransposeAttributes =\n    <T extends ConvTransposeAttributes>(attributes: T, inputs: readonly TensorView[]): T => {\n      const kernelShape = attributes.kernelShape.slice();\n      // if kernelShape is not specified in the attributes of this op, infer it from the weight tensor dims\n      if (attributes.kernelShape.length === 0 || attributes.kernelShape.reduce((a, b) => a * b, 1) === 0) {\n        kernelShape.length = 0;\n        for (let i = 2; i < inputs[1].dims.length; ++i) {\n          kernelShape.push(inputs[1].dims[i]);\n        }\n      }\n      const isChannelsLast = attributes.format === 'NHWC';\n      kernelShape.splice(0, 0, inputs[1].dims[0]);\n      kernelShape.splice(isChannelsLast ? 3 : 1, 0, inputs[1].dims[1]);\n\n      const pads = attributes.pads.slice();\n      const outputShape = attributes.outputShape.slice();\n      const outputPadding = attributes.outputPadding.slice();\n      const inputShape = inputs[0].dims;\n      let dilations = attributes.dilations.slice();\n      if (dilations.reduce((a, b) => a + b, 0) === 0) {\n        const spatialRank = inputs[0].dims.length - 2;\n        dilations = new Array(spatialRank).fill(1);\n      }\n      let strides = attributes.strides.slice();\n      if (strides.reduce((a, b) => a + b, 0) === 0) {\n        const spatialRank = inputs[0].dims.length - 2;\n        strides = new Array(spatialRank).fill(1);\n      }\n      // If outputShape is not specified in the attributes of this op, infer it from the parameters\n      // Similarly, automatically infer pads if not specified\n      calculateOutputShapeAndPads(\n          inputShape, kernelShape, dilations, attributes.autoPad, attributes.group, pads, strides, isChannelsLast,\n          outputPadding, outputShape);\n\n      // always return a new object so does not modify the original attributes\n      const newAttributes: T = Object.assign({}, attributes);\n      Object.assign(newAttributes, {kernelShape, pads, outputPadding, outputShape, dilations, strides});\n      return newAttributes;\n    };\n\nexport const parseConvTransposeAttributes = (attributes: Record<string, unknown>): ConvTransposeAttributes => {\n  const activationAttributes = parseInternalActivationAttributes(attributes);\n  // TODO : Make this generic enough to compute default attributes for multi-dimensional conv\n  const format = attributes.format as 'NHWC' | 'NCHW';\n  const autoPad =\n      ['NOTSET', 'VALID', 'SAME_UPPER',\n       'SAME_LOWER'][typeof attributes.autoPad == 'undefined' ? 0 : attributes.autoPad as number];\n  const dilations = attributes.dilations as [number, number];\n  const group = attributes.group as number;\n  const kernelShape = attributes.kernelShape as [number, number];\n  const pads = attributes.pads as [number, number, number, number];\n  const strides = attributes.strides as [number, number];\n  const wIsConst = (attributes.wIsConst as () => boolean)();\n  const outputPadding = attributes.outputPadding as [number, number, number, number];\n  const outputShape = attributes.outputShape as [number, number];\n  return {\n    autoPad,\n    format,\n    dilations,\n    group,\n    kernelShape,\n    outputPadding,\n    outputShape,\n    pads,\n    strides,\n    wIsConst,\n    ...activationAttributes,\n    cacheKey: `${attributes.format};${activationAttributes.activation};`\n  };\n};\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: ConvTransposeAttributes): void => {\n  // Refer to the below link for all input checks\n  // https://github.com/onnx/onnx/blob/main/docs/Operators.md#ConvTranspose\n  if (!inputs || (inputs.length !== 2 && inputs.length !== 3)) {\n    throw new Error('Conv requires 2 or 3 inputs');\n  }\n\n  // TODO : Need to add support for multi-dimensional conv\n  if (inputs[0].dims.length !== 4 && inputs[0].dims.length !== 3) {\n    throw new Error('currently only support 2-dimensional conv');\n  }\n\n  if (inputs[0].dims.length !== inputs[1].dims.length) {\n    throw new Error('filter does not have same dimension as input');\n  }\n\n  // FILTER_IN_CHANNEL should be equal to DATA_CHANNEL\n  const dataChannel = inputs[0].dims[attributes.format === 'NHWC' ? inputs[0].dims.length - 1 : 1];\n  const filterInChannel = inputs[1].dims[0];\n  if (dataChannel !== filterInChannel) {\n    throw new Error('FILTER_IN_CHANNEL should be equal to DATA_CHANNEL');\n  }\n\n  const featureMaps = inputs[1].dims[1] * attributes.group;\n\n  // if bias is provided it should be 1D and the number of elements should be equal to the number of feature maps\n  if (inputs.length === 3 && (inputs[2].dims.length !== 1 || inputs[2].dims[0] !== featureMaps)) {\n    throw new Error('invalid bias');\n  }\n\n  const spatialRank = inputs[0].dims.length - 2;\n  const dilationsSet = attributes.dilations.reduce((a, b) => a + b, 0) > 0;\n  // wrong dilations dimension\n  if (dilationsSet && attributes.dilations.length !== spatialRank) {\n    throw new Error(`dilations should be ${spatialRank}D`);\n  }\n\n  const stridesSet = attributes.strides.reduce((a, b) => a + b, 0) > 0;\n  // Wrong strides dimension\n  if (stridesSet && attributes.strides.length !== spatialRank) {\n    throw new Error(`strides should be ${spatialRank}D`);\n  }\n\n  // Wrong pads dimension\n  const padsSet = attributes.pads.reduce((a, b) => a + b, 0) > 0;\n  if (padsSet && attributes.pads.length !== spatialRank * 2) {\n    throw new Error(`pads should be ${spatialRank * 2}D`);\n  }\n\n  // Wrong output padding dimension\n  if (attributes.outputPadding.length !== spatialRank && attributes.outputPadding.length !== 0) {\n    throw new Error(`output_padding should be ${spatialRank}D`);\n  }\n\n  // if kernelShape is specified, it's data length must be 2 less than dims length of the weights tensor\n  // (the first 2 dims are batch_size and channels)\n  const kernelShapeSet = attributes.kernelShape.reduce((a, b) => a + b, 0) > 0;\n  if (kernelShapeSet && attributes.kernelShape.length !== 0 &&\n      attributes.kernelShape.length !== inputs[1].dims.length - 2) {\n    throw new Error('invalid kernel shape');\n  }\n\n  // as with kernelShape, must have same number of spatial dims as input\n  if (attributes.outputShape.length !== 0 && attributes.outputShape.length !== inputs[0].dims.length - 2) {\n    throw new Error('invalid output shape');\n  }\n};\n\n// for transposing weight tensor from [C, M/group, KH, KW] to [KH, KW, M/group, C]\nconst weightTransposePerm = [2, 3, 1, 0];\n\nconst convTranspose2d =\n    (context: ComputeContext, inputs: readonly TensorView[], attributes: ConvTransposeAttributes): void => {\n      const adjustedAttributes = getAdjustedConvTransposeAttributes(attributes, inputs);\n      const isChannelsLast = attributes.format === 'NHWC';\n      const outputShape = adjustedAttributes.outputShape;\n      const outChannels = outputShape[isChannelsLast ? 3 : 1];\n      const inputChannels = inputs[0].dims[isChannelsLast ? 3 : 1];\n      // Switch to naive method when outChannels and inputChannels are very small. It's because that in this case it's\n      // not suitable for matmul version since matmul uses tile size 32x32 resulting the underlying execution unit\n      // utilization rate is very low.\n      if (adjustedAttributes.group !== 1 || (outChannels === 1 && inputChannels === 1)) {\n        context.compute(createConvTranspose2DProgramInfo(inputs, adjustedAttributes));\n        return;\n      }\n      const outHeight = outputShape[isChannelsLast ? 1 : 2];\n      const outWidth = outputShape[isChannelsLast ? 2 : 3];\n      const weightHeight = inputs[1].dims[2];\n      const weightWidth = inputs[1].dims[3];\n\n      const dimAOuter = isChannelsLast ? outHeight * outWidth : outChannels;\n      const dimBOuter = isChannelsLast ? outChannels : outHeight * outWidth;\n      const dimInner = weightHeight * weightWidth * inputChannels;\n\n      const sequentialAccessByThreads = /* backend.adapterInfo.isIntel() */ true;\n\n\n      // STEP.1: transpose weight\n      const transposedWeight = (context.kernelCustomData.wT as TensorView | undefined) ??\n          context.compute(\n              createTransposeProgramInfo(inputs[1], weightTransposePerm),\n              {inputs: [1], outputs: [attributes.wIsConst ? -2 : -1]})[0];\n      if (attributes.wIsConst && !context.kernelCustomData.wT) {\n        context.kernelCustomData.wT = transposedWeight;\n      }\n\n      // STEP.2: prepare reshaped inputs\n      const convTransposeInputs = [inputs[0], transposedWeight];\n      const hasBias = inputs.length === 3;\n      if (hasBias) {\n        if (!isChannelsLast && inputs[2].dims.length === 1) {\n          convTransposeInputs.push(inputs[2].reshape([inputs[2].dims[0], 1, 1]));\n        } else {\n          convTransposeInputs.push(inputs[2]);\n        }\n      }\n\n      // STEP.3: compute matmul\n      context.compute(\n          createConv2DTransposeMatMulProgramInfo(\n              convTransposeInputs, adjustedAttributes, outputShape, dimAOuter, dimBOuter, dimInner, hasBias,\n              sequentialAccessByThreads),\n          {inputs: convTransposeInputs});\n    };\n\nconst convTranspose1d = (context: ComputeContext, attributes: ConvTransposeAttributes): void => {\n  // extend the input to 2D by adding H dimension\n  const isChannelLast = attributes.format === 'NHWC';\n\n  const inputs = [\n    context.inputs[0].reshape(\n        isChannelLast ?\n            // [N, W, C] -> [N, H=1, W, C]\n            [context.inputs[0].dims[0], 1, context.inputs[0].dims[1], context.inputs[0].dims[2]] :\n            // [N, C, W] -> [N, C, H=1, W]\n            [context.inputs[0].dims[0], context.inputs[0].dims[1], 1, context.inputs[0].dims[2]]),\n    //[FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kW] -> [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kH=1, kW]\n    context.inputs[1].reshape([context.inputs[1].dims[0], context.inputs[1].dims[1], 1, context.inputs[1].dims[2]])\n  ];\n  if (context.inputs.length === 3) {\n    inputs.push(context.inputs[2]);\n  }\n  let kernelShape = attributes.kernelShape;\n  if (kernelShape.length === 0 || kernelShape[0] === 0) {\n    kernelShape = [context.inputs[1].dims[2]];\n  }\n  let dilations = attributes.dilations;\n  if (dilations.length === 0 || dilations[0] === 0) {\n    dilations = [1];\n  }\n  let strides = attributes.strides;\n  if (strides.length === 0 || strides[0] === 0) {\n    strides = [1];\n  }\n  let pads = attributes.pads;\n  if (pads.length === 0) {\n    pads = [0, 0];\n  }\n  pads = [0, pads[0], 0, pads[1]];\n  strides = [1].concat(strides);\n  dilations = [1].concat(dilations);\n  kernelShape = [1].concat(kernelShape);\n  const adjustedAttributes =\n      getAdjustedConvTransposeAttributes({...attributes, pads, strides, dilations, kernelShape}, inputs);\n  context.compute(createConvTranspose2DProgramInfo(\n      inputs, adjustedAttributes,\n      outputShape => isChannelLast ? [outputShape[0], outputShape[2], outputShape[3]] :\n                                     [outputShape[0], outputShape[1], outputShape[3]]));\n};\n\nexport const convTranspose = (context: ComputeContext, attributes: ConvTransposeAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  if (context.inputs[0].dims.length === 3) {\n    convTranspose1d(context, attributes);\n  } else {\n    convTranspose2d(context, context.inputs, attributes);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, inputVariable, outputVariable, ShaderHelper} from './common';\n\n\nexport interface CumSumAttributes extends AttributeWithCacheKey {\n  readonly exclusive: boolean;\n  readonly reverse: boolean;\n}\nconst createCumsumProgramInfo =\n    (inputType: number, inputShape: readonly number[], axisInput: TensorView, attributes: CumSumAttributes):\n        ProgramInfo => {\n          const outputSize = ShapeUtil.size(inputShape);  // outputShape is same as inputShape.\n          const rank = inputShape.length;                 // input/output rank\n          const input = inputVariable('input', inputType, rank);\n          const output = outputVariable('output', inputType, rank);\n          const axisValue = axisInput.dataType === DataType.int32 ? axisInput.getInt32Array()[0] :\n                                                                    Number(axisInput.getBigInt64Array()[0]);\n          const axis = ShapeUtil.normalizeAxis(axisValue, rank);\n          const getShaderSource = (shaderHelper: ShaderHelper) => {\n            const index = ` i32(${input.indicesGet('inputIndices', 'uniforms.axis')}) `;\n            const max = getElementAt('uniforms.input_shape', 'uniforms.axis', rank);\n            const lowerLimit = attributes.reverse ? index + (attributes.exclusive ? ' + 1' : '') : '0';\n            const upperLimit = attributes.reverse ? max : index + (attributes.exclusive ? '' : ' + 1');\n            return `\n                ${\n                shaderHelper.registerUniform('outputSize', 'u32')\n                    .registerUniform('axis', 'u32')\n                    .declareVariables(input, output)}\n                ${shaderHelper.mainStart()}\n                  ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n                  var inputIndices = ${output.offsetToIndices('global_idx')};\n                  var sum = ${output.type.value}(0);\n                  let first : i32 = ${lowerLimit};\n                  let last : i32 = ${upperLimit};\n                  for (var i : i32 = first; i < last; i++) {\n                    ${input.indicesSet('inputIndices', 'uniforms.axis', 'u32(i)')};\n                    sum = sum + ${input.getByIndices('inputIndices')};\n                  }\n                  ${output.setByOffset('global_idx', 'sum')};\n                }`;\n          };\n          return {\n            name: 'CumSum',\n            shaderCache: {hint: attributes.cacheKey, inputDependencies: ['rank']},\n            getRunData: () => ({\n              outputs: [{dims: inputShape, dataType: inputType}],\n              dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n              programUniforms: [\n                {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: axis},\n                ...createTensorShapeVariables(inputShape, inputShape)\n              ]\n\n            }),\n            getShaderSource\n          };\n        };\n\n\nexport const cumsum = (context: ComputeContext, attributes: CumSumAttributes): void => {\n  const inputShape = context.inputs[0].dims;\n  const inputType = context.inputs[0].dataType;\n  const axis = context.inputs[1];\n  context.compute(createCumsumProgramInfo(inputType, inputShape, axis, attributes), {inputs: [0]});\n};\n\nexport const parseCumSumAttributes = (attributes: Record<string, unknown>): CumSumAttributes => {\n  const exclusive = attributes.exclusive as number === 1;\n  const reverse = attributes.reverse as number === 1;\n  return createAttributeWithCacheKey({exclusive, reverse});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface FormatAttributes {\n  readonly format: 'NHWC'|'NCHW';\n}\n\nexport interface DepthToSpaceAttributes extends FormatAttributes, AttributeWithCacheKey {\n  readonly blocksize: number;\n  readonly mode: string;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('DepthToSpace requires 1 input.');\n  }\n  if (inputs[0].dims.length !== 4) {\n    throw new Error('DepthToSpace requires 4D input.');\n  }\n};\n\nconst permFunctionBody = (perm: number[], rank: number, input: IndicesHelper, output: IndicesHelper): string => {\n  const reverseFunc = [];\n  reverseFunc.push(`fn perm(i: ${output.type.indices}) -> ${input.type.indices} {\n    var a: ${input.type.indices};`);\n  for (let i = 0; i < rank; ++i) {\n    reverseFunc.push(input.indicesSet('a', perm[i], `i[${i}]`));\n  }\n  reverseFunc.push('return a;}');\n  return reverseFunc.join('\\n');\n};\n\nconst createDepthToSpaceProgramInfo = (inputTensor: TensorView, attributes: DepthToSpaceAttributes): ProgramInfo => {\n  let n: number, h: number, w: number, c: number;\n  let shape: number[];\n  let perm: number[];\n  const isChannelLast = attributes.format === 'NHWC';\n  const blocksize = attributes.blocksize;\n  const isDCRmode = attributes.mode === 'DCR';\n  if (isChannelLast) {\n    [n, h, w, c] = inputTensor.dims;\n    shape = isDCRmode ? [n, h, w, blocksize, blocksize, c / (blocksize ** 2)] :\n                        [n, h, w, c / (blocksize ** 2), blocksize, blocksize];\n    perm = isDCRmode ? [0, 1, 3, 2, 4, 5] : [0, 1, 4, 2, 5, 3];\n  } else {\n    [n, h, w, c] = [inputTensor.dims[0], inputTensor.dims[2], inputTensor.dims[3], inputTensor.dims[1]];\n    shape = isDCRmode ? [n, blocksize, blocksize, c / (blocksize ** 2), h, w] :\n                        [n, c / (blocksize ** 2), blocksize, blocksize, h, w];\n    perm = isDCRmode ? [0, 3, 4, 1, 5, 2] : [0, 1, 4, 2, 5, 3];\n  }\n  const reshapedInputTensor = inputTensor.reshape(shape);\n  const reshapedInputRank = reshapedInputTensor.dims.length;\n  const inputDataType = inputTensor.dataType;\n\n  const reshapedInput = inputVariable('a', inputDataType, reshapedInputRank);\n  const permedOutput = outputVariable('output', inputDataType, reshapedInputRank);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(reshapedInput, permedOutput)}\n\n  ${permFunctionBody(perm, reshapedInputRank, reshapedInput, permedOutput)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n    let indices = ${permedOutput.offsetToIndices('global_idx')};\n    let aIndices = perm(indices);\n\n    ${permedOutput.setByOffset('global_idx', reshapedInput.getByIndices('aIndices'))}\n  }`;\n\n  return {\n    name: 'DepthToSpace',\n    shaderCache: {hint: `${inputTensor.dims};${attributes.blocksize};${attributes.mode}`, inputDependencies: ['rank']},\n    getRunData: (inputs) => {\n      const outputShape = isChannelLast ? [n, h * blocksize, w * blocksize, c / (blocksize ** 2)] :\n                                          [n, c / (blocksize ** 2), h * blocksize, w * blocksize];\n      const outputSize = ShapeUtil.size(outputShape);\n      const shapeBeforePerm = reshapedInputTensor.dims;\n      const shapeAfterPerm = ShapeUtil.sortBasedOnPerm(shapeBeforePerm, perm);\n      return {\n        outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n        dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n        programUniforms:\n            [{type: DataType.uint32, data: outputSize}, ...createTensorShapeVariables(shapeBeforePerm, shapeAfterPerm)],\n      };\n    },\n    getShaderSource,\n  };\n};\n\nexport const depthToSpace = (context: ComputeContext, attributes: DepthToSpaceAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createDepthToSpaceProgramInfo(context.inputs[0], attributes));\n};\n\nexport const parseDepthToSpaceAttributes = (attributes: Record<string, unknown>): DepthToSpaceAttributes =>\n    createAttributeWithCacheKey({\n      blocksize: attributes.blocksize as number,\n      mode: attributes.mode as string,\n      format: attributes.format as 'NHWC' | 'NCHW'\n    });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface EinsumAttributes extends AttributeWithCacheKey {\n  readonly equation: string;\n}\n// The equation attribute value is a string which consists of left hand side (LHS) and optionally right hand side (RHS)\n// separated by '->'. Ex. \"ij,jk -> ik\" expresses matrix multiplication\n//     \"ij->ji\" expresses matrix transpose\n//      \"ii->i\" diagonal elements of a square matrix\n// LHS consists of a sequence of terms separated by commas. Each term corresponds to an input variable.\n// Each symbol corresponds to a dimension in the input variable. The symbol can be either a letter, 'a' to 'z' or 'A' to\n// 'Z' or '...' to represent arbitrary dimensions.\n\nconst symbolPattern =\n    '[a-zA-Z]|\\\\.\\\\.\\\\.';  // The pattern each symbol in each term in the symbolic equation should match\nconst termPattern = '(' + symbolPattern + ')+';   // The pattern each term in the symbolic equation should match\nconst termPatternOnly = '^' + termPattern + '$';  // The patterns only matchs a term begin to end.\nconst lhsPattern = '(' + termPattern + ',)*' + termPattern;  // The pattern the LHS should match\nconst lhsPatternOnly = '^' + lhsPattern + '$';               // The patterns only matchs a LHS begin to end.\n\ninterface SymbolInfo {\n  count: number;           // Symbol corresponding to a dimmension of an input\n  inputIndices: number[];  // Number of input variables the symbol corresponds to\n  dimValue: number;        // Number of dimensions the symbol corresponds to\n}\n\nclass EinsumTerm {\n  constructor(inputIndex = -1) {\n    this.symbolToIndices = new Map<string, number[]>();\n    this.inputIndex = inputIndex;\n  }\n\n  // Add a symbol to the term\n  addSymbol(symbol: string, index: number) {\n    let value = this.symbolToIndices.get(symbol);\n    if (value === undefined) {\n      value = [index];\n    } else {\n      value.push(index);\n    }\n    this.symbolToIndices.set(symbol, value);\n  }\n\n  symbolToIndices: Map<string, number[]>;  // Map from symbol to dimensions of the input corresponding to the term\n  inputIndex: number;                      // -1 for output and 0, 1, 2, ... for inputs\n}\n\nclass EinsumEquation {\n  constructor(inputs: readonly TensorView[], public readonly equation: string) {\n    this.hasEllipsis = false;\n    this.symbolToInfo = new Map<string, SymbolInfo>();\n    this.lhs = new Array<EinsumTerm>();\n    this.outputDims = [];\n    // As rhs needs to be updated allow using let instead of const for both lhs and rhs.\n    // eslint-disable-next-line prefer-const\n    let [lhs, rhs] = equation.includes('->') ? equation.split('->', 2) : [equation, ''];\n    if (!lhs.match(RegExp(lhsPatternOnly))) {\n      throw new Error('Invalid LHS term');\n    }\n    const inputTerms = lhs.split(',');\n    inputTerms.forEach((inputTerm, index) => {\n      const dims = inputs[index].dims.slice();\n      if (!inputTerm.match(RegExp(termPatternOnly))) {\n        throw new Error('Invalid LHS term');\n      }\n      const einsumTerm = this.processTerm(inputTerm, true, dims, index);\n      this.lhs.push(einsumTerm);\n    });\n\n    // Initialize the RHS if not specified\n    if (rhs === '') {\n      // Construct RHS from LHS terms/symbols\n      rhs += [...this.symbolToInfo.entries()]\n                 .filter(([sym, info]) => (info.count === 1 || sym === '...'))\n                 .map(([sym]) => sym)\n                 .join('');\n    } else {\n      if (!rhs.match(RegExp(termPattern))) {\n        throw new Error('Invalid RHS');\n      }\n    }\n\n    // Compute output dims\n    const rhsSymbols = rhs.match(RegExp(symbolPattern, 'g'));\n    rhsSymbols?.forEach((symbol) => {\n      if (symbol === '...') {\n        this.outputDims = this.outputDims.concat(this.ellipsisDims);\n      } else {\n        const info = this.symbolToInfo.get(symbol);\n        if (info === undefined) {\n          throw new Error('Invalid RHS symbol');\n        }\n        this.outputDims.push(info.dimValue);\n      }\n    });\n    this.rhs = this.processTerm(rhs, false, this.outputDims);\n  }  // End of EinsumEqation constructor\n\n  // Add a symbol to the equation\n  addSymbol(symbol: string, dimValue: number, inputIndex: number) {\n    let info = this.symbolToInfo.get(symbol);\n    if (info !== undefined) {\n      if (info.dimValue !== dimValue && info.count !== 1) {\n        throw new Error('Dimension mismatch');\n      } else {\n        info.count++;\n        info.inputIndices.push(inputIndex);\n      }\n    } else {\n      info = {count: 1, dimValue, inputIndices: [inputIndex]};\n    }\n    this.symbolToInfo.set(symbol, info);\n  }\n\n  // Process one input/output term\n  processTerm(term: string, isInput: boolean, dims: readonly number[], index = -1): EinsumTerm {\n    const rank = dims.length;\n    let ellipsis = false;\n    let ellipsisDims = [];\n    let nextDim = 0;\n    // For output empty string is allowed because the output may be reduced to a scalar value\n    if (!term.match(RegExp(termPatternOnly)) && (!isInput && term !== '')) {\n      throw new Error('Invalid LHS term');\n    }\n    const indexSymbols = term.match(RegExp(symbolPattern, 'g'));\n    const einsumTerm = new EinsumTerm(index);\n    // symbol can be either a lettre, 'a' to 'z' or 'A' to 'Z', or '...'\n    indexSymbols?.forEach((symbol: string, i: number) => {\n      if (symbol === '...') {\n        if (ellipsis) {\n          throw new Error('Only one ellipsis is allowed per input term');\n        }\n        ellipsis = true;\n        const ellipsisDimLength = rank - indexSymbols.length + 1;\n        if (ellipsisDimLength < 0) {\n          throw new Error('Ellipsis out of bounds');\n        }\n        ellipsisDims = dims.slice(nextDim, nextDim + ellipsisDimLength);\n        if (this.hasEllipsis) {\n          if (this.ellipsisDims.length !== ellipsisDims.length ||\n              this.ellipsisDims.toString() !== ellipsisDims.toString()) {\n            throw new Error('Ellipsis dimensions mismatch');\n          }\n        } else if (isInput) {\n          this.hasEllipsis = true;\n          this.ellipsisDims = ellipsisDims;\n        } else {\n          throw new Error('Ellipsis must be specified in the LHS');\n        }\n        // Add '0', '1', '2', '3', '4', etc to represent ellipsis dimensions to avoid special handling\n        for (let j = 0; j < ellipsisDims.length; j++) {\n          const symbol = String.fromCharCode('0'.charCodeAt(0) + j);\n          einsumTerm.addSymbol(symbol, i + j);\n          this.addSymbol(symbol, dims[nextDim++], index);\n        }\n      } else {\n        einsumTerm.addSymbol(symbol, i + (this.hasEllipsis ? this.ellipsisDims.length - 1 : 0));\n        this.addSymbol(symbol, dims[nextDim++], index);\n      }\n    });\n    return einsumTerm;\n  }\n\n  symbolToInfo: Map<string, SymbolInfo>;  // All symbols in the equation\n  hasEllipsis: boolean;                   // The equation has ellipsis or not\n  ellipsisDims: number[];                 // The dimensions of the equation ellipsis corresponds to.\n  lhs: EinsumTerm[];                      // Terms on the left-hand side of the equation\n  rhs: EinsumTerm;                        // Term on the right-hand side of the equation\n  outputDims: number[];                   // Output dimensions of the equation\n}  // End of class EinsumEquation\n\nconst appendMax = (name: string): string => name + '_max';\n\nconst createEinsumProgramInfo =\n    (inputShapes: Array<readonly number[]>, dataType: number, einsumEquation: EinsumEquation,\n     outputShape: readonly number[]): ProgramInfo => {\n      const ranks = inputShapes.map((dims) => dims.length);\n      const inputVars = ranks.map((rank, index) => inputVariable(`input${index}`, dataType, rank));\n      const outputSize = ShapeUtil.size(outputShape);\n      const output = outputVariable('output', dataType, outputShape.length);\n      const uniformsSymbols =\n          [...einsumEquation.symbolToInfo.keys()].filter((symbol) => !einsumEquation.rhs.symbolToIndices.has(symbol));\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const idxCopy: string[] = [];\n        const initProd = 'var prod = 1.0;';\n        const initSum = 'var sum = 0.0;';\n        const updateSum = 'sum += prod;';\n        const reduceOpsSetIndices: string[] = [];\n        const reduceOpsLoopHeaders: string[] = [];\n        const reduceOpsLoopFooters: string[] = [];\n        const reduceOpCompute: string[] = [];\n        const isReduceOpsWithoutLoop = einsumEquation.symbolToInfo.size === einsumEquation.rhs.symbolToIndices.size;\n        einsumEquation.symbolToInfo.forEach((info, symbol) => {\n          if (einsumEquation.rhs.symbolToIndices.has(symbol)) {\n            const outputIndex = einsumEquation.rhs.symbolToIndices.get(symbol)?.[0];\n            if (outputIndex !== undefined) {\n              einsumEquation.lhs.forEach((term, i) => {\n                if (info.inputIndices.includes(i)) {\n                  const indices = term.symbolToIndices.get(symbol);\n                  if (indices === undefined) {\n                    throw new Error('Invalid symbol error');\n                  }\n                  indices.forEach((index) => {\n                    idxCopy.push(`${\n                        inputVars[i].indicesSet(\n                            `input${i}Indices`, index, output.indicesGet('outputIndices', outputIndex))}`);\n                  });\n                }\n              });\n            }\n          } else {\n            einsumEquation.lhs.forEach((term, i) => {\n              if (info.inputIndices.includes(i)) {\n                const indices = term.symbolToIndices.get(symbol);\n                if (indices === undefined) {\n                  throw new Error('Invalid symbol error');\n                }\n                indices.forEach((index) => {\n                  reduceOpsSetIndices.push(`${inputVars[i].indicesSet(`input${i}Indices`, index, `${symbol}`)}`);\n                });\n                reduceOpCompute.push(`prod *= ${inputVars[i].getByIndices(`input${i}Indices`)};`);\n              }\n            });\n            reduceOpsLoopHeaders.push(\n                `for(var ${symbol}: u32 = 0; ${symbol} < uniforms.${appendMax(symbol)}; ${symbol}++) {`);\n            reduceOpsLoopFooters.push('}');\n          }\n        });\n        const reduceOps = isReduceOpsWithoutLoop ?\n            [\n              ...idxCopy,\n              `let sum = ${inputVars.map((inputVar, i) => inputVar.getByIndices(`input${i}Indices`)).join(' * ')};`\n            ] :\n            [\n              ...idxCopy,\n              initSum,\n              ...reduceOpsLoopHeaders,\n              ...reduceOpsSetIndices,\n              initProd,\n              ...reduceOpCompute,\n              updateSum,\n              ...reduceOpsLoopFooters,\n            ];\n        return `\n            ${\n            shaderHelper\n                .registerUniforms(uniformsSymbols.map((symbol) => ({name: `${appendMax(symbol)}`, type: 'u32'})))\n                .registerUniform('outputSize', 'u32')\n                .declareVariables(...inputVars, output)}\n\n            ${shaderHelper.mainStart()}\n            ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n            var outputIndices = ${output.offsetToIndices('global_idx')};\n            ${inputVars.map((_var, i) => `var input${i}Indices: ${inputVars[i].type.indices};`).join('\\n')}\n            ${reduceOps.join('\\n')};\n            ${output.setByOffset('global_idx', 'sum')};\n          }`;\n      };\n      return {\n        name: 'Einsum',\n        shaderCache: {hint: einsumEquation.equation, inputDependencies: inputShapes.map(() => 'rank')},\n        getRunData: () => {\n          // The symbols from uniformSymbols array are guaranteed to exist in einsumEquations.symbolToInfo map. The\n          // filter is added to make sure that dimValue is never 0.\n          const programUniformsInit: ProgramUniform[] =\n              uniformsSymbols.filter((symbol) => einsumEquation.symbolToInfo.has(symbol))\n                  .map(\n                      (symbol) =>\n                          ({type: DataType.uint32, data: einsumEquation.symbolToInfo.get(symbol)?.dimValue || 0}));\n          programUniformsInit.push({type: DataType.uint32, data: outputSize});\n          const programUniforms: ProgramUniform[] =\n              inputShapes.map((dims, _) => [...createTensorShapeVariables(dims)])\n                  .reduce((acc, inputProgramUniforms) => acc.concat(inputProgramUniforms), programUniformsInit);\n          programUniforms.push(...createTensorShapeVariables(outputShape));\n          return ({\n            outputs: [{dims: outputShape, dataType}],\n            dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n            programUniforms\n          });\n        },\n        getShaderSource,\n      };\n    };\n\nexport const einsum = (context: ComputeContext, attributes: EinsumAttributes): void => {\n  const einsumEquation = new EinsumEquation(context.inputs, attributes.equation);\n  const outputShape = einsumEquation.outputDims;\n  const inputShapes = context.inputs.map((input, _) => input.dims);\n  context.compute(createEinsumProgramInfo(inputShapes, context.inputs[0].dataType, einsumEquation, outputShape));\n};\n\nexport const parseEinsumAttributes = (attributes: Record<string, unknown>): EinsumAttributes => {\n  const equation = (attributes.equation as string).replace(/\\s+/g, '');\n  return createAttributeWithCacheKey({equation});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('Expand requires 2 input.');\n  }\n  const inputShape = inputs[0].dims;\n  const shape = Array.from(inputs[1].getBigInt64Array(), Number);\n\n  let shapeIndex = shape.length < inputShape.length ? 0 : shape.length - inputShape.length;\n  let inputShapeIndex = inputShape.length < shape.length ? 0 : inputShape.length - shape.length;\n  for (; shapeIndex < shape.length && inputShapeIndex < inputShape.length; ++shapeIndex, ++inputShapeIndex) {\n    if (shape[shapeIndex] !== inputShape[inputShapeIndex] && shape[shapeIndex] !== 1 &&\n        inputShape[inputShapeIndex] !== 1) {\n      throw new Error('Expand requires shape to be broadcastable to input');\n    }\n  }\n};\n\nconst getAdjustedShape = (shape1: readonly number[], shape2: readonly number[]): number[] => {\n  const diff = shape1.length - shape2.length;\n  const shape: number[] = [];\n  for (let i = 0; i < diff; ++i) {\n    shape.push(shape1[i]);\n  }\n  for (let i = 0; i < shape2.length; ++i) {\n    shape.push(shape2[i] === 1 ? shape1[i + diff] : shape2[i]);\n  }\n  return shape;\n};\n\nconst calculateOutputShape = (inputShape: readonly number[], shape: readonly number[]): number[] =>\n    (inputShape.length > shape.length) ? getAdjustedShape(inputShape, shape) : getAdjustedShape(shape, inputShape);\n\n\nconst createExpandProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const shape = Array.from(inputs[1].getBigInt64Array(), Number);\n  const outputShape: number[] = calculateOutputShape(inputShape, shape);\n  const dataType = inputs[0].dataType;\n  const components = dataType === DataType.bool ? 4 : 1;\n  const outputSize = Math.ceil(ShapeUtil.size(outputShape) / components);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const input = inputVariable('input', dataType, inputShape.length, components);\n    const output = outputVariable('output', dataType, outputShape.length, components);\n    let assignment: string;\n    if (dataType === DataType.bool) {\n      const singleAssignment = (resStr: string, x: number, typeCast = '') => `\n          let outputIndices${x} = ${output.offsetToIndices(`outputOffset + ${x}u`)};\n          let offset${x} = ${input.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n          let index${x} = offset${x} / 4u;\n          let component${x} = offset${x} % 4u;\n          ${resStr}[${x}] = ${typeCast}(${input.getByOffset(`index${x}`)}[component${x}]);\n        `;\n      assignment = `\n        let outputOffset = global_idx * ${components};\n        var data = vec4<u32>(0);\n        ${singleAssignment('data', 0, 'u32')}\n        ${singleAssignment('data', 1, 'u32')}\n        ${singleAssignment('data', 2, 'u32')}\n        ${singleAssignment('data', 3, 'u32')}\n        ${output.setByOffset('global_idx', 'data')}\n      }`;\n    } else {\n      assignment = `\n        let outputIndices = ${output.offsetToIndices('global_idx')};\n        let inputOffset = ${input.broadcastedIndicesToOffset('outputIndices', output)};\n        ${output.setByOffset('global_idx', input.getByOffset('inputOffset'))}\n      }`;\n    }\n    return `\n    ${shaderHelper.registerUniform('vec_size', 'u32').declareVariables(input, output)}\n    ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.vec_size')}\n    ${assignment}`;\n  };\n\n  const programUniforms: ProgramUniform[] =\n      [{type: DataType.uint32, data: outputSize}, ...createTensorShapeVariables(inputShape, outputShape)];\n  return {\n    name: 'Expand',\n    shaderCache: {hint: `${outputShape.length}`, inputDependencies: ['rank']},\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n      programUniforms\n    })\n  };\n};\n\nexport const expand = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  context.compute(createExpandProgramInfo(context.inputs), {inputs: [0]});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglValueType, UniformsArrayType, WORKGROUP_SIZE} from './common';\nimport * as unary from './unary-op';\n\n// GELU is defined as Y=0.5*X*(1+tanh(0.797885*X+0.035677*X*X*X)), where X may pre-add a bias.\n\nconst createFastGeluProgramInfo = (inputTensors: readonly TensorView[]): ProgramInfo => {\n  const dataType = inputTensors[0].dataType;\n  const outputSize = ShapeUtil.size(inputTensors[0].dims);\n  const biasLength = ShapeUtil.size(inputTensors[1].dims);\n  // can only use vec4 when bias length is multiple of 4\n  const useVec4 = biasLength % 4 === 0;\n  const getShaderSource = (shaderHelper: ShaderHelper): string => {\n    const x = inputVariable('x', dataType, [1], 4);\n    const bias = inputVariable('bias', dataType, [1], 4);\n    const y = outputVariable('y', dataType, [1], 4);\n\n    const uniforms: UniformsArrayType = [{name: 'output_vec_size', type: 'u32'}, {name: 'bias_size', type: 'u32'}];\n\n    const singleElementBias = (i: 0|1|2|3) => `\n      let bias${i}_offset: u32 = (global_idx * 4 + ${i}) % uniforms.bias_size;\n      let bias${i} = ${bias.getByOffset(`bias${i}_offset / 4`)}[bias${i}_offset % 4];`;\n    const biasGetExpression = useVec4 ?\n        `\n      let bias = ${bias.getByOffset('global_idx % (uniforms.bias_size / 4)')};` :\n        `${singleElementBias(0)}${singleElementBias(1)}${singleElementBias(2)}${singleElementBias(3)}\n      let bias = ${x.type.value}(bias0, bias1, bias2, bias3);`;\n\n    return `${shaderHelper.registerUniforms(uniforms).declareVariables(x, bias, y)}\n\n    ${unary.fastGeluImpl(tensorTypeToWsglValueType(dataType))}\n\n    ${shaderHelper.mainStart(WORKGROUP_SIZE)}\n      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_vec_size')}\n\n      let x = ${x.getByOffset('global_idx')};\n      ${biasGetExpression}\n      let x_in = x + bias;\n      ${y.setByOffset('global_idx', unary.fastGeluExpression('x_in'))}\n    }`;\n  };\n\n  return {\n    name: 'FastGeluWithBias',\n    shaderCache: {hint: `${useVec4}`, inputDependencies: ['type', 'type']},\n    getShaderSource,\n    getRunData: (inputs) => ({\n      outputs: [{dims: inputs[0].dims, dataType: inputs[0].dataType}],\n      programUniforms:\n          [{type: DataType.uint32, data: Math.ceil(outputSize / 4)}, {type: DataType.uint32, data: biasLength}],\n      dispatchGroup: {x: Math.ceil(outputSize / WORKGROUP_SIZE / 4)}\n    })\n  };\n};\n\nexport const fastGelu = (context: ComputeContext): void => {\n  if (context.inputs.length < 2 || ShapeUtil.size(context.inputs[1].dims) === 0) {\n    unary.fastGelu(context);\n  } else {\n    context.compute(createFastGeluProgramInfo(context.inputs));\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface GatherAttributes extends AttributeWithCacheKey {\n  axis: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('Gather requires 2 inputs.');\n  }\n};\n\nconst createGatherProgramInfo = (inputs: readonly TensorView[], attributes: GatherAttributes): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const indicesShape = inputs[1].dims;\n\n  const inputRank = inputShape.length;\n  const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank);\n\n  const outputShape = inputShape.slice(0);\n  outputShape.splice(axis, 1, ...indicesShape);\n\n  const axisDimLimit = inputShape[axis];\n  const components = inputs[0].dataType === DataType.bool ? 4 : 1;\n  const outputSize = Math.ceil(ShapeUtil.size(outputShape) / components);\n\n  const programUniforms: ProgramUniform[] = [\n    {type: DataType.uint32, data: outputSize}, {type: DataType.int32, data: axisDimLimit},\n    {type: DataType.uint32, data: axis}, ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims, outputShape)\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const data = inputVariable('data', inputs[0].dataType, inputs[0].dims.length, components);\n    const indices = inputVariable('inputIndices', inputs[1].dataType, inputs[1].dims.length);\n    const output = outputVariable('output', inputs[0].dataType, outputShape.length, components);\n\n    const calcDataIndices = (x: number|string): string => {\n      const indicesRank = indicesShape.length;\n      let calcStr = `var indicesIndices${x}  = ${indices.type.indices}(0);`;\n      for (let i = 0; i < indicesRank; i++) {\n        calcStr += `${indicesRank > 1 ? `indicesIndices${x}[${i}]` : `indicesIndices${x}`} = ${\n            outputShape.length > 1 ? `outputIndices${x}[uniforms.axis + ${i}]` : `outputIndices${x}`};`;\n      }\n      calcStr += `\n          var idx${x} = ${indices.getByIndices(`indicesIndices${x}`)};\n          if (idx${x} < 0) {\n            idx${x} = idx${x} + uniforms.axisDimLimit;\n          }\n          var dataIndices${x} : ${data.type.indices};\n        `;\n      for (let i = 0, j = 0; i < inputRank; i++) {\n        if (i === axis) {\n          calcStr += `${inputRank > 1 ? `dataIndices${x}[${i}]` : `dataIndices${x}`} = u32(idx${x});`;\n          j += indicesRank;\n        } else {\n          calcStr += `${inputRank > 1 ? `dataIndices${x}[${i}]` : `dataIndices${x}`} = ${\n              outputShape.length > 1 ? `outputIndices${x}[${j}]` : `outputIndices${x}`};`;\n          j++;\n        }\n      }\n      return calcStr;\n    };\n    let assignment: string;\n    if (inputs[0].dataType === DataType.bool) {\n      const singleAssignment = (resStr: string, x: number, typeCast = '') => `\n          let outputIndices${x} = ${output.offsetToIndices(`outputOffset + ${x}u`)};\n          ${calcDataIndices(x)};\n          let offset${x} = ${data.indicesToOffset(`dataIndices${x}`)};\n          let index${x} = offset${x} / 4u;\n          let component${x} = offset${x} % 4u;\n          ${resStr}[${x}] = ${typeCast}(${data.getByOffset(`index${x}`)}[component${x}]);\n        `;\n      assignment = `\n        let outputOffset = global_idx * ${components};\n        var value = vec4<u32>(0);\n        ${singleAssignment('value', 0, 'u32')}\n        ${singleAssignment('value', 1, 'u32')}\n        ${singleAssignment('value', 2, 'u32')}\n        ${singleAssignment('value', 3, 'u32')}\n        ${output.setByOffset('global_idx', 'value')}\n      `;\n    } else {\n      assignment = `\n      let outputIndices = ${output.offsetToIndices('global_idx')};\n      ${calcDataIndices('')};\n      let value = ${data.getByIndices('dataIndices')};\n      ${output.setByOffset('global_idx', 'value')};\n      `;\n    }\n    return `\n      ${\n        shaderHelper.registerUniform('outputSize', 'u32')\n            .registerUniform('axisDimLimit', 'i32')\n            .registerUniform('axis', 'u32')\n            .declareVariables(data, indices, output)}\n      ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n        ${assignment}\n      }`;\n  };\n  return {\n    name: 'Gather',\n    shaderCache: {hint: attributes.cacheKey, inputDependencies: ['rank', 'rank']},\n    getRunData: () => ({\n      outputs: [\n        {dims: outputShape, dataType: inputs[0].dataType},\n      ],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n      programUniforms\n    }),\n    getShaderSource,\n  };\n};\n\nexport const parseGatherAttributes = (attributes: Record<string, unknown>): GatherAttributes =>\n    createAttributeWithCacheKey({axis: attributes.axis as number});\n\nexport const gather = (context: ComputeContext, attributes: GatherAttributes): void => {\n  const inputs = context.inputs;\n  validateInputs(inputs);\n  context.compute(createGatherProgramInfo(context.inputs, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface GatherElementsAttributes extends AttributeWithCacheKey {\n  axis: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('GatherElements requires 2 inputs.');\n  }\n\n  if (inputs[0].dims.length < 1) {\n    throw new Error('GatherElements requires that the data input be rank >= 1.');\n  }\n\n  if (inputs[0].dims.length !== inputs[1].dims.length) {\n    throw new Error(`GatherElements requires that the data input and\n                     indices input tensors be of same rank.`);\n  }\n};\n\nconst createGatherElementsProgramInfo =\n    (inputs: readonly TensorView[], attributes: GatherElementsAttributes): ProgramInfo => {\n      const inputShape = inputs[0].dims;\n      const inputOutputDataType = inputs[0].dataType;\n      const inputRank = inputShape.length;\n\n      const indicesShape = inputs[1].dims;\n      const indicesDataType = inputs[1].dataType;\n      const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank);\n      const axisDimLimit = inputShape[axis];\n\n      const outputShape = indicesShape.slice(0);\n      const outputSize = ShapeUtil.size(outputShape);\n\n      const input = inputVariable('input', inputOutputDataType, inputRank);\n      const indices = inputVariable('indicesInput', indicesDataType, indicesShape.length);\n      const output = outputVariable('output', inputOutputDataType, outputShape.length);\n\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize}, {type: DataType.int32, data: axisDimLimit},\n        {type: DataType.uint32, data: axis}\n      ];\n      programUniforms.push(...createTensorShapeVariables(inputShape, indicesShape, outputShape));\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n\n      // int64 indices would be treated as little endian i32 with assumption they fall in i32 limits\n      // That assumption is safe as it's not possible to allocate >2gb buffer for input tensor\n      // Input data will be treated as u32 or two u32 for 8-byte tensors\n      const getShaderSource = (shaderHelper: ShaderHelper) => `\n      ${\n          shaderHelper.registerUniform('outputSize', 'u32')\n              .registerUniform('axisDimLimit', 'i32')\n              .registerUniform('axis', 'u32')\n              .declareVariables(input, indices, output)}\n      ${shaderHelper.mainStart()}\n      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n\n      let outputIndices = ${output.offsetToIndices('global_idx')};\n\n      var idx = ${indices.getByOffset('global_idx')};\n      if (idx < 0) {\n        idx = idx + uniforms.axisDimLimit;\n      }\n      var inputIndices = ${input.type.indices}(outputIndices);\n      ${input.indicesSet('inputIndices', 'uniforms.axis', 'u32(idx)')};\n      let value = ${input.getByIndices('inputIndices')};\n\n      ${output.setByOffset('global_idx', 'value')};\n  }`;\n\n      return {\n        name: 'GatherElements',\n        shaderCache: {inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n\nexport const parseGatherElementsAttributes = (attributes: Record<string, unknown>): GatherElementsAttributes =>\n    createAttributeWithCacheKey({axis: attributes.axis as number});\n\nexport const gatherElements = (context: ComputeContext, attributes: GatherElementsAttributes): void => {\n  const inputs = context.inputs;\n  validateInputs(inputs);\n  context.compute(createGatherElementsProgramInfo(context.inputs, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {GemmUtil, ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper, UniformsArrayType} from './common';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs) {\n    throw new Error('Input is missing');\n  }\n  if (inputs.length < 2 || inputs.length > 3) {\n    throw new Error('Invaid input number.');\n  }\n\n  // 'C' can be of dimensionality 0, 1 or 2 only\n  if (inputs.length === 3 && inputs[2].dims.length > 2) {\n    throw new Error('Invalid input shape of C');\n  }\n\n  if ((inputs[0].dataType !== inputs[1].dataType) ||\n      (inputs.length === 3 && inputs[0].dataType !== inputs[2].dataType)) {\n    throw new Error('Input types are mismatched');\n  }\n};\n\nexport interface GemmAttributes extends AttributeWithCacheKey {\n  transA: boolean;\n  transB: boolean;\n  alpha: number;\n  beta: number;\n}\n\nconst createGemmProgramInfo = (inputs: readonly TensorView[], attributes: GemmAttributes): ProgramInfo => {\n  const aShape = inputs[0].dims.slice();\n  const bShape = inputs[1].dims.slice();\n  const [M, N, K] = GemmUtil.getShapeOfGemmResult(\n      aShape, attributes.transA, bShape, attributes.transB, inputs.length === 3 ? inputs[2].dims : undefined);\n  const outputShape = [M, N];\n  if (!outputShape) {\n    throw new Error('Can\\'t use gemm on the given tensors');\n  }\n  const outputSize = ShapeUtil.size(outputShape);\n  const programUniforms: ProgramUniform[] = [\n    {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: M}, {type: DataType.uint32, data: N},\n    {type: DataType.uint32, data: K}, {type: DataType.float, data: attributes.alpha},\n    {type: DataType.float, data: attributes.beta}\n  ];\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n  if (inputs.length === 3) {\n    programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n    inputDependencies.push('rank');\n  }\n  programUniforms.push(...createTensorShapeVariables(outputShape));\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    let line = '';\n    if (attributes.transA && attributes.transB) {\n      line = 'value += a[k * uniforms.M + m] * b[n * uniforms.K + k];';\n    } else if (attributes.transA && !attributes.transB) {\n      line = 'value += a[k * uniforms.M + m] * b[k * uniforms.N + n];';\n    } else if (!attributes.transA && attributes.transB) {\n      line = 'value += a[m * uniforms.K + k] * b[n * uniforms.K + k];';\n    } else if (!attributes.transA && !attributes.transB) {\n      line = 'value += a[m * uniforms.K + k] * b[k * uniforms.N + n];';\n    }\n\n    const calculateAlpha = attributes.alpha === 1 ? '' : 'value *= uniforms.alpha;';\n    const a = inputVariable('a', inputs[0].dataType, inputs[0].dims);\n    const b = inputVariable('b', inputs[1].dataType, inputs[1].dims);\n    const dataType = a.type.value;\n    let c: IndicesHelper|null = null;\n    const variables = [a, b];\n    if (inputs.length === 3) {\n      c = inputVariable('c', inputs[2].dataType, inputs[2].dims.length);\n      variables.push(c);\n    }\n    const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n    variables.push(output);\n    const uniforms: UniformsArrayType = [\n      {name: 'output_size', type: 'u32'}, {name: 'M', type: 'u32'}, {name: 'N', type: 'u32'}, {name: 'K', type: 'u32'},\n      {name: 'alpha', type: 'f32'}, {name: 'beta', type: 'f32'}\n    ];\n    return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n    let m = global_idx / uniforms.N;\n    let n = global_idx % uniforms.N;\n\n    var value = ${dataType}(0);\n    for (var k: u32 = 0u; k < uniforms.K; k++) {\n      ${line}\n    }\n\n    ${calculateAlpha}\n    ${(() => {\n      if (c != null) {\n        return `let cOffset = ${c.broadcastedIndicesToOffset('vec2(m, n)', output)}; value += ${\n            dataType}(uniforms.beta) * ${c.getByOffset('cOffset')};`;\n      }\n      return '';\n    })()}\n    output[global_idx] = value;\n  }`;\n  };\n\n  return {\n    name: 'Gemm',\n    shaderCache: {hint: `${attributes.cacheKey}`, inputDependencies},\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n      programUniforms\n    }),\n    getShaderSource,\n  };\n};\n\nexport const parseGemmAttributes = (attributes: Record<string, unknown>): GemmAttributes => {\n  const transA = attributes.transA as boolean;\n  const transB = attributes.transB as boolean;\n  const alpha = attributes.alpha as number;\n  const beta = attributes.beta as number;\n  return {transA, transB, alpha, beta, cacheKey: `${attributes.transA};${attributes.transB};${attributes.alpha === 1}`};\n};\n\nexport const gemm = (context: ComputeContext, attributes: GemmAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createGemmProgramInfo(context.inputs, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, fillVector, getMaxComponents, inputVariable, outputVariable, ShaderHelper, sumVector, tensorTypeToWsglStorageType, UniformsArrayType} from './common';\n\nexport interface InstanceNormAttributes {\n  epsilon: number;\n  format: 'NHWC'|'NCHW';\n}\n\nconst createInstanceNormProgramInfo =\n    (inputs: readonly TensorView[], attributes: InstanceNormAttributes): ProgramInfo => {\n      const xShape = inputs[0].dims;\n      const outputShape = xShape;\n      const axis = 2;\n      const normCount = ShapeUtil.sizeToDimension(xShape, axis);\n      const normSize = ShapeUtil.sizeFromDimension(xShape, axis);\n      const components = getMaxComponents(normSize);\n      const normPackedSize = normSize / components;\n      const inputShape = [xShape[0], xShape[1], normPackedSize];\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'type', 'type'];\n      const programUniforms: ProgramUniform[] =\n          [{type: DataType.uint32, data: normSize}, {type: DataType.uint32, data: normPackedSize}];\n      programUniforms.push(...createTensorShapeVariables(inputShape, inputShape));\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const x = inputVariable('x', inputs[0].dataType, inputShape.length, components);\n        const scale = inputVariable('scale', inputs[1].dataType, inputs[1].dims);\n        const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims);\n        const output = outputVariable('output', inputs[0].dataType, inputShape.length, components);\n        const variables = [x, scale, bias, output];\n        const dataType = x.type.value;\n        const f32Type = components === 1 ? 'f32' : `vec${components}<f32>`;\n        const workgroupSize = 64;\n\n        const uniforms: UniformsArrayType = [{name: 'normSize', type: 'u32'}, {name: 'normPackedSize', type: 'u32'}];\n        return `\n  var<workgroup> meanShared : f32;\n  var<workgroup> squaredNormShared : f32;\n  var<workgroup> workgroupShared : array<${f32Type}, ${workgroupSize}>;\n  const workgroupSize = ${workgroupSize}u;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n  ${shaderHelper.mainStart(workgroupSize)}\n    let norm = global_idx / workgroupSize;\n    let batch = norm / uniforms.x_shape[1];\n    let channel = norm % uniforms.x_shape[1];\n    let localIndex = local_id.x;\n\n    // initialize workgroup memory\n    var initial = ${f32Type}(0);\n    for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) {\n      initial = initial + ${f32Type}(${x.get('batch', 'channel', 'h')});\n    }\n    workgroupShared[localIndex] = initial;\n    workgroupBarrier();\n\n    // Calculate the mean of current channel data.\n    for (var currSize = workgroupSize >> 1;  currSize > 0; currSize = currSize >> 1) {\n      if (localIndex < currSize) {\n        workgroupShared[localIndex] = workgroupShared[localIndex] + workgroupShared[localIndex + currSize];\n      }\n      workgroupBarrier();\n    }\n    if (localIndex == 0) {\n      meanShared = ${sumVector('workgroupShared[0]', components)} / f32(uniforms.normSize);\n    }\n    workgroupBarrier();\n\n    // reinitialize workgroup memory.\n    initial = ${f32Type}(0);\n    for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) {\n      let deviation =  ${f32Type}(${x.get('batch', 'channel', 'h')}) - ${f32Type}(meanShared);\n      initial = initial + deviation * deviation;\n    }\n    workgroupShared[localIndex] = initial;\n    workgroupBarrier();\n\n    // Calculate the sum of square of deviation of current channel data.\n    for (var currSize = workgroupSize >> 1;  currSize > 0; currSize = currSize >> 1) {\n      if (localIndex < currSize) {\n        workgroupShared[localIndex] = workgroupShared[localIndex] + workgroupShared[localIndex + currSize];\n      }\n      workgroupBarrier();\n    }\n    if (localIndex == 0) {\n      squaredNormShared = ${sumVector('workgroupShared[0]', components)};\n    }\n    workgroupBarrier();\n\n    let invStdDev = inverseSqrt(squaredNormShared / f32(uniforms.normSize) + f32(${attributes.epsilon}));\n    let channelScale = invStdDev * f32(${scale.getByOffset('channel')});\n    let channelShift = f32(${bias.getByOffset('channel')}) - meanShared * channelScale;\n    for (var h = localIndex; h < uniforms.normPackedSize; h += workgroupSize) {\n      let value = ${x.get('batch', 'channel', 'h')} * ${dataType}(${f32Type}(channelScale)) + ${dataType}(${\n            f32Type}(channelShift));\n      ${output.set('batch', 'channel', 'h', 'value')};\n    }\n  }`;\n      };\n      return {\n        ...{name: 'InstanceNormalization'},\n        // TODO: use epsilon as uniform. Currently epsilon as uniform fails test_instancenorm_epsilon.\n        shaderCache: {hint: `${attributes.epsilon};${components}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [\n            {dims: outputShape, dataType: inputs[0].dataType},\n          ],\n          dispatchGroup: {x: normCount},\n          programUniforms\n        }),\n        getShaderSource,\n      };\n    };\n\nconst computeMean =\n    (context: ComputeContext, input: TensorView, scale: TensorView, bias: TensorView, n: number, h: number, c: number,\n     epsilon: number) => {\n      const components = getMaxComponents(c);\n      const WG = 64;\n      // we will store channel scale and channel shift in [2, components] matrix\n      // or in vec2 when components == 1\n      const outputType = components === 1 ? 'vec2f' : `mat2x${components}f`;\n      const sumCastType = components === 1 ? 'f32' : `vec${components}f`;\n      const setOutputValue = (var1: string, var2: string) => `${outputType}(${var1}, ${var2})`;\n      const unitsOfWork = n * c / components;\n      const wgSize = Math.ceil(h / WG);\n\n      const meanInputDependencies: ProgramInputTensorInfoDependency[] = ['type'];\n      const meanProgramUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: wgSize}, {type: DataType.uint32, data: h},\n        {type: DataType.uint32, data: Math.floor(c / components)},\n        {type: DataType.uint32, data: Math.floor(h * c / components)}\n      ];\n\n      const getMeanShaderSource = (shaderHelper: ShaderHelper) => {\n        const inputHelper = inputVariable('input', input.dataType, input.dims, components);\n        return `\n  ${shaderHelper.declareVariables(inputHelper)}\n  @group(0) @binding(1) var<storage, read_write> output : array<${outputType}>;\n  struct Uniforms {wg_size:u32, H:u32, C:u32, image_size:u32};\n  @group(0) @binding(2) var<uniform> uniforms: Uniforms;\n\n  ${shaderHelper.mainStart(WG)}\n    let currentImageNumber = global_idx / ${WG} / uniforms.C;\n    let currentChannelNumber = (global_idx / ${WG}) % uniforms.C;\n    let wgOffset = local_id.x * uniforms.wg_size;\n    if (wgOffset >= uniforms.H) {\n        return;\n    }\n    let wgMax = min(wgOffset + uniforms.wg_size, uniforms.H);\n\n    let offset = currentImageNumber * uniforms.image_size + currentChannelNumber;\n    var sum = ${fillVector('f32', components)};\n    var squaredSum = ${fillVector('f32', components)};\n    for (var i: u32 = wgOffset; i < wgMax; i++) {\n        let value = ${sumCastType}(input[offset + i * uniforms.C]);\n        sum += value;\n        squaredSum += value * value;\n    }\n    output[global_idx] = ${setOutputValue('sum', 'squaredSum')};\n  }`;\n      };\n\n      const meanValues = context.compute(\n          {\n            name: 'InstanceNormComputeMean',\n            shaderCache: {hint: `${components}`, inputDependencies: meanInputDependencies},\n            getRunData: () => ({\n              outputs: [\n                {dims: [n, c, WG, 2], dataType: DataType.float},\n              ],\n              dispatchGroup: {x: n * c / components},\n              programUniforms: meanProgramUniforms\n            }),\n            getShaderSource: getMeanShaderSource,\n          },\n          {inputs: [input], outputs: [-1]})[0];\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: unitsOfWork}, {type: DataType.uint32, data: h},\n        {type: DataType.uint32, data: Math.floor(c / components)},\n        {type: DataType.uint32, data: Math.floor(WG * c / components)}\n      ];\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type', 'type'];\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const scaleHelper = inputVariable('scale', scale.dataType, scale.dims, components);\n        const biasHelper = inputVariable('bias', bias.dataType, bias.dims, components);\n        return `\n  @group(0) @binding(0) var<storage, read> input : array<${outputType}>;\n  @group(0) @binding(1) var<storage, read> scale : array<${scaleHelper.type.storage}>;\n  @group(0) @binding(2) var<storage, read> bias : array<${biasHelper.type.storage}>;\n  @group(0) @binding(3) var<storage, read_write> output : array<${outputType}>;\n  struct Uniforms {units_of_work : u32, H: u32, C : u32, image_size : u32};\n  @group(0) @binding(4) var<uniform> uniforms: Uniforms;\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.units_of_work')}\n    let currentImageNumber = global_idx / uniforms.C;\n    let currentChannelNumber = global_idx % uniforms.C;\n\n    let offset = currentImageNumber * uniforms.image_size;\n    var sum = ${fillVector('f32', components)};\n    var squaredSum = ${fillVector('f32', components)};\n    for (var i: u32 = 0; i < min(${WG}, uniforms.H); i++) {\n        let value = input[offset + i + currentChannelNumber * ${WG}];\n        sum += value[0];\n        squaredSum += value[1];\n    }\n    sum = sum / f32(uniforms.H);\n    squaredSum = squaredSum / f32(uniforms.H);\n    let invStdDev = inverseSqrt(squaredSum - sum * sum + f32(${epsilon}));\n    let channelScale = invStdDev * ${sumCastType}(scale[currentChannelNumber]);\n    let channelShift = ${sumCastType}(bias[currentChannelNumber]) - sum * channelScale;\n\n    output[global_idx] = ${setOutputValue('channelScale', 'channelShift')};\n  }`;\n      };\n      return context.compute(\n          {\n            name: 'InstanceNormComputeChannelScaleShift',\n            // TODO: use epsilon as uniform. Currently epsilon as uniform fails test_instancenorm_epsilon.\n            shaderCache: {hint: `${components};${epsilon}`, inputDependencies},\n            getRunData: () => ({\n              outputs: [\n                {dims: [n, c, 2], dataType: DataType.float},\n              ],\n              dispatchGroup: {x: Math.ceil(unitsOfWork / 64 /* workgroup size */)},\n              programUniforms\n            }),\n            getShaderSource,\n          },\n          {inputs: [meanValues, scale, bias], outputs: [-1]})[0];\n    };\n\nconst createInstanceNormNHWCProgramInfo =\n    (context: ComputeContext, inputs: readonly TensorView[], attributes: InstanceNormAttributes) => {\n      const xShape = inputs[0].dims;\n      const outputShape = xShape;\n      const N = xShape[0];\n      const C = xShape[xShape.length - 1];\n      const H = ShapeUtil.sizeFromDimension(xShape, 1) / C;\n      const components = getMaxComponents(C);\n      const outputSize = ShapeUtil.size(outputShape) / components;\n      const programUniforms: ProgramUniform[] =\n          [{type: DataType.uint32, data: H}, {type: DataType.uint32, data: Math.floor(C / components)}];\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n      // first compute mean\n      const channelScaleShift = computeMean(context, inputs[0], inputs[1], inputs[2], N, H, C, attributes.epsilon);\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n        const scaleType = components === 1 ? 'vec2f' : `mat2x${components}f`;\n        const scaleCastType = components === 1 ? dataType : `vec${components}<${dataType}>`;\n\n        const inputHelper = inputVariable('input', inputs[0].dataType, inputs[0].dims, components);\n        const outputHelper = outputVariable('output', inputs[0].dataType, outputShape, components);\n\n        return `\n  @group(0) @binding(0) var<storage, read> input : array<${inputHelper.type.storage}>;\n  @group(0) @binding(1) var<storage, read> scaleInput : array<${scaleType}>;\n  @group(0) @binding(2) var<storage, read_write> output : array<${outputHelper.type.storage}>;\n  struct Uniforms {H: u32, C : u32};\n  @group(0) @binding(3) var<uniform> uniforms: Uniforms;\n\n  ${shaderHelper.mainStart()}\n    let currentImageNumber = global_idx / (uniforms.C * uniforms.H);\n    let currentChannelNumber = global_idx % uniforms.C;\n\n    let scaleOffset = currentImageNumber * uniforms.C + currentChannelNumber;\n    let scale = scaleInput[scaleOffset];\n    output[global_idx] = fma(input[global_idx], ${scaleCastType}(scale[0]), ${scaleCastType}(scale[1]));\n  }`;\n      };\n      context.compute(\n          {\n            name: 'InstanceNormalizationNHWC',\n            shaderCache: {hint: `${components}`, inputDependencies},\n            getRunData: () => ({\n              outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n              dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n              programUniforms\n            }),\n            getShaderSource,\n          },\n          {inputs: [inputs[0], channelScaleShift]});\n    };\n\nexport const instanceNorm = (context: ComputeContext, attributes: InstanceNormAttributes): void => {\n  if (attributes.format === 'NHWC') {\n    createInstanceNormNHWCProgramInfo(context, context.inputs, attributes);\n  } else {\n    context.compute(createInstanceNormProgramInfo(context.inputs, attributes));\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {castToF32, fillVector, getMaxComponents, inputVariable, outputVariable, ShaderHelper, sumVector, tensorTypeToWsglStorageType, UniformsArrayType,} from './common';\n\ninterface LayerNormAttributes {\n  simplified: boolean;\n  axis: number;\n  epsilon: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length < 2) {\n    throw new Error('layerNorm requires at least 2 inputs.');\n  }\n};\n\nconst createLayerNormProgramInfo =\n    (inputs: readonly TensorView[], attributes: LayerNormAttributes, outputCount: number): ProgramInfo => {\n      const simplified = attributes.simplified;\n\n      const xShape = inputs[0].dims;\n      const scale = inputs[1];\n      const bias = !simplified && inputs[2];\n\n      const outputShape = xShape;\n      const axis = ShapeUtil.normalizeAxis(attributes.axis, xShape.length);\n      const normCount = ShapeUtil.sizeToDimension(xShape, axis);\n      const normSize = ShapeUtil.sizeFromDimension(xShape, axis);\n\n      const scaleSize = ShapeUtil.size(scale.dims);\n      const biasSize = bias ? ShapeUtil.size(bias.dims) : 0;\n      if (scaleSize !== normSize || (bias && biasSize !== normSize)) {\n        throw new Error(`Size of X.shape()[axis:] == ${normSize}.\n       Size of scale and bias (if provided) must match this.\n       Got scale size of ${scaleSize} and bias size of ${biasSize}`);\n      }\n\n      const meanInvStdDevDim: number[] = [];\n      for (let i = 0; i < xShape.length; ++i) {\n        if (i < axis) {\n          meanInvStdDevDim.push(xShape[i]);\n        } else {\n          meanInvStdDevDim.push(1);\n        }\n      }\n      const components = getMaxComponents(normSize);\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: normCount}, {type: DataType.float, data: normSize},\n        {type: DataType.uint32, data: Math.floor(normSize / components)},\n        {type: DataType.float, data: attributes.epsilon}\n      ];\n      if (bias) {\n        inputDependencies.push('type');\n      }\n      const hasMeanDataOutput = outputCount > 1;\n      const hasInvStdOutput = outputCount > 2;\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n        const variables = [\n          inputVariable('x', inputs[0].dataType, inputs[0].dims, components),\n          inputVariable('scale', scale.dataType, scale.dims, components),\n        ];\n        if (bias) {\n          variables.push(inputVariable('bias', bias.dataType, bias.dims, components));\n        }\n        variables.push(outputVariable('output', inputs[0].dataType, outputShape, components));\n        if (hasMeanDataOutput) {\n          variables.push(outputVariable('mean_data_output', DataType.float, meanInvStdDevDim));\n        }\n        if (hasInvStdOutput) {\n          variables.push(outputVariable('inv_std_output', DataType.float, meanInvStdDevDim));\n        }\n\n        const uniforms: UniformsArrayType = [\n          {name: 'norm_count', type: 'u32'}, {name: 'norm_size', type: 'f32'},\n          {name: 'norm_size_vectorized', type: 'u32'}, {name: 'epsilon', type: 'f32'}\n        ];\n        return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.norm_count')}\n    let offset = global_idx * uniforms.norm_size_vectorized;\n    var mean_vector = ${fillVector('f32', components)};\n    var mean_square_vector = ${fillVector('f32', components)};\n\n    for (var h: u32 = 0u; h < uniforms.norm_size_vectorized; h++) {\n      let value = ${castToF32(dataType, components, 'x[h + offset]')};\n      mean_vector += value;\n      mean_square_vector += value * value;\n    }\n    let mean = ${sumVector('mean_vector', components)} / uniforms.norm_size;\n    let inv_std_dev = inverseSqrt(${sumVector('mean_square_vector', components)} / uniforms.norm_size ${\n            simplified ? '' : '- mean * mean'} + uniforms.epsilon);\n\n    for (var j: u32 = 0; j < uniforms.norm_size_vectorized; j++) {\n      let f32input = ${castToF32(dataType, components, 'x[j + offset]')};\n      let f32scale = ${castToF32(dataType, components, 'scale[j]')};\n      output[j + offset] = ${variables[0].type.value}((f32input ${simplified ? '' : '- mean'}) * inv_std_dev * f32scale\n        ${bias ? `+ ${castToF32(dataType, components, 'bias[j]')}` : ''}\n      );\n    }\n\n    ${hasMeanDataOutput ? 'mean_data_output[global_idx] = mean' : ''};\n    ${hasInvStdOutput ? 'inv_std_output[global_idx] = inv_std_dev' : ''};\n  }`;\n      };\n      const outputs = [{dims: outputShape, dataType: inputs[0].dataType}];\n      if (hasMeanDataOutput) {\n        outputs.push({dims: meanInvStdDevDim, dataType: DataType.float});\n      }\n      if (hasInvStdOutput) {\n        outputs.push({dims: meanInvStdDevDim, dataType: DataType.float});\n      }\n\n      return {\n        name: 'LayerNormalization',\n        shaderCache: {hint: `${components};${outputCount};${simplified}`, inputDependencies},\n        getRunData: () =>\n            ({outputs, dispatchGroup: {x: Math.ceil(normCount / 64 /* workgroup size */)}, programUniforms}),\n        getShaderSource,\n      };\n    };\n\nexport const layerNorm = (context: ComputeContext, attributes: LayerNormAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createLayerNormProgramInfo(context.inputs, attributes, context.outputCount));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType, getTensorElementSize} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, getMaxComponents, inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType, UniformsArrayType} from './common';\n\n//  TODO support quantization bits not equal to 4\nexport interface MatMulNBitsAttributes extends AttributeWithCacheKey {\n  k: number;\n  n: number;\n  accuracyLevel: number;\n  bits: number;\n  blockSize: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: MatMulNBitsAttributes): void => {\n  if (inputs.length < 3 || inputs.length > 4) {\n    throw new Error('MatMulNBits requires 3 or 4 inputs');\n  }\n  const a = inputs[0];\n  const aRank = a.dims.length;\n  if (a.dims[aRank - 1] !== attributes.k) {\n    throw new Error('The last dim of input shape does not match the k value');\n  }\n  const nBlocksPerCol = Math.floor((attributes.k + attributes.blockSize - 1) / attributes.blockSize);\n  const blobSize = attributes.blockSize / 8 * attributes.bits;\n  const b = inputs[1];\n  if (!ShapeUtil.areEqual(b.dims, [attributes.n, nBlocksPerCol, blobSize])) {\n    throw new Error('The second inputs must be 3D tensor with shape N X nBlocksPerCol X blobSize');\n  }\n  const scales = inputs[2];\n  const scalesShape = scales.dims;\n  if (ShapeUtil.size(scalesShape) !== attributes.n * nBlocksPerCol) {\n    throw new Error('scales input size error.');\n  }\n  if (inputs.length === 4) {\n    const zeroPoints = inputs[3];\n    const zeroPointsShape = zeroPoints.dims;\n    const expectedZeroPointsSize =\n        attributes.bits > 4 ? (attributes.n * nBlocksPerCol) : attributes.n * Math.floor((nBlocksPerCol + 1) / 2);\n    if (ShapeUtil.size(zeroPointsShape) !== expectedZeroPointsSize) {\n      throw new Error('zeroPoints input size error.');\n    }\n  }\n};\n\nexport const createMatMulNBitsProgramInfo =\n    (inputs: readonly TensorView[], attributes: MatMulNBitsAttributes,\n     maxComputeWorkgroupSizes: [number, number, number], maxComputeWorkgroupStorageSize: number): ProgramInfo => {\n      const inputShape = inputs[0].dims;\n      const aRank = inputShape.length;\n      const nBlocksPerCol = Math.floor((attributes.k + attributes.blockSize - 1) / attributes.blockSize);\n      const dimAOuter = inputShape[aRank - 2];\n      const dimInner = attributes.k;\n      const dimBOuter = attributes.n;\n      const batchDims = inputShape.slice(0, aRank - 2);\n      const batchSize = ShapeUtil.size(batchDims);\n      const blobSize = attributes.blockSize / 8 * attributes.bits;\n      const blobSizeInWords = blobSize / 4;\n      const dataType = inputs[0].dataType;\n      const outputNumber = getMaxComponents(dimAOuter);\n      const aComponents = getMaxComponents(attributes.k);\n      const bComponents = getMaxComponents(blobSizeInWords);\n      const elementSize = getTensorElementSize(dataType)!;\n      const workgroupOutputSize = dimAOuter * nBlocksPerCol * elementSize;\n      const maxNumberOfComponents = Math.floor(maxComputeWorkgroupStorageSize / workgroupOutputSize);\n      const useBlockwiseMatMulNBits = nBlocksPerCol <= maxComputeWorkgroupSizes[0] && maxNumberOfComponents > 0;\n      const components = (!useBlockwiseMatMulNBits || maxNumberOfComponents >= 4) ? getMaxComponents(dimBOuter) :\n          ((maxNumberOfComponents >= 2) && getMaxComponents(dimBOuter) >= 2)      ? 2 :\n                                                                                    1;\n      const outputShape = batchDims.concat([dimAOuter, dimBOuter]);\n      const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;\n\n      const programUniforms: ProgramUniform[] = useBlockwiseMatMulNBits ?\n          [] :\n          [{type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: attributes.blockSize}];\n      const inputShapeTemp = [batchSize, dimAOuter, dimInner / aComponents];\n      const bShape = ShapeUtil.convertShape(inputs[1].dims).slice();\n      bShape.splice(-1, 1, blobSizeInWords / bComponents);\n      programUniforms.push(...createTensorShapeVariables(inputShapeTemp));\n      programUniforms.push(...createTensorShapeVariables(bShape));\n      programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n      if (inputs.length === 4) {\n        programUniforms.push(...createTensorShapeVariables(ShapeUtil.convertShape(inputs[3].dims)));\n      }\n      const outputShapeTemp = [batchSize, dimAOuter, dimBOuter / components];\n      programUniforms.push(...createTensorShapeVariables(outputShapeTemp));\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const inputRank = inputShapeTemp.length;\n        const a = inputVariable('a', inputs[0].dataType, inputRank, aComponents);\n        const b = inputVariable('b', DataType.uint32, bShape.length, bComponents);\n        const scales = inputVariable('scales', inputs[2].dataType, inputs[2].dims.length);\n        const inputVariables = [a, b, scales];\n        const zeroPoints =\n            inputs.length === 4 ? inputVariable('zero_points', DataType.uint32, inputs[3].dims.length) : undefined;\n        if (zeroPoints) {\n          inputVariables.push(zeroPoints);\n        }\n        const outputRank = outputShapeTemp.length;\n        const output = outputVariable('output', inputs[0].dataType, outputRank, components);\n        const uniforms: UniformsArrayType = [{name: 'output_size', type: 'u32'}, {name: 'block_size', type: 'u32'}];\n        const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n\n        const qDqDataType = (() => {\n          switch (aComponents) {\n            case 1:\n              return `array<${dataType}, 8>`;\n            case 2:\n              return `mat4x2<${dataType}>`;\n            case 4:\n              return `mat2x4<${dataType}>`;\n            default:\n              throw new Error(`${aComponents}-component is not supported.`);\n          }\n        })();\n\n        const processOneBlock = `\n        for (var word: u32 = 0; word < ${blobSizeInWords}; word += ${bComponents}) {\n          ${b.indicesSet('b_indices', '2', 'word')};\n          let b_data = ${b.getByIndices('b_indices')};\n          for (var i: u32 = 0; i < ${bComponents}; i++) {\n            let b_value: u32 = ${bComponents === 1 ? 'b_data' : 'b_data[word + i]'};\n            let b_mask: u32 = 0x0F0F0F0Fu;\n            let b_value_lower: vec4<u32> = unpack4xU8(b_value & b_mask);\n            let b_value_upper: vec4<u32> = unpack4xU8((b_value >> 4) & b_mask);\n            let b_quantized_values = ${qDqDataType}(${\n            Array.from({length: 4}, (_, i) => `${dataType}(b_value_lower[${i}]), ${dataType}(b_value_upper[${i}])`)\n                .join(', ')});\n            let b_dequantized_values = ${(() => {\n          if (aComponents === 1) {\n            return `${qDqDataType}(${\n                Array.from({length: 8}, (_, i) => `(b_quantized_values[${i}] - zero_point) * scale`).join(', ')});`;\n          } else {\n            return `(b_quantized_values - ${qDqDataType}(${Array(8).fill('zero_point').join(',')})) * scale;`;\n          }\n        })()};\n            // Number of B elements per 32-bit word is 32/bits = 32/4 = 8\n            for (var m: u32 = 0; m < ${useBlockwiseMatMulNBits ? dimAOuter : outputNumber}u; m++) {\n              ${a.indicesSet('a_indices', inputRank - 2, useBlockwiseMatMulNBits ? 'm' : `row * ${outputNumber} + m`)};\n              ${a.indicesSet('a_indices', inputRank - 1, 'word_offset')};\n              var input_offset = ${a.indicesToOffset('a_indices')};\n              var a_data: ${qDqDataType};\n              for (var j: u32 = 0; j < ${8 / aComponents}; j++) {\n                a_data[j] = ${a.getByOffset('input_offset')};\n                input_offset++;\n              }\n              ${useBlockwiseMatMulNBits ? 'workgroup_shared[workgroup_shared_offset + m]' : 'output_values[m]'}${\n            components > 1 ? '[c]' : ''} += ${\n            Array\n                .from(\n                    {length: 8 / aComponents},\n                    (_, i) => `${\n                        aComponents === 1 ? `a_data[${i}] * b_dequantized_values[${i}]` :\n                                            `dot(a_data[${i}], b_dequantized_values[${i}])`}`)\n                .join(' + ')};\n            }\n            word_offset += ${8 / aComponents};\n          }\n        }`;\n        const updateZeroPointIndex = zeroPoints ? `\n          zero_point_offset += 4;\n          if (zero_point_offset == 32) {\n            zero_point_offset = 0;\n            zero_point_index++;\n            zero_point_word = ${zeroPoints.getByOffset('zero_point_index')};\n          }` :\n                                                  '';\n\n        return useBlockwiseMatMulNBits ? `\n        var<workgroup> workgroup_shared: array<${output.type.value}, ${dimAOuter * nBlocksPerCol}>;\n        ${shaderHelper.declareVariables(...inputVariables, output)}\n        ${shaderHelper.mainStart([\n          nBlocksPerCol, 1, 1\n        ])}\n          var a_indices: ${a.type.indices};\n          var block = local_id.x;\n          var col = workgroup_id.y;\n          var batch = workgroup_id.z;\n          ${a.indicesSet('a_indices', '0', 'batch')};\n          // Two zero points are packed into one byte when uniforms.bits is 4.\n          for (var c: u32 = 0; c < ${components}; c++) {\n            let col_times_components_plus_c = col * ${components} + c;\n              ${\n                                             zeroPoints ? `\n            var zero_point_bytes_per_col: u32 = (${nBlocksPerCol} + 1) / 2;\n            var zero_point_byte_count: u32 = col_times_components_plus_c * zero_point_bytes_per_col + (block >> 0x1u);\n            var zero_point_word_index: u32 = zero_point_byte_count >> 0x2u;\n            var zero_point_byte_offset: u32 = zero_point_byte_count & 0x3u;\n            var zero_point_nibble_offset: u32 = block & 0x1u;\n            var zero_point_bits_offset: u32 = (zero_point_byte_offset << 3) + (zero_point_nibble_offset << 2);\n            var zero_point_word: u32 = ${zeroPoints.getByOffset('zero_point_word_index')} >> zero_point_bits_offset;` :\n                                                          ''}\n            var b_indices: ${b.type.indices};\n            ${b.indicesSet('b_indices', '0', 'col_times_components_plus_c')};\n            // The scale and zero points are computed per block.\n            var scales_index = col_times_components_plus_c * ${nBlocksPerCol} + block;\n            let scale = ${scales.getByOffset('scales_index')};\n            // The default zero point is 8 for unsigned 4-bit quantization.\n            let zero_point = ${dataType}(${zeroPoints ? '(zero_point_word) & 0xFu' : 8.0});\n            ${b.indicesSet('b_indices', '1', 'block')};\n            var word_offset: u32 = block * ${attributes.blockSize / aComponents};\n            var workgroup_shared_offset: u32 = block * ${dimAOuter};\n            ${processOneBlock}\n          }\n          workgroupBarrier();\n          if (local_id.x == 0u) {\n            var output_indices: ${output.type.indices};\n            ${output.indicesSet('output_indices', '0', 'batch')};\n            ${output.indicesSet('output_indices', outputRank - 1, 'col')};\n            ${output.indicesSet('output_indices', outputRank - 2, '0')};\n            var output_offset = ${output.indicesToOffset('output_indices')};\n            for (var m: u32 = 0u; m < ${dimAOuter}u; m++) {\n              var output_value: ${output.type.value} = ${output.type.value}(0);\n              var workgroup_shared_offset: u32 = m;\n              for (var b: u32 = 0u; b < ${nBlocksPerCol}u; b++) {\n                output_value += workgroup_shared[workgroup_shared_offset];\n                workgroup_shared_offset += ${dimAOuter};\n              }\n              ${output.setByOffset('output_offset', 'output_value')};\n              output_offset += ${dimBOuter / components};\n            }\n          }\n        }` :\n                                         `\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n        ${shaderHelper.mainStart()}\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n          var output_values: array<${output.type.value}, ${outputNumber}>;\n          var output_indices = ${output.offsetToIndices('global_idx')};\n          var col = ${output.indicesGet('output_indices', outputRank - 1)};\n          var row = ${output.indicesGet('output_indices', outputRank - 2)};\n          var a_indices: ${a.type.indices} = output_indices;\n          // Two zero points are packed into one byte because uniforms.bits <= 4.\n          // zero_point_offset is either 0 or 4. It is bit offset within one byte.\n          // TODO support zero_point_offset for bits > 4\n          ${\n                                             zeroPoints ? `\n          var zero_point_abs_offset = col * ${components} * ((${nBlocksPerCol} + 1) / 2);\n          var zero_point_index: u32 = zero_point_abs_offset / 4;\n          var zero_point_word: u32 = ${zeroPoints.getByOffset('zero_point_index')};\n          var zero_point_offset: u32 = (zero_point_abs_offset % 4) * 8;` :\n                                                          ''}\n          var scale_index = col * ${nBlocksPerCol * components};\n          var b_indices: ${b.type.indices};\n          for (var c: u32 = 0; c < ${components}; c++) {\n            ${b.indicesSet('b_indices', '0', `col * ${components} + c`)};\n            var block_offset: u32 = 0;\n            for (var block: u32 = 0; block < ${nBlocksPerCol}; block++) {\n              // The scale and zero points are computed per block.\n              let scale = ${scales.getByOffset('scale_index')};\n              // The default zero point is 8 for unsigned 4-bit quantization.\n              let zero_point = ${dataType}(${zeroPoints ? 'extractBits(zero_point_word, zero_point_offset, 4)' : 8.0});\n              ${b.indicesSet('b_indices', '1', 'block')};\n              var word_offset: u32 = block_offset;\n              ${processOneBlock}\n              scale_index++;\n              ${updateZeroPointIndex}\n              block_offset += uniforms.block_size / ${aComponents};\n            }\n            // Drop the trailing 4 bits if the zero_poit_offset is not a byte boundary to align with the next byte.\n            ${\n                                             zeroPoints ? `if (zero_point_offset % 8 > 0) {\n                ${updateZeroPointIndex}\n              }` :\n                                                          ''}\n            }\n            for (var k: u32 = 0u; k < ${outputNumber}u; k++) {\n              ${output.indicesSet('output_indices', outputRank - 2, `${outputNumber} * row + k`)};\n              ${output.setByIndices('output_indices', 'output_values[k]')}\n            }\n        }`;\n      };\n      return {\n        name: useBlockwiseMatMulNBits ? 'BlockwiseMatMulNBits' : 'MatMulNBits',\n        shaderCache: {\n          hint: `${attributes.cacheKey};${dimAOuter};${dataType};${inputs.length}`,\n          inputDependencies: Array(inputs.length).fill('rank')\n        },\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType}],\n          name: useBlockwiseMatMulNBits ? 'BlockwiseMatMulNBits' : 'MatMulNBits',\n          dispatchGroup: useBlockwiseMatMulNBits ? {x: 1, y: Math.ceil(dimBOuter / components), z: batchSize} :\n                                                   {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource\n      };\n    };\n\nexport const matMulNBits = (context: ComputeContext, attributes: MatMulNBitsAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  const maxComputeWorkgroupSizes: [number, number, number] = context.getMaxComputeWorkgroupSizes();\n  const maxComputeWorkgroupStorageSize = context.getMaxComputeWorkgroupStoragesize();\n  context.compute(createMatMulNBitsProgramInfo(\n      context.inputs, attributes, maxComputeWorkgroupSizes, maxComputeWorkgroupStorageSize));\n};\n\nexport const parseMatMulNBitsAttributes = (attributes: Record<string, unknown>): MatMulNBitsAttributes =>\n    createAttributeWithCacheKey(attributes as Omit<MatMulNBitsAttributes, keyof AttributeWithCacheKey>);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, GpuDataType, ProgramUniform} from '../types';\n\nimport {applyAttention, AttentionAttrs, AttentionMaskType, AttentionParameters, AttentionQkvFormat} from './attention';\nimport {inputVariable, outputVariable, ShaderHelper, UniformsArrayType} from './common';\nimport {createTransposeProgramInfo, TransposeAttributes} from './transpose';\n\nconst getInput = (inputs: readonly TensorView[], i: number) =>\n    (inputs.length > i) && (inputs[i].dims.length > 0) && (ShapeUtil.size(inputs[i].dims)) > 0 ? inputs[i] : undefined;\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: AttentionAttrs): AttentionParameters => {\n  const query = inputs[0];\n  const key = getInput(inputs, 1);\n  const value = getInput(inputs, 2);\n  const bias = getInput(inputs, 3);\n  const keyPaddingMask = getInput(inputs, 4);\n  const relativePositionBias = getInput(inputs, 5);\n  const pastKey = getInput(inputs, 6);\n  const pastValue = getInput(inputs, 7);\n\n  // Abbreviation and Meanings:\n  //   B:    batch_size\n  //   S:    sequence_length (input sequence length of query)\n  //   P:    past_sequence_length (past sequence length of key or value)\n  //   L:    kv_sequence_length (input sequence length of key or value)\n  //   M:    max_sequence_length\n  //   T:    total_sequence_length = past_sequence_length + kv_sequence_length\n  //   N:    num_heads\n  //   H:    head size for Q and K, aka q_head_size or k_head_size or qk_head_size\n  //   H_v:  v_head_size\n  //   D_i:  input hidden size\n  //   D:    hidden size for Q and K (D = N * H), aka q_hidden_size or k_hidden_size or qk_hidden_size\n  //   D_v:  v_hidden_size = num_heads * v_head_size\n\n  //     key_padding_mask (K/V)     : (B) or (2*B + 1) or (B, L) or None\n  //     relative_position_bias     : (B, 1, S, L)\n  //     past_key                   : (B, N, S*, H)\n  //     past_value                 : (B, N, S*, H)\n  // When no packing for q/k/v:\n  //     query            (Q)       : (B, S, D)\n  //     key              (K)       : (B, L, D) or (B, N, S*, H)\n  //     value            (V)       : (B, L, D_v) or (B, N, S*, H)\n  //     bias             (Q/K/V)   : (D + D + D_v)\n  // When packed kv is used:\n  //     query            (Q)       : (B, S, D)\n  //     key              (K)       : (B, L, N, 2, H)\n  //     value            (V)       : None\n  //     bias             (Q/K/V)   : None\n  // When packed qkv is used:\n  //     query            (Q)       : (B, L, N, 3, H) or (B, S, 3*D)\n  //     key              (K)       : None\n  //     value            (V)       : None\n  //     bias             (Q/K/V)   : None or (D + D + D_v)\n\n  if (query.dims.length !== 3 && query.dims.length !== 5) {\n    throw new Error('Input query is expected to have 3 or 5 dimensions');\n  }\n\n  const dmmhaPacking = false;\n  const batchSize = query.dims[0];\n  const sequenceLength = query.dims[1];\n  const hiddenSize = query.dims.length === 3 ? (dmmhaPacking ? query.dims[2] / 3 : query.dims[2]) :\n                                               attributes.numHeads * query.dims[4];\n  let kvSequenceLength = sequenceLength;\n\n  let pastSequenceLength = 0;\n  let maxSequenceLength = 0;\n  const headSize = Math.floor(hiddenSize / attributes.numHeads);\n  if (pastKey && pastValue) {\n    if (pastKey.dims.length !== 4) {\n      throw new Error('Input \"past_key\" is expected to have 4 dimensions');\n    }\n    if (pastKey.dims[0] !== batchSize || pastKey.dims[1] !== attributes.numHeads || pastKey.dims[3] !== headSize) {\n      throw new Error('Input \"past_key\" shape (batch_size, num_heads, past_sequence_length, head_size)');\n    }\n    if (pastValue.dims[0] !== batchSize || pastValue.dims[1] !== attributes.numHeads ||\n        pastValue.dims[3] !== headSize) {\n      throw new Error('Input \"past_value\" shape (batch_size, num_heads, past_sequence_length, head_size)');\n    }\n    if (pastKey.dims[2] !== pastValue.dims[2]) {\n      throw new Error('Input \"past_key\" and \"past_value\" shall have same dim 2 (past_sequence_length)');\n    }\n    if (pastValue.dims.length !== 4) {\n      throw new Error('Input \"past_value\" is expected to have 4 dimensions');\n    }\n    pastSequenceLength = pastKey.dims[2];\n    maxSequenceLength = pastKey.dims[2];\n  } else if (pastKey || pastValue) {\n    throw new Error('Input \"past_key\" and \"past_value\" shall be both present or both absent');\n  }\n\n  let qkvFormat: AttentionQkvFormat;\n  if (key) {\n    if (query.dims.length !== 3) {\n      throw new Error('Input \"query\" is expected to have 3 dimensions when key is given');\n    }\n    if (key.dims.length < 3 || key.dims.length > 5) {\n      throw new Error('Input \"key\" is expected to have 3, 4, or 5 dimensions');\n    }\n    if (query.dims[0] !== key.dims[0]) {\n      throw new Error('Input \"query\" and \"key\" shall have same dim 0 (batch size)');\n    }\n\n    if (key.dims.length === 3) {\n      if (key.dims[2] !== query.dims[2]) {\n        throw new Error('Input \"query\" and \"key\" shall have same dim 2 (hidden_size)');\n      }\n      qkvFormat = AttentionQkvFormat.qkvBSNH;\n      kvSequenceLength = key.dims[1];\n    } else if (key.dims.length === 5) {\n      if (key.dims[2] !== attributes.numHeads || key.dims[3] !== 2 || key.dims[4] !== headSize) {\n        throw new Error('Expect \"key\" shape (batch_size, kv_sequence_length, num_heads, 2, head_size) for packed kv');\n      }\n      if (value) {\n        throw new Error('Expect \"value\" be none when \"key\" has packed kv format.');\n      }\n      qkvFormat = AttentionQkvFormat.qKvBSNHxBSN2H;\n      kvSequenceLength = key.dims[1];\n    } else {  // key_dims.size() == 4 (cross-attention with past_key)\n      if (key.dims[1] !== attributes.numHeads || key.dims[3] !== headSize) {\n        throw new Error('Expect \"key\" shape (batch_size, num_heads, kv_sequence_length, head_size) for past_key');\n      }\n\n      qkvFormat = AttentionQkvFormat.unknown;\n      kvSequenceLength = key.dims[2];\n    }\n  } else {  // packed QKV\n    if (query.dims.length !== 3 && query.dims.length !== 5) {\n      throw new Error('Input \"query\" is expected to have 3 or 5 dimensions when key is empty');\n    }\n    if (query.dims.length === 5 && (query.dims[2] !== attributes.numHeads || query.dims[3] !== 3)) {\n      throw new Error('Expect \"query\" shape (batch_size, kv_sequence_length, num_heads, 3, head_size) for packed kv');\n    }\n\n    qkvFormat = AttentionQkvFormat.qkvBSN3H;\n  }\n\n  if (bias) {\n    if (bias.dims.length !== 1) {\n      throw new Error('Input \"bias\" is expected to have 1 dimension');\n    }\n\n    if (value) {\n      if (query.dims.length === 5 && query.dims[3] === 2) {\n        throw new Error('bias is not allowed for packed kv.');\n      }\n    }\n  }\n\n  let maskType: AttentionMaskType = AttentionMaskType.none;\n  if (keyPaddingMask) {\n    maskType = AttentionMaskType.maskUnknown;\n    const maskDims = keyPaddingMask.dims;\n    if (maskDims.length === 1) {\n      if (maskDims[0] === batchSize) {\n        maskType = AttentionMaskType.mask1dKeySeqLen;\n      } else if (maskDims[0] === 3 * batchSize + 2) {\n        maskType = AttentionMaskType.mask1DKeySeqLenStart;\n      }\n    } else if (maskDims.length === 2 && maskDims[0] === batchSize && maskDims[1] === kvSequenceLength) {\n      maskType = AttentionMaskType.mask2dKeyPadding;\n    }\n    if (maskType === AttentionMaskType.maskUnknown) {\n      throw new Error('Input \"key_padding_mask\" shape shall be (batch_size) or (batch_size, kv_sequence_length)');\n    }\n    throw new Error('Mask not supported');\n  }\n\n  let passPastInKv = false;\n  let vHiddenSize = hiddenSize;\n  if (value) {\n    if (value.dims.length !== 3 && value.dims.length !== 4) {\n      throw new Error('Input \"value\" is expected to have 3 or 4 dimensions');\n    }\n\n    if (query.dims[0] !== value.dims[0]) {\n      throw new Error('Input \"query\" and \"value\" shall have same dim 0 (batch_size)');\n    }\n\n    if (value.dims.length === 3) {\n      if (kvSequenceLength !== value.dims[1]) {\n        throw new Error('Input \"key\" and \"value\" shall have the same dim 1 (kv_sequence_length)');\n      }\n      vHiddenSize = value.dims[2];\n    } else {\n      if (kvSequenceLength !== value.dims[2]) {\n        throw new Error('Input \"past_key\" and \"past_value\" shall have the same dim 2 (kv_sequence_length)');\n      }\n      vHiddenSize = value.dims[1] * value.dims[3];\n      passPastInKv = true;\n    }\n  }\n\n  const totalSequenceLength = pastSequenceLength + kvSequenceLength;\n  const broadcastResPosBias = false;\n\n  if (keyPaddingMask) {\n    throw new Error('Key padding mask is not supported');\n  }\n\n  if (relativePositionBias) {\n    if (relativePositionBias.dims.length !== 4) {\n      throw new Error('Input \"relative_position_bias\" is expected to have 4 dimensions');\n    }\n    if ((relativePositionBias.dims[0] !== batchSize && relativePositionBias.dims[0] !== 1) ||\n        relativePositionBias.dims[1] !== attributes.numHeads || relativePositionBias.dims[2] !== sequenceLength ||\n        relativePositionBias.dims[3] !== totalSequenceLength) {\n      throw new Error('Input \"relative_position_bias\" shape (batch_size, 1, sequence_length, kv_sequence_length)');\n    }\n  }\n\n  return {\n    batchSize,\n    sequenceLength,\n    pastSequenceLength,\n    kvSequenceLength,\n    totalSequenceLength,\n    maxSequenceLength,\n    inputHiddenSize: 0,\n    hiddenSize,\n    vHiddenSize,\n    headSize,\n    vHeadSize: Math.floor(vHiddenSize / attributes.numHeads),\n    numHeads: attributes.numHeads,\n    isUnidirectional: false,\n    pastPresentShareBuffer: false,\n    maskFilterValue: attributes.maskFilterValue,\n    maskType,\n    scale: attributes.scale,\n    broadcastResPosBias,\n    passPastInKv,\n    qkvFormat,\n  };\n};\n\nexport const parseMultiHeadAttentionAttributes = (attributes: AttentionAttrs): AttentionAttrs =>\n    createAttributeWithCacheKey({...attributes});\n\nconst weightTransposeAttribute: TransposeAttributes = createAttributeWithCacheKey({perm: [0, 2, 1, 3]});\n\nconst addBiasTranspose =\n    (context: ComputeContext, qkv: TensorView, bias: TensorView, batchSize: number, sequenceLength: number,\n     hiddenSize: number, biasOffset: number) => {\n      const outputShape = [batchSize, sequenceLength, hiddenSize];\n      const outputSize = ShapeUtil.size(outputShape);\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: biasOffset},\n        {type: DataType.uint32, data: hiddenSize}\n      ];\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const output = outputVariable('qkv_with_bias', qkv.dataType, outputShape);\n        const qkvInput = inputVariable('qkv', qkv.dataType, outputShape);\n        const biasInput = inputVariable('bias', bias.dataType, outputShape);\n\n        const uniforms: UniformsArrayType = [\n          {name: 'output_size', type: 'u32'}, {name: 'bias_offset', type: 'u32'}, {name: 'hidden_size', type: 'u32'}\n        ];\n        return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(qkvInput, biasInput, output)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n    let bias_offset_idx = (global_idx % uniforms.hidden_size) + uniforms.bias_offset;\n\n    qkv_with_bias[global_idx] = qkv[global_idx] + bias[bias_offset_idx];\n  }`;\n      };\n\n      return context.compute(\n          {\n            name: 'MultiHeadAttentionAddBias',\n            shaderCache: {inputDependencies: ['type', 'type']},\n            getRunData: () => ({\n              outputs: [{dims: outputShape, dataType: qkv.dataType, gpuDataType: GpuDataType.default}],\n              dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n              programUniforms\n            }),\n            getShaderSource,\n          },\n          {inputs: [qkv, bias], outputs: [-1]})[0];\n    };\n\nconst maybeTransposeToBNSHAndAddBias =\n    (context: ComputeContext, batchSize: number, numHeads: number, sequenceLength: number, headSize: number,\n     input: TensorView, bias?: TensorView, biasOffset?: number) => {\n      // const newDims = [];\n\n      let reshapedInput = input;\n      if (!bias) {\n        if (input.dims.length === 3) {\n          reshapedInput = input.reshape([batchSize, sequenceLength, numHeads, headSize]);\n        }\n        return context.compute(\n            createTransposeProgramInfo(reshapedInput, weightTransposeAttribute.perm),\n            {inputs: [reshapedInput], outputs: [-1]})[0];\n      } else {\n        if (sequenceLength === 1) {\n          throw new Error('AddBiasReshape is not implemented. Please export your model with packed QKV or KV');\n        } else {\n          reshapedInput =\n              addBiasTranspose(context, input, bias, batchSize, sequenceLength, numHeads * headSize, biasOffset!);\n          reshapedInput = reshapedInput.reshape([batchSize, sequenceLength, numHeads, headSize]);\n          return context.compute(\n              createTransposeProgramInfo(reshapedInput, weightTransposeAttribute.perm),\n              {inputs: [reshapedInput], outputs: [-1]})[0];\n        }\n      }\n    };\n\nexport const multiHeadAttention = (context: ComputeContext, attributes: AttentionAttrs): void => {\n  const params = validateInputs(context.inputs, attributes);\n  const query = context.inputs[0];\n  const key = getInput(context.inputs, 1);\n  const value = getInput(context.inputs, 2);\n  const bias = getInput(context.inputs, 3);\n  const keyPaddingMask = getInput(context.inputs, 4);\n  const relativePositionBias = getInput(context.inputs, 5);\n  const pastKey = getInput(context.inputs, 6);\n  const pastValue = getInput(context.inputs, 7);\n  if (query.dims.length === 5) {\n    throw new Error('Packed QKV is not implemented');\n  }\n\n  if (key?.dims.length === 5) {\n    throw new Error('Packed KV is not implemented');\n  }\n\n  // applyAttention expects BNSH inputs\n  const kvBNSH = key && value && key.dims.length === 4 && value.dims.length === 4;\n\n  const Q = maybeTransposeToBNSHAndAddBias(\n      context, params.batchSize, params.numHeads, params.sequenceLength, params.headSize, query, bias, 0);\n\n  if (kvBNSH) {\n    return applyAttention(\n        context, Q, key, value, keyPaddingMask, undefined, pastKey, pastValue, relativePositionBias, params,\n        attributes);\n  }\n  if (!key || !value) {\n    throw new Error('key and value must be provided');\n  }\n  const K = maybeTransposeToBNSHAndAddBias(\n      context, params.batchSize, params.numHeads, params.kvSequenceLength, params.headSize, key, bias,\n      params.hiddenSize);\n\n  const V = maybeTransposeToBNSHAndAddBias(\n      context, params.batchSize, params.numHeads, params.kvSequenceLength, params.vHeadSize, value, bias,\n      2 * params.hiddenSize);\n\n  applyAttention(\n      context, Q, K, V, keyPaddingMask, undefined, pastKey, pastValue, relativePositionBias, params, attributes);\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, IndicesHelper, inputVariable, outputVariable, ShaderHelper, UniformDataElementType, UniformsArrayType} from './common';\n\ninterface PadAttributes {\n  // 0-constant, 1-reflect, 2-edge, 3-wrap\n  readonly mode: number;\n  readonly value: number;\n  readonly pads: number[];\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length < 1) {\n    throw new Error('Too few inputs');\n  }\n  if (inputs[0].dataType !== DataType.float && inputs[0].dataType !== DataType.float16) {\n    throw new Error('Input type must be float or float16.');\n  }\n\n  if (inputs.length >= 2) {\n    let validPads = inputs[0].dims.length * 2 === inputs[1].dims[0];\n    if (inputs.length === 4) {\n      validPads = inputs[3].dims[0] * 2 === inputs[1].dims[0];\n    }\n    if (!validPads) {\n      throw new Error('The pads should be a 1D tensor of shape [2 * input_rank] or [2 * num_axes].');\n    }\n  }\n};\n\nconst getPadConstant = (output: IndicesHelper, inputRank: number, padsLength: number): string => {\n  let block = '';\n  for (let i = inputRank - 1; i >= 0; --i) {\n    block += `\n            k = i32(${output.indicesGet('indices', i)}) - ${getElementAt('uniforms.pads', i, padsLength)};\n            if (k < 0) {\n              break;\n            }\n            if (k >= i32(${getElementAt('uniforms.x_shape', i, inputRank)})) {\n              break;\n            }\n            offset += k * i32(${getElementAt('uniforms.x_strides', i, inputRank)});\n        `;\n  }\n\n  return `\n          value = ${output.type.value}(uniforms.constant_value);\n          for (var i = 0; i < 1; i++) {\n            var offset = 0;\n            var k = 0;\n            ${block}\n            value = x[offset];\n          }\n      `;\n};\n\nconst getPadReflect = (output: IndicesHelper, inputRank: number, padsLength: number): string => {\n  let block = '';\n  for (let i = inputRank - 1; i >= 0; --i) {\n    block += `\n                k = i32(${output.indicesGet('indices', i)}) - ${getElementAt('uniforms.pads', i, padsLength)};\n                if (k < 0) {\n                  k = -k;\n                }\n                {\n                  let _2n_1 = 2 * (i32(${getElementAt('uniforms.x_shape', i, inputRank)}) - 1);\n                  k = k % _2n_1;\n                  if(k >= i32(${getElementAt('uniforms.x_shape', i, inputRank)})) {\n                    k = _2n_1 - k;\n                  }\n                }\n                offset += k * i32(${getElementAt('uniforms.x_strides', i, inputRank)});\n            `;\n  }\n\n  return `\n              var offset = 0;\n              var k = 0;\n              ${block}\n              value = x[offset];\n          `;\n};\n\nconst getPadEdge = (output: IndicesHelper, inputRank: number, padsLength: number): string => {\n  let block = '';\n  for (let i = inputRank - 1; i >= 0; --i) {\n    block += `\n                k = i32(${output.indicesGet('indices', i)}) - ${getElementAt('uniforms.pads', i, padsLength)};\n                if (k < 0) {\n                  k = 0;\n                }\n                if (k >= i32(${getElementAt('uniforms.x_shape', i, inputRank)})) {\n                  k = i32(${getElementAt('uniforms.x_shape', i, inputRank)}) - 1;\n                }\n                offset += k * i32(${getElementAt('uniforms.x_strides', i, inputRank)});\n            `;\n  }\n\n  return `\n              var offset = 0;\n              var k = 0;\n              ${block}\n              value = x[offset];\n          `;\n};\n\nconst getPadWrap = (output: IndicesHelper, inputRank: number, padsLength: number): string => {\n  let block = '';\n  for (let i = inputRank - 1; i >= 0; --i) {\n    block += `\n                k = i32(${output.indicesGet('indices', i)}) - ${getElementAt('uniforms.pads', i, padsLength)};\n                if (k < 0)  {\n                  k += i32(${getElementAt('uniforms.x_shape', i, inputRank)}]);\n                }\n                if (k >= i32(${getElementAt('uniforms.x_shape', i, inputRank)})) {\n                  k -= i32(${getElementAt('uniforms.x_shape', i, inputRank)});\n                }\n                offset += k * i32(${getElementAt('uniforms.x_strides', i, inputRank)});\n            `;\n  }\n\n  return `\n              var offset = 0;\n              var k = 0;\n              ${block}\n              value = x[offset];\n          `;\n};\n\nconst getPadSnippet = (output: IndicesHelper, inputRank: number, attributes: PadAttributes): string => {\n  switch (attributes.mode) {\n    case 0:\n      return getPadConstant(output, inputRank, attributes.pads.length);\n    case 1:\n      return getPadReflect(output, inputRank, attributes.pads.length);\n    case 2:\n      return getPadEdge(output, inputRank, attributes.pads.length);\n    case 3:\n      return getPadWrap(output, inputRank, attributes.pads.length);\n    default:\n      throw new Error('Invalid mode');\n  }\n};\n\nconst createPadProgramInfo = (inputs: readonly TensorView[], attributes: PadAttributes): ProgramInfo => {\n  const outputShape = ShapeUtil.padShape(inputs[0].dims.slice(), attributes.pads);\n  const inputDims = inputs[0].dims;\n  const outputSize = ShapeUtil.size(outputShape);\n  const programUniforms: ProgramUniform[] =\n      [{type: DataType.uint32, data: outputSize}, {type: DataType.int32, data: attributes.pads}];\n  if (attributes.mode === 0) {\n    programUniforms.push({type: inputs[0].dataType, data: attributes.value});\n  }\n\n  programUniforms.push(...createTensorShapeVariables(inputs[0].dims, outputShape));\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank'];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n    const input = inputVariable('x', inputs[0].dataType, inputDims.length);\n    const dataType = input.type.value;\n    const padSnippet = getPadSnippet(output, inputDims.length, attributes);\n    const uniforms: UniformsArrayType =\n        [{name: 'output_size', type: 'u32'}, {name: 'pads', type: 'i32', length: attributes.pads.length}];\n    if (attributes.mode === 0) {\n      uniforms.push({name: 'constant_value', type: dataType as UniformDataElementType});\n    }\n\n    return `\n            ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)}\n            ${shaderHelper.mainStart()}\n            ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n            let indices = ${output.offsetToIndices('global_idx')};\n\n            var value = ${dataType}(0);\n            ${padSnippet}\n            output[global_idx] = value;\n        }`;\n  };\n\n  return {\n    name: 'Pad',\n    shaderCache: {hint: `${attributes.mode}`, inputDependencies},\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(ShapeUtil.size(outputShape) / 64 /* workgroup size */)},\n      programUniforms\n    }),\n    getShaderSource,\n  };\n};\n\nconst createPadAttributesFromInputs = (inputs: readonly TensorView[], attributes: PadAttributes): PadAttributes => {\n  if (inputs.length > 1) {\n    const bigInt64Pads = inputs[1].getBigInt64Array();\n    const value = (inputs.length >= 3 && inputs[2].data) ? inputs[2].getFloat32Array()[0] : 0.0;\n\n    const inputRank = inputs[0].dims.length;\n    const updatePads = new Int32Array(2 * inputRank).fill(0);\n    if (inputs.length >= 4) {\n      const axes = inputs[3].getBigInt64Array();\n      for (let i = 0; i < axes.length; i++) {\n        updatePads[Number(axes[i])] = Number(bigInt64Pads[i]);\n        updatePads[Number(axes[i]) + inputRank] = Number(bigInt64Pads[i + axes.length]);\n      }\n    } else {\n      bigInt64Pads.forEach((v, i) => updatePads[Number(i)] = (Number(v)));\n    }\n\n    const pads: number[] = [];\n    updatePads.forEach(v => pads.push(v));\n\n    return {mode: attributes.mode, value, pads};\n  } else {\n    return attributes;\n  }\n};\n\nexport const pad = (context: ComputeContext, attributes: PadAttributes): void => {\n  validateInputs(context.inputs);\n  const updatedAttributes = createPadAttributesFromInputs(context.inputs, attributes);\n  context.compute(createPadProgramInfo(context.inputs, updatedAttributes), {inputs: [0]});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {env} from 'onnxruntime-common';\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {PoolConvUtil, ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, IndicesHelper, inputVariable, outputVariable, ShaderHelper, UniformsArrayType} from './common';\n\n// TODO: support:\n// - ceil_mode                 \"test_maxpool_2d_ceil\"\n// - storage_order             \"test_maxpool_with_argmax_2d_precomputed_strides\"\n// - [MaxPool] dilations       \"test_maxpool_2d_dilations\"\n// - [MaxPool] output[1]       \"test_maxpool_with_argmax_2d_precomputed_pads\"\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (env.webgpu.validateInputContent && (!inputs || inputs.length !== 1)) {\n    throw new Error('Pool ops requires 1 input.');\n  }\n};\n\nconst getAdjustedPoolAttributesAndOutputShape = <AttributeType extends AveragePoolAttributes|MaxPoolAttributes>(\n    input: TensorView, attributes: AttributeType, isGlobalOperator: boolean): [AttributeType, number[]] => {\n  const isChannelsLast = attributes.format === 'NHWC';\n  const inputShapeAsChannelFirst = input.dims.slice();\n  if (isChannelsLast) {\n    inputShapeAsChannelFirst.splice(1, 0, inputShapeAsChannelFirst.pop()!);  // Move channel to the second position.\n  }\n  const hasDilations = Object.hasOwnProperty.call(attributes, 'dilations');\n  const kernelShape = attributes.kernelShape.slice();\n  const strides = attributes.strides.slice();\n  const dilations: number[] = hasDilations ? (attributes as MaxPoolAttributes).dilations.slice() : [];\n  const pads = attributes.pads.slice();\n  PoolConvUtil.adjustPoolAttributes(isGlobalOperator, inputShapeAsChannelFirst, kernelShape, strides, dilations, pads);\n\n  const outputShapeAsChannelFirst = PoolConvUtil.computePoolOutputShape(\n      isGlobalOperator, inputShapeAsChannelFirst, strides, dilations, kernelShape, pads, attributes.autoPad);\n\n  const newAttributes = Object.assign({}, attributes);\n  if (hasDilations) {\n    Object.assign(newAttributes, {kernelShape, strides, pads, dilations, cacheKey: attributes.cacheKey});\n  } else {\n    Object.assign(newAttributes, {kernelShape, strides, pads, cacheKey: attributes.cacheKey});\n  }\n  const outputShapeAsChannelLast = outputShapeAsChannelFirst.slice();\n  outputShapeAsChannelLast.push(outputShapeAsChannelLast.splice(1, 1)[0]);\n  return [newAttributes, isChannelsLast ? outputShapeAsChannelLast : outputShapeAsChannelFirst];\n};\n\nconst getUniformAndPadInfo = <AttributeType extends AveragePoolAttributes|MaxPoolAttributes>(\n    outputShape: readonly number[],\n    attributes: AttributeType): [ProgramUniform[], UniformsArrayType, boolean, boolean, boolean] => {\n  const isChannelsLast = attributes.format === 'NHWC';\n  const outputSize = ShapeUtil.size(outputShape);\n  const kernelSize = ShapeUtil.size(attributes.kernelShape);\n  const programUniforms: ProgramUniform[] =\n      [{type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: kernelSize}];\n  const uniforms: UniformsArrayType = [{name: 'outputSize', type: 'u32'}, {name: 'kernelSize', type: 'u32'}];\n  if (attributes.kernelShape.length <= 2) {\n    const kw = attributes.kernelShape[attributes.kernelShape.length - 1];\n    const sw = attributes.strides[attributes.strides.length - 1];\n    const pwStart = attributes.pads[attributes.pads.length / 2 - 1];\n    const pwEnd = attributes.pads[attributes.pads.length - 1];\n    const pwStartEndNotZero = !!(pwStart + pwEnd);\n    programUniforms.push(\n        {type: DataType.uint32, data: kw},\n        {type: DataType.uint32, data: sw},\n        {type: DataType.uint32, data: pwStart},\n        {type: DataType.uint32, data: pwEnd},\n    );\n    uniforms.push(\n        {name: 'kw', type: 'u32'}, {name: 'sw', type: 'u32'}, {name: 'pwStart', type: 'u32'},\n        {name: 'pwEnd', type: 'u32'});\n\n    let phStartEndNotZero = false;\n    if (attributes.kernelShape.length === 2) {\n      const kh = attributes.kernelShape[attributes.kernelShape.length - 2];\n      const sh = attributes.strides[attributes.strides.length - 2];\n      const phStart = attributes.pads[attributes.pads.length / 2 - 2];\n      const phEnd = attributes.pads[attributes.pads.length - 2];\n      phStartEndNotZero = !!(phStart + phEnd);\n      programUniforms.push(\n          {type: DataType.uint32, data: kh}, {type: DataType.uint32, data: sh}, {type: DataType.uint32, data: phStart},\n          {type: DataType.uint32, data: phEnd});\n\n      uniforms.push(\n          {name: 'kh', type: 'u32'}, {name: 'sh', type: 'u32'}, {name: 'phStart', type: 'u32'},\n          {name: 'phEnd', type: 'u32'});\n    }\n    return [programUniforms, uniforms, true, pwStartEndNotZero, phStartEndNotZero];\n  } else {\n    if (isChannelsLast) {\n      throw new Error('Pooling with kernelShape.length > 2 is not supported for NHWC format.');\n    }\n    const kernelStrides = ShapeUtil.computeStrides(attributes.kernelShape);\n    programUniforms.push(\n        {type: DataType.uint32, data: kernelStrides}, {type: DataType.uint32, data: attributes.pads},\n        {type: DataType.uint32, data: attributes.strides});\n    uniforms.push(\n        {name: 'kernelStrides', type: 'u32', length: kernelStrides.length},\n        {name: 'pads', type: 'u32', length: attributes.pads.length},\n        {name: 'strides', type: 'u32', length: attributes.strides.length});\n\n    const hasPads = attributes.pads.reduce((sum, cur) => sum + cur);\n    return [programUniforms, uniforms, !!hasPads, false, false];\n  }\n};\n\nconst generatePoolingCode = <AttributeType extends AveragePoolAttributes|MaxPoolAttributes>(\n    shaderHelper: ShaderHelper, x: IndicesHelper, rank: number, outputShapeRank: number, attributes: AttributeType,\n    op1: string, op2: string, start: number, uniforms: UniformsArrayType, hasPads: boolean, pwStartEndNotZero: boolean,\n    phStartEndNotZero: boolean): string => {\n  const isChannelsLast = attributes.format === 'NHWC';\n  const dataType = x.type.value;\n  const output = outputVariable('output', x.type.tensor, outputShapeRank);\n\n  if (attributes.kernelShape.length <= 2) {\n    let codeW = '';\n    let codeH = '';\n    let codeHEnd = '';\n    const dimIdxW = rank - (isChannelsLast ? 2 : 1);\n    if (pwStartEndNotZero) {\n      codeW = `\n                for (var i: u32 = 0u; i < uniforms.kw; i++) {\n                  xIndices[${dimIdxW}] = indices[${dimIdxW}] * uniforms.sw - uniforms.pwStart + i;\n                  if (xIndices[${dimIdxW}] < 0 || xIndices[${dimIdxW}]\n                      >= uniforms.x_shape[${dimIdxW}]) {\n                    pad++;\n                    continue;\n                  }\n                  let x_val = x[${x.indicesToOffset('xIndices')}];\n                  ${op1}\n                }`;\n    } else {\n      codeW = `\n                for (var i: u32 = 0u; i < uniforms.kw; i++) {\n                  xIndices[${dimIdxW}] = indices[${dimIdxW}] * uniforms.sw - uniforms.pwStart + i;\n                  let x_val = x[${x.indicesToOffset('xIndices')}];\n                  ${op1}\n                }`;\n    }\n\n    if (attributes.kernelShape.length === 2) {\n      const dimIdxH = rank - (isChannelsLast ? 3 : 2);\n      if (phStartEndNotZero) {\n        codeH = `\n                for (var j: u32 = 0u; j < uniforms.kh; j++) {\n                  xIndices[${dimIdxH}] = indices[${dimIdxH}] * uniforms.sh - uniforms.phStart + j;\n                  if (xIndices[${dimIdxH}] < 0 || xIndices[${dimIdxH}] >= uniforms.x_shape[${dimIdxH}]) {\n                    pad += i32(uniforms.kw);\n                    continue;\n                  }\n              `;\n      } else {\n        codeH = `\n                for (var j: u32 = 0u; j < uniforms.kh; j++) {\n                  xIndices[${dimIdxH}] = indices[${dimIdxH}] * uniforms.sh - uniforms.phStart + j;\n                `;\n      }\n      codeHEnd = `\n              }\n            `;\n    }\n\n    const poolingCode = `\n            ${shaderHelper.registerUniforms(uniforms).declareVariables(x, output)}\n\n            ${shaderHelper.mainStart()}\n              ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n\n              let indices = ${output.offsetToIndices('global_idx')};\n              var xIndices = ${output.offsetToIndices('global_idx')};\n\n              var value = ${dataType}(${start});\n              var pad = 0;\n              ${codeH}\n              ${codeW}\n              ${codeHEnd}\n              ${op2}\n\n              output[global_idx] = value;\n            }`;\n    return poolingCode;\n  } else {\n    if (isChannelsLast) {\n      throw new Error('Pooling with kernelShape.length > 2 is not supported for NHWC format.');\n    }\n    const stridesRank = attributes.kernelShape.length;\n    const padsRank = attributes.pads.length;\n    let padCode = '';\n    if (hasPads) {\n      padCode = `\n                if (xIndices[j] >= uniforms.x_shape[j]) {\n                  pad++;\n                  isPad = true;\n                  break;\n                }\n              }\n              if (!isPad) {\n                let x_val = x[${x.indicesToOffset('xIndices')}];\n                ${op1}\n              }`;\n    } else {\n      padCode = `\n              }\n              let x_val = x[${x.indicesToOffset('xIndices')}];\n              ${op1}\n            `;\n    }\n    const poolingCode = `\n            ${shaderHelper.registerUniforms(uniforms).declareVariables(x, output)}\n\n            ${shaderHelper.mainStart()}\n              ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n              let indices = ${output.offsetToIndices('global_idx')};\n              var xIndices = ${output.offsetToIndices('global_idx')};\n\n              var offsets: array<u32, ${stridesRank}>;\n\n              var value = ${dataType}(${start});\n              var pad = 0;\n              var isPad = false;\n\n              for (var i: u32 = 0u; i < uniforms.kernelSize; i++) {\n                var offset = i;\n                for (var j = 0u; j < ${stridesRank - 1}u; j++) {\n                  offsets[j] = offset / ${getElementAt('uniforms.kernelStrides', 'j', stridesRank)};\n                  offset -= offsets[j] * ${getElementAt('uniforms.kernelStrides', 'j', stridesRank)};\n                }\n                offsets[${stridesRank - 1}] = offset;\n\n                isPad = false;\n                for (var j = ${rank - stridesRank}u; j < ${rank}u; j++) {\n                  xIndices[j] = indices[j] * ${\n        getElementAt('uniforms.strides', `j - ${rank - stridesRank}u`, stridesRank)}\n                    + offsets[j - ${rank - stridesRank}u] - ${getElementAt('uniforms.pads', 'j - 2u', padsRank)};\n                  ${padCode}\n              }\n              ${op2}\n\n              output[global_idx] = value;\n            }`;\n    return poolingCode;\n  }\n};\n\nexport interface FormatAttributes {\n  readonly format: 'NHWC'|'NCHW';\n}\n\nexport interface PoolCommonAttributes extends FormatAttributes {\n  readonly autoPad: string;\n  readonly ceilMode: number;\n  readonly kernelShape: readonly number[];\n  readonly strides: readonly number[];\n  readonly pads: readonly number[];\n}\n\nconst createShaderKeyFromAttributes = (attributes: PoolCommonAttributes): string =>\n    (`${attributes.format};${attributes.ceilMode};${attributes.autoPad};${attributes.kernelShape.length}`);\n\nconst createAveragePoolShaderKeyFromAttributes = (attributes: AveragePoolAttributes): string =>\n    (`${createShaderKeyFromAttributes(attributes)};${attributes.countIncludePad}`);\n\nconst createMaxPoolShaderKeyFromAttributes = (attributes: MaxPoolAttributes): string =>\n    (`${createShaderKeyFromAttributes(attributes)};${attributes.storageOrder};${attributes.dilations}`);\n\nconst parsePoolCommonAttributes = (attributes: Record<string, unknown>): PoolCommonAttributes => ({\n  format: attributes.format as FormatAttributes['format'],\n  autoPad: ['NOTSET', 'VALID', 'SAME_UPPER', 'SAME_LOWER'][attributes.auto_pad as number],\n  ceilMode: attributes.ceil_mode as number,\n  kernelShape: attributes.kernel_shape as [number, number],\n  strides: attributes.strides as [number, number],\n  pads: attributes.pads as [number, number, number, number]\n});\n\nexport interface AveragePoolAttributes extends PoolCommonAttributes, AttributeWithCacheKey {\n  readonly countIncludePad: boolean;\n}\n\nconst createAveragePoolProgramInfo =\n    (name: string, input: TensorView, isGlobalOperator: boolean, attributes: AveragePoolAttributes): ProgramInfo => {\n      const [adjustedAttributes, outputShape] =\n          getAdjustedPoolAttributesAndOutputShape(input, attributes, isGlobalOperator);\n      const x = inputVariable('x', input.dataType, input.dims.length);\n      const dataType = x.type.value;\n\n      const op1 = 'value += x_val;';\n      let op2 = '';\n      if (adjustedAttributes.countIncludePad) {\n        op2 += `value /= ${dataType}(uniforms.kernelSize);`;\n      } else {\n        op2 += `value /= ${dataType}(i32(uniforms.kernelSize) - pad);`;\n      }\n      const [programUniforms, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero] =\n          getUniformAndPadInfo(outputShape, adjustedAttributes);\n      programUniforms.push(...createTensorShapeVariables(input.dims, outputShape));\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank'];\n      return {\n        name,\n        shaderCache:\n            {hint: `${attributes.cacheKey};${hasPads};${pwStartEndNotZero};${phStartEndNotZero}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: input.dataType}],\n          dispatchGroup: {x: Math.ceil(ShapeUtil.size(outputShape) / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource: shaderHelper => generatePoolingCode(\n            shaderHelper, x, input.dims.length, outputShape.length, adjustedAttributes, op1, op2, 0.0, uniforms,\n            hasPads, pwStartEndNotZero, phStartEndNotZero),\n      };\n    };\n\nexport const parseAveragePoolAttributes = (attributes: Record<string, unknown>): AveragePoolAttributes => {\n  const countIncludePad = (attributes.count_include_pad as number) === 0 ? false : true;\n\n  const attr = parsePoolCommonAttributes(attributes);\n  // TODO: support attribute 'ceil_mode'\n  if (attr.ceilMode !== 0) {\n    throw new Error('using ceil() in shape computation is not yet supported for AveragePool');\n  }\n  const averagePoolAttributes = {countIncludePad, ...attr, cacheKey: ''};\n  return {...averagePoolAttributes, cacheKey: createAveragePoolShaderKeyFromAttributes(averagePoolAttributes)};\n};\n\nexport const averagePool = (context: ComputeContext, attributes: AveragePoolAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createAveragePoolProgramInfo('AveragePool', context.inputs[0], false, attributes));\n};\n\nconst globalPoolAttributes = {\n  autoPad: '',\n  ceilMode: 0,\n  countIncludePad: false,\n  kernelShape: [],\n  strides: [],\n  pads: [],\n  storageOrder: 0,\n  dilations: []\n};\n\nexport const parseGlobalAveragePoolAttributes = (attributes: Record<string, unknown>): AveragePoolAttributes => {\n  const format = attributes.format as FormatAttributes['format'];\n  return {format, ...globalPoolAttributes, cacheKey: format};\n};\n\nexport const globalAveragePool = (context: ComputeContext, attributes: AveragePoolAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createAveragePoolProgramInfo('GlobalAveragePool', context.inputs[0], true, attributes));\n};\n\nexport interface MaxPoolAttributes extends PoolCommonAttributes, AttributeWithCacheKey {\n  readonly storageOrder: number;\n  readonly dilations: number[];\n}\n\nconst createMaxPoolProgramInfo =\n    (name: string, input: TensorView, isGlobalOperator: boolean, attributes: MaxPoolAttributes): ProgramInfo => {\n      const [adjustedAttributes, outputShape] =\n          getAdjustedPoolAttributesAndOutputShape(input, attributes, isGlobalOperator);\n      const op1 = `\n      value = max(x_val, value);\n    `;\n      const op2 = '';\n      const x = inputVariable('x', input.dataType, input.dims.length);\n      const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank'];\n      const [programUniforms, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero] =\n          getUniformAndPadInfo(outputShape, adjustedAttributes);\n      programUniforms.push(...createTensorShapeVariables(input.dims, outputShape));\n      return {\n        name,\n        shaderCache:\n            {hint: `${attributes.cacheKey};${hasPads};${pwStartEndNotZero};${phStartEndNotZero}`, inputDependencies},\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: input.dataType}],\n          dispatchGroup: {x: Math.ceil(ShapeUtil.size(outputShape) / 64 /* workgroup size */)},\n          programUniforms\n        }),\n        getShaderSource: shaderHelper => generatePoolingCode(\n            shaderHelper, x, input.dims.length, outputShape.length, adjustedAttributes, op1, op2,\n            (input.dataType === DataType.float16) ? -65504 : -1e5, uniforms, hasPads, pwStartEndNotZero,\n            phStartEndNotZero),\n      };\n    };\n\nexport const maxPool = (context: ComputeContext, attributes: MaxPoolAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createMaxPoolProgramInfo('MaxPool', context.inputs[0], false, attributes));\n};\n\nexport const parseMaxPoolAttributes = (attributes: Record<string, unknown>): MaxPoolAttributes => {\n  const storageOrder = attributes.storage_order as number;\n  const dilations = attributes.dilations as [number, number];\n\n  const attr = parsePoolCommonAttributes(attributes);\n  // TODO: support attribute 'ceil_mode' and 'storage_order'\n  if (storageOrder !== 0) {\n    throw new Error('column major storage order is not yet supported for MaxPool');\n  }\n  if (attr.ceilMode !== 0) {\n    throw new Error('using ceil() in shape computation is not yet supported for MaxPool');\n  }\n  const maxPoolAttributes = {storageOrder, dilations, ...attr, cacheKey: ''};\n  return {...maxPoolAttributes, cacheKey: createMaxPoolShaderKeyFromAttributes(maxPoolAttributes)};\n};\n\nexport const parseGlobalMaxPoolAttributes = (attributes: Record<string, unknown>): MaxPoolAttributes => {\n  const format = attributes.format as FormatAttributes['format'];\n  return {format, ...globalPoolAttributes, cacheKey: format};\n};\n\nexport const globalMaxPool = (context: ComputeContext, attributes: MaxPoolAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createMaxPoolProgramInfo('GlobalMaxPool', context.inputs[0], true, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {env} from 'onnxruntime-common';\n\nimport {DataType} from '../../../wasm-common';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, outputVariable, ShaderHelper, UniformDataElementType, UniformsArrayType} from './common';\n\nconst validateInputsContent = (start: number, limit: number, delta: number): void => {\n  const sameStartLimit = start === limit;\n  const increasingRangeNegativeStep = start < limit && delta < 0;\n  const decreasingRangePositiveStep = start > limit && delta > 0;\n\n  if (sameStartLimit || increasingRangeNegativeStep || decreasingRangePositiveStep) {\n    throw new Error('Range these inputs\\' contents are invalid.');\n  }\n};\n\nconst createRangeProgramInfo = (start: number, limit: number, delta: number, dataType: DataType): ProgramInfo => {\n  const numElements = Math.abs(Math.ceil((limit - start) / delta));\n  const outputShape: number[] = [numElements];\n  const outputSize = numElements;\n  const programUniforms: ProgramUniform[] = [\n    {type: DataType.uint32, data: outputSize}, {type: dataType, data: start}, {type: dataType, data: delta},\n    ...createTensorShapeVariables(outputShape)\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const output = outputVariable('output', dataType, outputShape.length);\n    const wgslType = output.type.value;\n    const uniforms: UniformsArrayType = [\n      {name: 'outputSize', type: 'u32'}, {name: 'start', type: wgslType as UniformDataElementType},\n      {name: 'delta', type: wgslType as UniformDataElementType}\n    ];\n    return `\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(output)}\n        ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n        output[global_idx] = uniforms.start + ${wgslType}(global_idx) * uniforms.delta;\n      }`;\n  };\n\n  return {\n    name: 'Range',\n    shaderCache: {hint: `${dataType}`},\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n      programUniforms\n    })\n  };\n};\n\nexport const range = (context: ComputeContext): void => {\n  let start = 0;\n  let limit = 0;\n  let delta = 0;\n  if (context.inputs[0].dataType === DataType.int32) {\n    start = context.inputs[0].getInt32Array()[0];\n    limit = context.inputs[1].getInt32Array()[0];\n    delta = context.inputs[2].getInt32Array()[0];\n  } else if (context.inputs[0].dataType === DataType.float) {\n    start = context.inputs[0].getFloat32Array()[0];\n    limit = context.inputs[1].getFloat32Array()[0];\n    delta = context.inputs[2].getFloat32Array()[0];\n  }\n  if (env.webgpu.validateInputContent) {\n    validateInputsContent(start, limit, delta);\n  }\n\n  context.compute(createRangeProgramInfo(start, limit, delta, context.inputs[0].dataType), {inputs: []});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\n\ntype CoordinateTransformMode = 'half_pixel'|'asymmetric'|'pytorch_half_pixel'|'tf_half_pixel_for_nn'|'align_corners'|\n    'tf_crop_and_resize'|'half_pixel_symmetric';\n\ntype KeepAspectRatioPolicy = 'stretch'|'not_smaller'|'not_larger';\n\ntype Mode = 'nearest'|'linear'|'cubic';\n\ntype NearestMode = 'round_prefer_floor'|'round_prefer_ceil'|'floor'|'ceil'|'simple';\n\nexport interface ResizeAttributes extends AttributeWithCacheKey {\n  antialias: number;\n  axes: number[];\n  coordinateTransformMode: CoordinateTransformMode;\n  cubicCoeffA: number;\n  excludeOutside: boolean;\n  extrapolationValue: number;\n  keepAspectRatioPolicy: KeepAspectRatioPolicy;\n  mode: Mode;\n  nearestMode: NearestMode;\n}\n\nconst validateScales = (scales: number[], attributes: ResizeAttributes): void => {\n  scales.every((value) => value > 0 || (() => {\n                            throw new Error('Resize requires scales input values to be positive');\n                          }));\n  // Check scales dims based on mode: LINEAR, CUBIC\n  if (scales.length > 0) {\n    if (attributes.mode === 'linear') {\n      if (!(scales.length === 2 || scales.length === 3 || (scales.length === 4 && scales[0] === 1 && scales[1] === 1) ||\n            (scales.length === 4 && scales[0] === 1 && scales[3] === 1) ||\n            (scales.length === 5 && scales[0] === 1 && scales[1] === 1))) {\n        throw new Error(\n            `For linear mode, Resize requires scales to be 2D, 3D, 4D with either two outermost or one innermost and\n            one outermost scale values equal to 1, or 5D with two outermost scale values equal to 1`);\n      }\n    } else if (attributes.mode === 'cubic') {\n      if (!(scales.length === 2 || (scales.length === 4 && scales[0] === 1 && scales[1] === 1) ||\n            (scales.length === 4 && scales[0] === 1 && scales[3] === 1))) {\n        throw new Error('Resize requires scales input size to be 2 or 4 for cubic mode');\n      }\n    }\n  }\n};\n\nconst updateScales = (scales: readonly number[], axes: readonly number[], rank: number): number[] => {\n  axes.every((value) => value >= 0 && value < rank || (() => {\n                          throw new Error('Resize requires axes input values to be positive and less than rank');\n                        }));\n  const newScales = new Array(rank).fill(1.0);\n  axes.forEach((value, index) => newScales[value] = scales[index]);\n  return newScales;\n};\n\nconst validateInputs =\n    (inputs: readonly TensorView[], attributes: ResizeAttributes, opsetVersion: number, scales: number[],\n     sizes: number[], roi: number[]): void => {\n      const [roiInputIndex, scalesInputIndex, sizesInputIndex] =\n          (opsetVersion > 10) ? [1, 2, 3] : [-1, (inputs.length > 1) ? 1 : -1, -1];\n      const rank = inputs[0].dims.length;\n      if (roiInputIndex > 0 && inputs.length > roiInputIndex && inputs[roiInputIndex].dims.length > 0) {\n        inputs[roiInputIndex].getFloat32Array().forEach((value) => roi.push(value));\n      } else if (attributes.coordinateTransformMode === 'tf_crop_and_resize') {\n        throw new Error('Resize requires RoI input to be specified when coordinateTransformMode is tfCropAndResize');\n      }\n\n      if (scalesInputIndex > 0 && inputs.length > scalesInputIndex && inputs[scalesInputIndex].dims.length > 0) {\n        inputs[scalesInputIndex].getFloat32Array().forEach((value) => scales.push(value));\n        if (scales.length !== 0 &&\n            (scales.length !== rank && (opsetVersion >= 18 && scales.length !== attributes.axes.length))) {\n          throw new Error(\n              'Resize requires scales input size to be same as input rank or axes size for opset 18 and up');\n        }\n        validateScales(scales, attributes);\n        if (attributes.axes.length > 0) {\n          updateScales(scales, attributes.axes, rank).forEach((value, index) => scales[index] = value);\n        }\n      }\n      if (sizesInputIndex > 0 && inputs.length > sizesInputIndex) {\n        inputs[sizesInputIndex].getBigInt64Array().forEach((value) => sizes.push(Number(value)));\n        if (sizes.length !== rank || (opsetVersion >= 18 && sizes.length === attributes.axes.length)) {\n          throw new Error('Resize requires sizes input size to be same as input rank or axes size for opset 18 and up');\n        }\n      }\n\n      if (attributes.axes.length > 0) {\n        if (scales.length !== attributes.axes.length) {\n          throw new Error('Resize requires \"scales\" input size to be of axes rank when axes attributes is specified');\n        }\n        if (sizes.length !== attributes.axes.length) {\n          throw new Error(\n              'Resize requires \"sizes\" input size to be of rank axes rank when axes attributes is specified');\n        }\n      }\n      if (typeof scales !== 'undefined' && typeof sizes !== 'undefined' && scales.length > 0 && sizes.length > rank) {\n        throw new Error('Resize requires only of scales or sizes to be specified');\n      }\n    };\n\nconst getOriginalCoordinateFromResizedCoordinate =\n    (coordinateTransferMode: CoordinateTransformMode, dType: string): string =>\n        `fn getOriginalCoordinateFromResizedCoordinate(xResized: u32, xScale: f32, lengthResized: u32,\n     lengthOriginal: u32, roiStart: f32, roiEnd: f32) -> ${dType} { ` +\n    (() => {\n          switch (coordinateTransferMode) {\n            case 'asymmetric':\n              return `return ${dType}(xResized) / ${dType}(xScale);`;\n            case 'pytorch_half_pixel':\n              return `if (lengthResized > 1) {\n                    return (${dType}(xResized) + 0.5) / ${dType}(xScale) - 0.5;\n                  } else {\n                    return 0.0;\n                  }`;\n            case 'tf_half_pixel_for_nn':\n              return `return (${dType}(xResized) + 0.5) / ${dType}(xScale);`;\n            case 'align_corners':\n              return `if (lengthResized == 1) {\n                    return 0.0;\n                  } else {\n                    // The whole part and the fractional part are calculated separately due to inaccuracy of floating\n                    // point division. As an example, f32(21) / f32(7) may evaluate to 2.99... instead of 3, causing an\n                    // offset-by-one error later in floor().\n                    let whole = ${dType}(xResized * (lengthOriginal - 1) / (lengthResized - 1));\n                    let fract =\n                        ${dType}(xResized * (lengthOriginal - 1) % (lengthResized - 1)) / ${dType}(lengthResized - 1);\n                    return whole + fract;\n                  }`;\n            case 'tf_crop_and_resize':\n              return `if (lengthResized > 1) {\n                    return ${dType}(roiStart) * ${dType}(lengthOriginal - 1) +\n                        (${dType}(xResized) * ${dType}(roiEnd - roiStart) * ${dType}(lengthOriginal - 1)) /\n                        ${dType}(lengthResized - 1);\n                  } else {\n                    return 0.5 * ${dType}(roiStart + roiEnd) * ${dType}(lengthOriginal - 1);\n                  }`;\n            case 'half_pixel_symmetric':\n              return `const outputWidth = ${dType}xScale * ${dType}(lengthResized);\n                  const adjustment = ${dType}(lengthResized) / outputWidth;\n                  const center = ${dType}(lengthOriginal) / 2;\n                  const offset = center * (1 - adjustment);\n                  return offset + ((${dType}(xResized) + 0.5) / ${dType}(xScale)) - 0.5;`;\n            case 'half_pixel':\n              return `return ((${dType}(xResized) + 0.5) / ${dType}(xScale)) - 0.5;`;\n            default:\n              throw new Error(`Coordinate transform mode ${coordinateTransferMode} is not supported`);\n          }\n        })() +\n    '}';\n\nconst getNearestPixelFromOriginal = (nearestMode: NearestMode, opsetVersion: number, dType: string): string =>\n    `fn getNearestPixelFromOriginal(xOriginal: ${dType}, isDownSample: bool) -> ${dType} {` + (() => {\n      switch (nearestMode) {\n        case 'round_prefer_ceil':\n          return 'if (fract(xOriginal) == 0.5) { \\\n            return ceil(xOriginal); \\\n          } else { \\\n            return round(xOriginal); \\\n          }';\n        case 'floor':\n          return 'return floor(xOriginal);';\n        case 'ceil':\n          return 'return ceil(xOriginal);';\n        case 'round_prefer_floor':\n          return 'if (fract(xOriginal) == 0.5) { \\\n                    return floor(xOriginal); \\\n                  } else { \\\n                    return round(xOriginal); \\\n                  }';\n        case 'simple':\n        default:\n          if (opsetVersion < 11) {\n            return 'if (isDownSample) \\\n                    { \\\n                      return ceil(xOriginal); \\\n                    } else { \\\n                      return xOriginal; \\\n                    }';\n          }\n          throw new Error(`Nearest mode ${nearestMode} is not supported`);\n      }\n    })() +\n    '}';\n\nconst updateRoI = (roi: readonly number[], axes: readonly number[], rank: number): number[] => {\n  const roiTmp = new Array(rank).fill(0).concat(new Array(rank).fill(1));\n  const roiLocal = roi.length === 0 ? roiTmp : roi.slice();\n  if (axes.length > 0) {\n    axes.forEach((v, i) => {\n      roiTmp[v] = roiLocal[i];\n      roiTmp[i + rank] = roiLocal[axes.length + i];\n    });\n    return roiTmp;\n  }\n  return roiLocal;\n};\n\nconst initOutputShape =\n    (inputShape: readonly number[], scales: readonly number[], sizes: readonly number[], axes: readonly number[]):\n        number[] => {\n          let outputShape: number[] = [];\n          if (sizes.length > 0) {\n            if (axes.length > 0) {\n              inputShape.forEach((v) => outputShape.push(v));\n              if (Math.max(...axes) > inputShape.length) {\n                throw new Error('axes is out of bound');\n              }\n              axes.forEach((v, i) => outputShape[v] = sizes[i]);\n            } else {\n              sizes.forEach((v) => outputShape.push(v));\n            }\n          } else {\n            if (scales.length === 0) {\n              throw new Error('Resize requires either scales or sizes.');\n            } else {\n              outputShape = inputShape.map((value, index) => Math.round(value * scales[index]));\n            }\n          }\n          return outputShape;\n        };\n\nconst adjustOutputShape = (inputShape: readonly number[], scales: number[], attributes: ResizeAttributes) => {\n  const scaleInPolicy = (() => {\n    switch (attributes.keepAspectRatioPolicy) {\n      case 'not_larger':\n        return attributes.axes.length > 0 ? Math.min(...attributes.axes.map(i => scales[i]), Number.MAX_VALUE) :\n                                            Math.min(...scales, Number.MAX_VALUE);\n      case 'not_smaller':\n        return attributes.axes.length > 0 ? Math.max(...attributes.axes.map(i => scales[i]), Number.MIN_VALUE) :\n                                            Math.max(...scales, Number.MIN_VALUE);\n      default:\n        throw new Error(`Keep aspect ratio policy ${attributes.keepAspectRatioPolicy} is not supported`);\n    }\n  })();\n  scales.fill(1.0, 0, scales.length);\n  const adjustedOutputShape = inputShape.slice();\n  if (attributes.axes.length > 0) {\n    attributes.axes.forEach((v) => scales[v] = scaleInPolicy);\n    attributes.axes.forEach((v) => adjustedOutputShape[v] = Math.round(inputShape[v] * scales[v]));\n  } else {\n    scales.fill(scaleInPolicy, 0, scales.length);\n    adjustedOutputShape.forEach((v, i) => adjustedOutputShape[i] = Math.round(v * scales[i]));\n  }\n  return adjustedOutputShape;\n};\n\nconst calculateOriginalIndicesFromOutputIndices =\n    (output: IndicesHelper, inputShape: readonly number[], outputShape: readonly number[], scalesLength: number,\n     roiLength: number): string => `\n    fn calculateOriginalIndicesFromOutputIndices(output_indices: ${output.type.indices}) -> array<${\n        output.type.value}, ${outputShape.length}> {\n      var original_indices: array<${output.type.value}, ${outputShape.length}>;\n      for (var i:u32 = 0; i < ${outputShape.length}; i++) {\n        var output_index = ${output.indicesGet('output_indices', 'i')};\n        var scale = ${getElementAt('uniforms.scales', 'i', scalesLength)};\n        var roi_low = ${getElementAt('uniforms.roi', 'i', roiLength)};\n        var roi_hi = ${getElementAt('uniforms.roi', `i + ${inputShape.length}`, roiLength)};\n        if (scale == 1.0) {\n          original_indices[i] = ${output.type.value}(output_index);\n        } else {\n          var input_shape_i = ${getElementAt('uniforms.input_shape', 'i', inputShape.length)};\n          var output_shape_i = ${getElementAt('uniforms.output_shape', 'i', outputShape.length)};\n          original_indices[i] = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i,\n                                                                           input_shape_i, roi_low, roi_hi);\n        }\n      }\n      return original_indices;\n    }`;\n\nconst calculateInputIndicesFromOutputIndices =\n    (input: IndicesHelper, output: IndicesHelper, inputShape: readonly number[], outputShape: readonly number[],\n     scalesLength: number, roiLength: number, useExtrapolation: boolean): string => `\n    fn calculateInputIndicesFromOutputIndices(output_indices: ${output.type.indices}) -> ${input.type.indices} {\n      var input_indices: ${input.type.indices};\n      for (var i:u32 = 0; i < ${outputShape.length}; i++) {\n        var output_index = ${output.indicesGet('output_indices', 'i')};\n        var input_index: u32;\n        var scale = ${getElementAt('uniforms.scales', 'i', scalesLength)};\n        if (scale == 1.0) {\n          input_index = output_index;\n        } else {\n          var roi_low = ${getElementAt('uniforms.roi', 'i', roiLength)};\n          var roi_hi = ${getElementAt('uniforms.roi', `i + ${inputShape.length}`, roiLength)};\n          var input_shape_i = ${getElementAt('uniforms.input_shape', 'i', inputShape.length)};\n          var output_shape_i = ${getElementAt('uniforms.output_shape', 'i', outputShape.length)};\n          var original_idx = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i,\n                                                                        input_shape_i, roi_low, roi_hi);\n          if (!${useExtrapolation} || (original_idx >= 0 && original_idx < ${output.type.value}(input_shape_i))) {\n            if (original_idx < 0) {\n              input_index = 0;\n            } else if (original_idx > ${output.type.value}(input_shape_i - 1)) {\n              input_index = input_shape_i - 1;\n            } else {\n              input_index = u32(getNearestPixelFromOriginal(original_idx, scale < 1));\n            }\n          } else {\n            input_index = u32(original_idx);\n          }\n        }\n        ${input.indicesSet('input_indices', 'i', ' input_index')}\n      }\n      return input_indices;\n    }`;\nconst checkInputIndices = (input: IndicesHelper, inputShape: readonly number[]): string => `\n    fn checkInputIndices(input_indices: ${input.type.indices}) -> bool {\n      for (var i:u32 = 0; i < ${inputShape.length}; i++) {\n        var input_index = ${input.indicesGet('input_indices', 'i')};\n        if (input_index < 0 || input_index >= ${getElementAt('uniforms.input_shape', 'i', inputShape.length)}) {\n          return false;\n        }\n      }\n      return true;\n    }`;\n\nconst setChannelAndBatchIndices =\n    (input: IndicesHelper, channelIdx: number, batchIdx: number, spacialDims: number): string =>\n        input.rank > spacialDims ? `\n    ${input.indicesSet('input_indices', channelIdx, 'channel')};\n    ${input.indicesSet('input_indices', batchIdx, 'batch')};\n` :\n                                   '';\n\nconst bilinearInterpolation =\n    (input: IndicesHelper, output: IndicesHelper, inputShape: readonly number[], useExtrapolation: boolean,\n     extrapolationValue: number): string => {\n      const isNchw = true;\n      const [batchIdx, heightIdx, widthIdx, channelIdx] =\n          inputShape.length === 2 ? [-1, 0, 1, -1] : (isNchw ? [0, 2, 3, 1] : [0, 1, 2, 3]);\n      const dType = input.type.value;\n      return `\n    fn getInputValue(batch: u32, channel: u32, row: u32, col: u32) -> ${dType} {\n      var input_indices: ${input.type.indices};\n      ${input.indicesSet('input_indices', heightIdx, `max(0, min(row, ${inputShape[heightIdx]} - 1))`)};\n      ${input.indicesSet('input_indices', widthIdx, `max(0, min(col, ${inputShape[widthIdx]} - 1))`)};\n      ${setChannelAndBatchIndices(input, channelIdx, batchIdx, 2)}\n      return ${input.getByIndices('input_indices')};\n    }\n\n    fn bilinearInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n      var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices);\n      var row:${dType} = originalIndices[${heightIdx}];\n      var col:${dType} = originalIndices[${widthIdx}];\n      ${\n          useExtrapolation ?\n              `if (row < 0 || row > (${inputShape[heightIdx]} - 1) || col < 0 || col > (${inputShape[widthIdx]} - 1)) {\n        return ${extrapolationValue};\n      }` :\n              ''};\n      row = max(0, min(row, ${inputShape[heightIdx]} - 1));\n      col = max(0, min(col, ${inputShape[widthIdx]} - 1));\n      var row1: u32 = u32(row);\n      var col1: u32 = u32(col);\n      var row2: u32 = u32(row + 1);\n      var col2: u32 = u32(col + 1);\n      var channel: u32 = ${inputShape.length > 2 ? `u32(originalIndices[${channelIdx}])` : '0'};\n      var batch: u32 =  ${inputShape.length > 2 ? `u32(originalIndices[${batchIdx}])` : '0'};\n      var x11: ${dType} = getInputValue(batch, channel, row1, col1);\n      var x12: ${dType} = getInputValue(batch, channel, row1, col2);\n      var x21: ${dType} = getInputValue(batch, channel, row2, col1);\n      var x22: ${dType} = getInputValue(batch, channel, row2, col2);\n      var dx1: ${dType} = abs(row - ${dType}(row1));\n      var dx2: ${dType} = abs(${dType}(row2) - row);\n      var dy1: ${dType} = abs(col - ${dType}(col1));\n      var dy2: ${dType} = abs(${dType}(col2) - col);\n      if (row1 == row2) {\n        dx1 = 0.5;\n        dx2 = 0.5;\n      }\n      if (col1 == col2) {\n        dy1 = 0.5;\n        dy2 = 0.5;\n      }\n      return (x11 * dx2 * dy2 + x12 * dx2 * dy1 + x21 * dx1 * dy2 + x22 * dx1 * dy1);\n    }`;\n    };\n\nconst bicubicInterpolation =\n    (input: IndicesHelper, output: IndicesHelper, inputShape: readonly number[], outputShape: readonly number[],\n     scales: readonly number[], roi: readonly number[], cubicCoeffA: number, useExtrapolation: boolean,\n     extrapolationValue: number, excludeOutside: boolean): string => {\n      const is2D = inputShape.length === 2;\n      const isNchw = true;\n      const [heightIdx, widthIdx] = is2D ? [0, 1] : isNchw ? [2, 3] : [1, 2];\n      const dType = input.type.value;\n      const createCubicInterpolationFunction = (idx: number): string => {\n        const direction = idx === heightIdx ? 'row' : 'col';\n        return `\n      fn ${direction}CubicInterpolation(input_indices: ${input.type.indices}, output_indices: ${\n            output.type.indices}) -> ${dType} {\n        var output_index = ${output.indicesGet('output_indices', idx)};\n        var originalIdx: ${dType} = getOriginalCoordinateFromResizedCoordinate(output_index, ${scales[idx]},\n        ${outputShape[idx]}, ${inputShape[idx]}, ${roi[idx]}, ${roi[idx]} + ${inputShape.length});\n        var fractOriginalIdx: ${dType} = originalIdx - floor(originalIdx);\n        var coefs = getCubicInterpolationCoefs(fractOriginalIdx);\n\n        if (${useExtrapolation} && (originalIdx < 0 || originalIdx > (${inputShape[idx]} - 1))) {\n          return ${extrapolationValue};\n        }\n        var data: array<${dType}, 4> = array<${dType}, 4>(0.0, 0.0, 0.0, 0.0);\n        for (var i: i32 = -1; i < 3; i++) {\n          var ${direction}: ${dType} = originalIdx + ${dType}(i);\n          if (${direction} < 0 || ${direction} >= ${inputShape[idx]}) {\n            ${(() => {\n          if (excludeOutside) {\n            return `coefs[i + 1] = 0.0;\n                        continue;`;\n          } else if (useExtrapolation) {\n            return `return ${extrapolationValue};`;\n          } else {\n            return `${direction} = max(0, min(${direction}, ${inputShape[idx]} - 1));`;\n          }\n        })()};\n          }\n        var input_indices_copy: ${input.type.indices} = input_indices;\n          ${input.indicesSet('input_indices_copy', idx, `u32(${direction})`)};\n          data[i + 1] = ${\n            idx === heightIdx ? input.getByIndices('input_indices_copy') :\n                                'rowCubicInterpolation(input_indices_copy, output_indices)'};\n        }\n        return cubicInterpolation1D(data, coefs);\n      }`;\n      };\n\n      return `\n    ${createCubicInterpolationFunction(heightIdx)};\n    ${createCubicInterpolationFunction(widthIdx)};\n  fn getCubicInterpolationCoefs(s: ${dType}) -> array<${dType}, 4> {\n    var absS = abs(s);\n    var coeffs: array<${dType}, 4> = array<${dType}, 4>(0.0, 0.0, 0.0, 0.0);\n    var oneMinusAbsS: ${dType} = 1.0 - absS;\n    var twoMinusAbsS: ${dType} = 2.0 - absS;\n    var onePlusAbsS: ${dType} = 1.0 + absS;\n    coeffs[0] = ((${cubicCoeffA} * onePlusAbsS - 5 * ${cubicCoeffA}) * onePlusAbsS + 8 * ${\n          cubicCoeffA}) * onePlusAbsS - 4 * ${cubicCoeffA};\n    coeffs[1] = ((${cubicCoeffA} + 2) * absS - (${cubicCoeffA} + 3)) * absS * absS + 1;\n    coeffs[2] = ((${cubicCoeffA} + 2) * oneMinusAbsS - (${cubicCoeffA} + 3)) * oneMinusAbsS * oneMinusAbsS + 1;\n    coeffs[3] = ((${cubicCoeffA} * twoMinusAbsS - 5 * ${cubicCoeffA}) * twoMinusAbsS + 8 * ${\n          cubicCoeffA}) * twoMinusAbsS - 4 * ${cubicCoeffA};\n    return coeffs;\n  }\n\n  fn cubicInterpolation1D(x: array<${dType}, 4>, coefs: array<${dType}, 4>) -> ${dType} {\n    var coefsSum: ${dType} = coefs[0] + coefs[1] + coefs[2] + coefs[3];\n    return (x[0] * coefs[0] + x[1] * coefs[1]+ x[2] * coefs[2]+ x[3] * coefs[3]) / coefsSum;\n  }\n\n  fn bicubicInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n    var input_indices: ${input.type.indices} = output_indices;\n    return colCubicInterpolation(input_indices, output_indices);\n  }\n    `;\n    };\n\nconst trilinearInterpolation =\n    (input: IndicesHelper, output: IndicesHelper, inputShape: readonly number[], useExtrapolation: boolean,\n     extrapolationValue: number): string => {\n      const isNchw = true;\n      const [batchIdx, depthIdx, heightIdx, widthIdx, channelIdx] =\n          inputShape.length === 3 ? [-1, 0, 1, 2, -1] : (isNchw ? [0, 2, 3, 4, 1] : [0, 1, 2, 3, 4]);\n      const dType = input.type.value;\n      return `\n    fn getInputValue(batch: u32, channel: u32, depth:u32, height: u32, width: u32) -> ${dType} {\n      var input_indices: ${input.type.indices};\n      ${input.indicesSet('input_indices', depthIdx, `max(0, min(depth, ${inputShape[depthIdx]} - 1))`)};\n      ${input.indicesSet('input_indices', heightIdx, `max(0, min(height, ${inputShape[heightIdx]} - 1))`)};\n      ${input.indicesSet('input_indices', widthIdx, `max(0, min(width, ${inputShape[widthIdx]} - 1))`)};\n      ${setChannelAndBatchIndices(input, channelIdx, batchIdx, 3)}\n      return ${input.getByIndices('input_indices')};\n    }\n\n    fn trilinearInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n      var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices);\n      var depth:${dType} = originalIndices[${depthIdx}];\n      var height:${dType} = originalIndices[${heightIdx}];\n      var width:${dType} = originalIndices[${widthIdx}];\n      ${\n          useExtrapolation ? `if (depth < 0 || depth > (${inputShape[depthIdx]} - 1) || height < 0 || height > (${\n                                 inputShape[heightIdx]} - 1) || width < 0 || (width > ${inputShape[widthIdx]} - 1)) {\n      return ${extrapolationValue};\n        }` :\n                             ''};\n\n    depth = max(0, min(depth, ${inputShape[depthIdx]} - 1));\n      height = max(0, min(height, ${inputShape[heightIdx]} - 1));\n      width = max(0, min(width, ${inputShape[widthIdx]} - 1));\n      var depth1: u32 = u32(depth);\n      var height1: u32 = u32(height);\n      var width1: u32 = u32(width);\n      var depth2: u32 = u32(depth + 1);\n      var height2: u32 = u32(height + 1);\n      var width2: u32 = u32(width + 1);\n      var channel: u32 = ${inputShape.length > 3 ? `u32(originalIndices[${channelIdx}])` : '0'};\n      var batch: u32 =  ${inputShape.length > 3 ? `u32(originalIndices[${batchIdx}])` : '0'};\n\n      var x111: ${dType} = getInputValue(batch, channel, depth1, height1, width1);\n      var x112: ${dType} = getInputValue(batch, channel, depth1, height1, width2);\n      var x121: ${dType} = getInputValue(batch, channel, depth1, height2, width1);\n      var x122: ${dType} = getInputValue(batch, channel, depth1, height2, width2);\n      var x211: ${dType} = getInputValue(batch, channel, depth2, height1, width1);\n      var x212: ${dType} = getInputValue(batch, channel, depth2, height1, width2);\n      var x221: ${dType} = getInputValue(batch, channel, depth2, height2, width1);\n      var x222: ${dType} = getInputValue(batch, channel, depth2, height2, width2);\n      var dx1: ${dType} = abs(depth - ${dType}(depth1));\n      var dx2: ${dType} = abs(${dType}(depth2) - depth);\n      var dy1: ${dType} = abs(height - ${dType}(height1));\n      var dy2: ${dType} = abs(${dType}(height2) - height);\n      var dz1: ${dType} = abs(width - ${dType}(width1));\n      var dz2: ${dType} = abs(${dType}(width2) - width);\n      if (depth1 == depth2) {\n        dx1 = 0.5;\n        dx2 = 0.5;\n      }\n      if (height1 == height2) {\n        dy1 = 0.5;\n        dy2 = 0.5;\n      }\n      if (width1 == width2) {\n        dz1 = 0.5;\n        dz2 = 0.5;\n      }\n      return (x111 * dx2 * dy2 * dz2 + x112 * dx2 * dy2 * dz1 + x121 * dx2 * dy1 *dz2 + x122 * dx2 * dy1 * dz1 +\n              x211 * dx1 * dy2 * dz2 + x212 * dx1 * dy2 * dz1 + x221 * dx1 * dy1 *dz2 + x222 * dx1 * dy1 * dz1);\n    }`;\n    };\n\nconst createResizeProgramInfo =\n    (inputTensor: TensorView, attributes: ResizeAttributes, opsetVersion: number, scalesInput: readonly number[],\n     sizes: readonly number[], roiInput: readonly number[]): ProgramInfo => {\n      const inputShape = inputTensor.dims;\n      const roi = updateRoI(roiInput, attributes.axes, inputShape.length);\n\n      let outputShape = initOutputShape(inputShape, scalesInput, sizes, attributes.axes);\n      let scales = scalesInput.slice();\n      if (scalesInput.length === 0) {\n        scales = inputShape.map((value, index) => value === 0 ? 1.0 : outputShape[index] / value);\n        if (attributes.keepAspectRatioPolicy !== 'stretch') {\n          outputShape = adjustOutputShape(inputShape, scales, attributes);\n        }\n      }\n      const output = outputVariable('output', inputTensor.dataType, outputShape.length);\n      const input = inputVariable('input', inputTensor.dataType, inputShape.length);\n      const outputSize = ShapeUtil.size(outputShape);\n      const noScale = inputShape.length === outputShape.length && inputShape.every((d, i) => d === outputShape[i]);\n      const useExtrapolation = attributes.coordinateTransformMode === 'tf_crop_and_resize';\n      const extrapolationValue = attributes.extrapolationValue;\n      const dataType = input.type.value;\n      const getShaderSource = (shaderHelper: ShaderHelper) => `\n      ${noScale ? '' : `\n      ${getOriginalCoordinateFromResizedCoordinate(attributes.coordinateTransformMode, dataType)};\n      ${(() => {\n        switch (attributes.mode) {\n          case 'nearest':\n            return `\n              ${checkInputIndices(input, inputShape)};\n              ${getNearestPixelFromOriginal(attributes.nearestMode, opsetVersion, dataType)};\n              ${\n                calculateInputIndicesFromOutputIndices(\n                    input, output, inputShape, outputShape, scales.length, roi.length, useExtrapolation)};\n              `;\n          case 'linear':\n            return `\n              ${calculateOriginalIndicesFromOutputIndices(output, inputShape, outputShape, scales.length, roi.length)};\n              ${(() => {\n              if (inputShape.length === 2 || inputShape.length === 4) {\n                return `${bilinearInterpolation(input, output, inputShape, useExtrapolation, extrapolationValue)}`;\n              } else if (inputShape.length === 3 || inputShape.length === 5) {\n                return `${trilinearInterpolation(input, output, inputShape, useExtrapolation, extrapolationValue)}`;\n              } else {\n                throw Error('Linear mode only supports input dims 2, 3, 4 and 5 are supported in linear mode.');\n              }\n            })()};\n            `;\n          case 'cubic':\n            return `\n            ${(() => {\n              if (inputShape.length === 2 || inputShape.length === 4) {\n                return `${\n                    bicubicInterpolation(\n                        input, output, inputShape, outputShape, scales, roi, attributes.cubicCoeffA, useExtrapolation,\n                        attributes.extrapolationValue, attributes.excludeOutside)}`;\n              } else {\n                throw Error('Cubic mode only supports input dims 2 and 4 are supported in linear mode.');\n              }\n            })()};\n            `;\n          default:\n            throw Error('Invalid resize mode');\n        }\n      })()};\n      `}\n      ${\n          shaderHelper.registerUniform('output_size', 'u32')\n              .registerUniform('scales', 'f32', scales.length)\n              .registerUniform('roi', 'f32', roi.length)\n              .declareVariables(input, output)}\n      ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n        ${noScale ? 'output[global_idx] = input[global_idx];' : `\n        let output_indices = ${output.offsetToIndices('global_idx')};\n        var input_indices: ${input.type.indices};\n        ${(() => {\n        switch (attributes.mode) {\n          case 'nearest':\n            return `input_indices = calculateInputIndicesFromOutputIndices(output_indices);\n                if (checkInputIndices(input_indices)) {\n                  output[global_idx] = ${input.getByIndices('input_indices')};\n                } else {\n                  output[global_idx] = ${attributes.extrapolationValue};\n                }`;\n          case 'linear':\n            return `output[global_idx] = ${\n                (inputShape.length === 2 || inputShape.length === 4) ? 'bilinearInterpolation' :\n                                                                       'trilinearInterpolation'}(output_indices);`;\n          case 'cubic':\n            return 'output[global_idx] = bicubicInterpolation(output_indices);';\n          default:\n            throw Error(`Unsupported resize mode: ${attributes.mode}`);\n        }\n      })()};\n`}\n      }`;\n\n      return {\n        name: 'Resize',\n        shaderCache: {\n          hint: `${attributes.cacheKey}|${opsetVersion}|${scales.length > 0 ? scales : ''}|${\n              sizes.length > 0 ? sizes : ''}|${roi.length > 0 ? roi : ''}|${noScale}|${inputShape}`,\n          inputDependencies: ['rank']\n        },\n        getShaderSource,\n        getRunData: () => ({\n          outputs: [{dims: outputShape, dataType: inputTensor.dataType}],\n          dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n          programUniforms: [\n            {type: DataType.uint32, data: outputSize}, {type: DataType.float, data: scales},\n            {type: DataType.float, data: roi}, ...createTensorShapeVariables(inputShape, outputShape)\n          ]\n        })\n      };\n    };\n\nconst getOpsetVersionFromCustomDataBuffer = (context: ComputeContext): number => {\n  const customDataBuffer = context.customDataBuffer;\n  const customDataBuffer32 = new Uint32Array(customDataBuffer, customDataBuffer.byteOffset, 1);\n  const opsetVersion = customDataBuffer32[0];\n  return opsetVersion;\n};\n\nexport const resize = (context: ComputeContext, attributes: ResizeAttributes): void => {\n  const scales: number[] = [];\n  const sizes: number[] = [];\n  const roi: number[] = [];\n\n  // Note that scales in resize are always f32. roi can be f32 or f16.\n  // TODO: Currently this code does not support f16 for roi when passed as optional input.\n\n  const opsetVersion = getOpsetVersionFromCustomDataBuffer(context);\n  if (attributes.antialias !== 0) {\n    throw Error('Only default value (0) for Antialias attribute is supported');\n  }\n  validateInputs(context.inputs, attributes, opsetVersion, scales, sizes, roi);\n  context.compute(\n      createResizeProgramInfo(context.inputs[0], attributes, opsetVersion, scales, sizes, roi), {inputs: [0]});\n};\n\nexport const parseResizeAttributes = (attributes: Record<string, unknown>): ResizeAttributes => {\n  const antialias = attributes.antialias as number;\n  const axes = attributes.axes as number[];\n  const coordinateTransformMode: CoordinateTransformMode =\n      attributes.coordinateTransformMode as CoordinateTransformMode;\n  const cubicCoeffA = attributes.cubicCoeffA as number;\n  const excludeOutside = attributes.excludeOutside as number !== 0;\n  const extrapolationValue = attributes.extrapolationValue as number;\n  const keepAspectRatioPolicy: KeepAspectRatioPolicy = attributes.keepAspectRatioPolicy as KeepAspectRatioPolicy;\n  const mode: Mode = attributes.mode as Mode;\n  // If nearestMode is not specified, use simple mode.\n  const nearestMode: NearestMode = (attributes.nearestMode === '' ? 'simple' : attributes.nearestMode) as NearestMode;\n  return createAttributeWithCacheKey({\n    antialias,\n    axes,\n    coordinateTransformMode,\n    cubicCoeffA,\n    excludeOutside,\n    extrapolationValue,\n    keepAspectRatioPolicy,\n    mode,\n    nearestMode\n  });\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper, WORKGROUP_SIZE} from './common';\n\nexport interface RotaryEmbeddingAttributes {\n  readonly interleaved: boolean;\n  readonly numHeads: number;\n  readonly rotaryEmbeddingDim: number;\n  readonly scale: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: RotaryEmbeddingAttributes): void => {\n  const [input, positionIds, cosCache, sinCache] = inputs;\n  const {numHeads, rotaryEmbeddingDim} = attributes;\n\n  if (input.dims.length !== 3 && input.dims.length !== 4) {\n    throw new Error(`Input 'x' is expected to have 3 or 4 dimensions, got ${input.dims.length}`);\n  }\n  if (!ShapeUtil.areEqual(positionIds.dims, []) && !ShapeUtil.areEqual(positionIds.dims, [1]) &&\n      positionIds.dims.length !== 2) {\n    throw new Error(`Input 'position_ids' is expected to have 0, 1, or 2 dimensions, got ${positionIds.dims.length}`);\n  }\n  if (cosCache.dims.length !== 2) {\n    throw new Error(`Input 'cos_cache' is expected to have 2 dimensions, got ${cosCache.dims.length}`);\n  }\n  if (sinCache.dims.length !== 2) {\n    throw new Error(`Input 'sin_cache' is expected to have 2 dimensions, got ${sinCache.dims.length}`);\n  }\n  if (!ShapeUtil.areEqual(cosCache.dims, sinCache.dims)) {\n    throw new Error('Inputs \\'cos_cache\\' and \\'sin_cache\\' are expected to have the same shape');\n  }\n\n  if (rotaryEmbeddingDim > 0 && numHeads === 0) {\n    throw new Error('num_heads must be provided if rotary_embedding_dim is specified');\n  }\n\n  const batchSize = input.dims[0];\n  const sequenceLength = input.dims[input.dims.length - 2];\n  const maxSequenceLength = cosCache.dims[0];\n  const hiddenSize = ShapeUtil.sizeFromDimension(input.dims, 1) / sequenceLength;\n  const headSize = rotaryEmbeddingDim === 0 ? cosCache.dims[1] * 2 : hiddenSize / numHeads;\n  if (rotaryEmbeddingDim > headSize) {\n    throw new Error('rotary_embedding_dim must be less than or equal to head_size');\n  }\n\n  if (positionIds.dims.length === 2) {\n    if (batchSize !== positionIds.dims[0]) {\n      throw new Error(`Input 'position_ids' dimension 0 should be of size batch_size, got ${positionIds.dims[0]}`);\n    }\n    if (sequenceLength !== positionIds.dims[1]) {\n      throw new Error(`Input 'position_ids' dimension 1 should be of size sequence_length, got ${positionIds.dims[1]}`);\n    }\n  }\n\n  if (headSize / 2 !== cosCache.dims[1] && rotaryEmbeddingDim / 2 !== cosCache.dims[1]) {\n    throw new Error(`Input 'cos_cache' dimension 1 should be same as head_size / 2 or rotary_embedding_dim / 2, got ${\n        cosCache.dims[1]}`);\n  }\n\n  if (sequenceLength > maxSequenceLength) {\n    throw new Error('Updating cos_cache and sin_cache in RotaryEmbedding is not currently supported');\n  }\n};\n\nconst createRotaryEmbeddingProgramInfo =\n    (inputs: readonly TensorView[], attributes: RotaryEmbeddingAttributes): ProgramInfo => {\n      const {interleaved, numHeads, rotaryEmbeddingDim, scale} = attributes;\n      const batchSize = inputs[0].dims[0];\n      const batchStride = ShapeUtil.sizeFromDimension(inputs[0].dims, 1);\n      const sequenceLength = inputs[0].dims[inputs[0].dims.length - 2];\n      const hiddenSize = batchStride / sequenceLength;\n      const halfRotaryEmbeddingDim = inputs[2].dims[1];\n      const headSize = rotaryEmbeddingDim === 0 ? halfRotaryEmbeddingDim * 2 : hiddenSize / numHeads;\n\n      // Rotary embeddings will be calculated in a pair-wise fashion. In accordance, use the shape\n      // [batch size, sequence length, num of heads, num of pairs to rotate + num of dims to copy]\n      // to unfold the global index in shader.\n      const globalShape =\n          new Array<number>(batchSize, sequenceLength, hiddenSize / headSize, headSize - halfRotaryEmbeddingDim);\n      const globalStrides = ShapeUtil.computeStrides(globalShape);\n\n      const programUniforms: ProgramUniform[] = [\n        {type: DataType.float, data: scale},\n        {type: DataType.uint32, data: globalShape},\n        {type: DataType.uint32, data: globalStrides},\n\n        // strides for addressing the input/output tensor, in permutated order to align with the unfolded global index,\n        // i.e. BSNH\n        ...(inputs[0].dims.length === 3 ?\n                new Array<ProgramUniform>({type: DataType.uint32, data: [batchStride, hiddenSize, headSize, 1]}) :\n                []),\n        ...(inputs[0].dims.length === 4 ?\n                new Array<ProgramUniform>(\n                    {type: DataType.uint32, data: [batchStride, headSize, sequenceLength * headSize, 1]}) :\n                []),\n\n        ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims, inputs[2].dims, inputs[3].dims, inputs[0].dims),\n      ];\n\n      const getShaderSource = (shaderHelper: ShaderHelper) => {\n        const input = inputVariable('input', inputs[0].dataType, inputs[0].dims.length);\n        const positionIds = inputVariable('position_ids', inputs[1].dataType, inputs[1].dims.length);\n        const cosCache = inputVariable('cos_cache', inputs[2].dataType, inputs[2].dims.length);\n        const sinCache = inputVariable('sin_cache', inputs[3].dataType, inputs[3].dims.length);\n        const output = outputVariable('output', inputs[0].dataType, inputs[0].dims.length);\n\n        shaderHelper.registerUniforms([\n          {name: 'scale', type: 'f32'},\n          {name: 'global_shape', type: 'u32', length: globalShape.length},\n          {name: 'global_strides', type: 'u32', length: globalStrides.length},\n          {name: 'input_output_strides', type: 'u32', length: globalStrides.length},\n        ]);\n\n        return `\n        ${shaderHelper.declareVariables(input, positionIds, cosCache, sinCache, output)}\n\n        ${shaderHelper.mainStart(WORKGROUP_SIZE)}\n          let half_rotary_emb_dim = uniforms.${cosCache.name}_shape[1];\n          let bsnh = global_idx / uniforms.global_strides % uniforms.global_shape;\n          let size = uniforms.global_shape[0] * uniforms.global_strides[0];\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('size')}\n\n          if (bsnh[3] < half_rotary_emb_dim) {\n            let position_ids_idx =\n                ${positionIds.broadcastedIndicesToOffset('bsnh.xy', outputVariable('', positionIds.type.tensor, 2))};\n            let position_id =\n                u32(${positionIds.getByOffset('position_ids_idx')}) + select(0, bsnh[1], position_ids_idx == 0);\n            let i = dot(bsnh, uniforms.input_output_strides) + select(0, bsnh[3], ${interleaved});\n            let j = i + select(half_rotary_emb_dim, 1, ${interleaved});\n            let re = ${input.getByOffset('i')} * ${cosCache.get('position_id', 'bsnh[3]')} -\n                ${input.getByOffset('j')} * ${sinCache.get('position_id', 'bsnh[3]')};\n            ${output.setByOffset('i', 're')}\n            let im = ${input.getByOffset('i')} * ${sinCache.get('position_id', 'bsnh[3]')} +\n                ${input.getByOffset('j')} * ${cosCache.get('position_id', 'bsnh[3]')};\n            ${output.setByOffset('j', 'im')}\n          } else {\n            let k = dot(bsnh, uniforms.input_output_strides) + half_rotary_emb_dim;\n            ${output.setByOffset('k', input.getByOffset('k'))}\n          }\n        }`;\n      };\n\n      return {\n        name: 'RotaryEmbedding',\n        shaderCache: {\n          hint: createAttributeWithCacheKey({\n                  interleaved,\n                }).cacheKey,\n          inputDependencies: ['rank', 'rank', 'rank', 'rank'],\n        },\n        getShaderSource,\n        getRunData: () => ({\n          outputs: [{dims: inputs[0].dims, dataType: inputs[0].dataType}],\n          dispatchGroup: {x: Math.ceil(ShapeUtil.size(globalShape) / WORKGROUP_SIZE)},\n          programUniforms,\n        }),\n      };\n    };\n\nexport const rotaryEmbedding = (context: ComputeContext, attributes: RotaryEmbeddingAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  context.compute(createRotaryEmbeddingProgramInfo(context.inputs, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo, ProgramUniform} from '../types';\n\nimport {castToF32, fillVector, getMaxComponents, inputVariable, outputVariable, ShaderHelper, sumVector, tensorTypeToWsglStorageType, UniformsArrayType} from './common';\n\nexport interface SkipLayerNormAttributes {\n  simplified: boolean;\n  epsilon: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length < 3) {\n    throw new Error('layerNorm requires at least 3 inputs.');\n  }\n\n  const input: TensorView = inputs[0];\n  const skip: TensorView = inputs[1];\n  const gamma: TensorView = inputs[2];\n\n  if (input.dataType !== skip.dataType || input.dataType !== gamma.dataType) {\n    throw new Error('All inputs must have the same data type');\n  }\n\n  if (input.dims.length !== 3 && input.dims.length !== 2) {\n    throw new Error('Input must be 2D or 3D');\n  }\n\n  if (skip.dims.length !== 3 && skip.dims.length !== 2) {\n    throw new Error('Skip must be 2D or 3D');\n  }\n\n  const hiddenSize = input.dims[input.dims.length - 1];\n  const sequenceLength = input.dims[input.dims.length - 2];\n  if (skip.dims[skip.dims.length - 1] !== hiddenSize) {\n    throw new Error('Skip must have the same hidden size as input');\n  }\n  if (skip.dims[skip.dims.length - 2] !== sequenceLength) {\n    throw new Error('Skip must have the same sequence length as input');\n  }\n\n  if (gamma.dims.length !== 1) {\n    throw new Error('Gamma must be 1D');\n  }\n  if (gamma.dims[gamma.dims.length - 1] !== hiddenSize) {\n    throw new Error('Gamma must have the same hidden size as input');\n  }\n  if (inputs.length > 3) {\n    const beta: TensorView = inputs[3];\n    if (beta.dims.length !== 1) {\n      throw new Error('Beta must be 1D');\n    }\n    if (beta.dims[beta.dims.length - 1] !== hiddenSize) {\n      throw new Error('Beta must have the same hidden size as input');\n    }\n  }\n\n  if (inputs.length > 4) {\n    const bias: TensorView = inputs[4];\n    if (bias.dims.length !== 1) {\n      throw new Error('Bias must be 1D');\n    }\n    if (bias.dims[bias.dims.length - 1] !== hiddenSize) {\n      throw new Error('Bias must have the same hidden size as input');\n    }\n  }\n};\n\nconst createSkipLayerNormProgramInfo =\n    (inputs: readonly TensorView[], attributes: SkipLayerNormAttributes, outputCount: number, isTraining: boolean):\n        ProgramInfo => {\n          const simplified = attributes.simplified;\n\n          const inputShape = inputs[0].dims;\n          const inputSize = ShapeUtil.size(inputShape);\n          const outputShape = inputShape;\n          const outputSize = inputSize;\n          const hiddenSize = inputShape.slice(-1)[0];\n          const meanInvStdDevDim = isTraining ? inputShape.slice(0, -1).concat(1) : [];\n          const hasBetaInput = !simplified && inputs.length > 3;\n          const hasBiasInput = inputs.length > 4;\n          const hasMeanOutput = isTraining && outputCount > 1;\n          const hasInvStdDevOutput = isTraining && outputCount > 2;\n          const hasInputSkipBiasSumOutput = outputCount > 3;\n\n          const components = getMaxComponents(hiddenSize);\n\n          const programUniforms: ProgramUniform[] = [\n            {type: DataType.uint32, data: outputSize},\n            {type: DataType.uint32, data: components},\n            {type: DataType.uint32, data: hiddenSize},\n            {type: DataType.float, data: attributes.epsilon},\n          ];\n          const getShaderSource = (shaderHelper: ShaderHelper) => {\n            const uniformsArray: UniformsArrayType = [\n              {name: 'output_size', type: 'u32'},\n              {name: 'components', type: 'u32'},\n              {name: 'hidden_size', type: 'u32'},\n              {name: 'epsilon', type: 'f32'},\n            ];\n            const variables = [\n              inputVariable('x', inputs[0].dataType, inputs[0].dims, components),\n              inputVariable('skip', inputs[1].dataType, inputs[1].dims, components),\n              inputVariable('gamma', inputs[2].dataType, inputs[2].dims, components),\n            ];\n            if (hasBetaInput) {\n              variables.push(inputVariable('beta', inputs[3].dataType, inputs[3].dims, components));\n            }\n            if (hasBiasInput) {\n              variables.push(inputVariable('bias', inputs[4].dataType, inputs[4].dims, components));\n            }\n            variables.push(outputVariable('output', inputs[0].dataType, outputShape, components));\n            if (hasMeanOutput) {\n              variables.push(outputVariable('mean_output', DataType.float, meanInvStdDevDim));\n            }\n            if (hasInvStdDevOutput) {\n              variables.push(outputVariable('inv_std_output', DataType.float, meanInvStdDevDim));\n            }\n            if (hasInputSkipBiasSumOutput) {\n              variables.push(outputVariable('input_skip_bias_sum', inputs[0].dataType, outputShape, components));\n            }\n            const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n            return `\n\n      ${shaderHelper.registerUniforms(uniformsArray).declareVariables(...variables)}\n\n      ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size / uniforms.hidden_size')}\n        let hidden_size_vectorized: u32 = uniforms.hidden_size / uniforms.components;\n        let offset = global_idx * hidden_size_vectorized;\n        var sum = ${fillVector('f32', components)};\n        var squareSum = ${fillVector('f32', components)};\n        for (var i: u32 = 0; i < hidden_size_vectorized; i++) {\n          let skip_value = skip[offset + i];\n          let bias_value = ${hasBiasInput ? 'bias[i]' : dataType + '(0.0)'};\n          let input_value = x[offset + i];\n          let value = input_value + skip_value + bias_value;\n          ${hasInputSkipBiasSumOutput ? 'input_skip_bias_sum[offset + i] = value;' : ''}\n          output[offset + i] = value;\n          let f32_value = ${castToF32(dataType, components, 'value')};\n          sum += f32_value;\n          squareSum += f32_value * f32_value;\n        }\n        let mean = ${sumVector('sum', components)} / f32(uniforms.hidden_size);\n        let inv_std_dev = inverseSqrt(${sumVector('squareSum', components)} / f32(uniforms.hidden_size) ${\n                simplified ? '' : '- mean * mean'} + uniforms.epsilon);\n        ${hasMeanOutput ? 'mean_output[global_idx] = mean;' : ''}\n        ${hasInvStdDevOutput ? 'inv_std_output[global_idx] = inv_std_dev;' : ''}\n        for (var i: u32 = 0; i < hidden_size_vectorized; i++) {\n          output[offset + i] = (output[offset + i] ${simplified ? '' : `- ${dataType}(mean)`}) * ${\n                dataType}(inv_std_dev) * gamma[i] ${hasBetaInput ? '+ beta[i]' : ''};\n        }\n      }`;\n          };\n          const outputs = [{dims: outputShape, dataType: inputs[0].dataType}];\n          if (outputCount > 1) {\n            outputs.push({dims: meanInvStdDevDim, dataType: DataType.float});\n          }\n          if (outputCount > 2) {\n            outputs.push({dims: meanInvStdDevDim, dataType: DataType.float});\n          }\n          if (outputCount > 3) {\n            outputs.push({dims: inputShape, dataType: inputs[0].dataType});\n          }\n          return {\n            name: 'SkipLayerNormalization',\n            shaderCache: {\n              hint: `${components};${hasMeanOutput};${hasInvStdDevOutput};${hasInputSkipBiasSumOutput}`,\n              inputDependencies: inputs.map((_input, _index) => 'type')\n            },\n            getShaderSource,\n            getRunData: () => ({outputs, dispatchGroup: {x: Math.ceil(outputSize / hiddenSize / 64)}, programUniforms}),\n          };\n        };\n\nexport const skipLayerNorm = (context: ComputeContext, attributes: SkipLayerNormAttributes): void => {\n  // TODO: initialize isTraining from ComputeContext\n  const isTraining = false;\n  validateInputs(context.inputs);\n  // Mean and InvStdDev are only used in training mode and are not required for inference.\n  // They are added here for completeness only.\n  const outputs = [0];\n  if (context.outputCount > 1) {\n    outputs.push(isTraining ? 1 : -3);\n  }\n  if (context.outputCount > 2) {\n    outputs.push(isTraining ? 2 : -3);\n  }\n  if (context.outputCount > 3) {\n    outputs.push(3);\n  }\n  context.compute(\n      createSkipLayerNormProgramInfo(context.inputs, attributes, context.outputCount, isTraining), {outputs});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform, TensorInfo} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, IndicesHelper, inputVariable, outputVariable, ShaderHelper, UniformsArrayType} from './common';\n\nexport interface SliceAttributes extends AttributeWithCacheKey {\n  readonly starts: number[];\n  readonly ends: number[];\n  readonly axes: number[];\n}\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: SliceAttributes): void => {\n  if (!inputs || inputs.length < 1) {\n    throw new Error('too few inputs');\n  }\n  if (attributes.axes.length !== 0) {\n    if (attributes.axes.length !== attributes.starts.length || attributes.axes.length !== attributes.ends.length) {\n      throw new Error('axes, starts and ends must have the same length');\n    }\n  } else if (attributes.starts.length !== attributes.ends.length) {\n    throw new Error('starts and ends must have the same length');\n  }\n  inputs.slice(1).forEach((_, idx) => {\n    if (inputs[idx + 1].dataType !== DataType.int32 && inputs[idx + 1].dataType !== DataType.int64) {\n      throw new Error(`Input ${idx} must be an array of int32 or int64`);\n    }\n  });\n};\n\nconst readInput = (inputs: readonly TensorView[], idx: number): number[] => {\n  const input: number[] = [];\n  if (inputs.length > idx) {\n    if (inputs[idx].dataType === DataType.int64) {\n      inputs[idx].getBigInt64Array().forEach(v => input.push(Number(v)));\n    } else if (inputs[idx].dataType === DataType.int32) {\n      inputs[idx].getInt32Array().forEach(v => input.push(Number(v)));\n    } else {\n      throw new Error(`Input ${idx} must be an array of int32 or int64`);\n    }\n  }\n  return input;\n};\n\nconst createSliceAttributesFromInputs =\n    (inputs: readonly TensorView[], attributes: SliceAttributes): SliceAttributes => {\n      if (inputs.length > 1) {\n        const starts: number[] = readInput(inputs, 1);\n        const ends: number[] = readInput(inputs, 2);\n        let axes: number[] = readInput(inputs, 3);\n        if (axes.length === 0) {\n          axes = [...Array(inputs[0].dims.length).keys()];\n        }\n        return createAttributeWithCacheKey({starts, ends, axes});\n      } else {\n        return attributes;\n      }\n    };\n\nconst fixStartEndValues =\n    (value: number, index: number, inputShape: readonly number[], axes: readonly number[], steps: readonly number[]):\n        number => {\n          let newValue = value;\n          if (value < 0) {\n            newValue += inputShape[axes[index]];\n          }\n          if (steps[index] < 0) {\n            return Math.max(0, Math.min(newValue, inputShape[axes[index]] - 1));\n          } else {\n            return Math.max(0, Math.min(newValue, inputShape[axes[index]]));\n          }\n        };\n\nconst calculateInputIndicesImpl =\n    (input: IndicesHelper, output: IndicesHelper, inputShape: readonly number[]): string =>\n        `fn calculateInputIndices(output_indices: ${output.type.indices}) -> ${input.type.indices} {\n          var input_indices: ${input.type.indices};\n          var carry = 0u;\n          for (var i = ${inputShape.length}; i >= 0; i--) {\n            let input_shape_i = ${getElementAt('uniforms.input_shape', 'i', inputShape.length)};\n            let steps_i = ${getElementAt('uniforms.steps', 'i', inputShape.length)};\n            let signs_i = ${getElementAt('uniforms.signs', 'i', inputShape.length)};\n            let starts_i = ${getElementAt('uniforms.starts', 'i', inputShape.length)};\n            var output_index = ${output.indicesGet('output_indices', 'i')};\n            var input_index = output_index * steps_i + starts_i + carry;\n            carry = input_index / input_shape_i;\n            input_index = input_index % input_shape_i;\n            if (signs_i < 0) {\n              input_index = input_shape_i - input_index - 1u + starts_i;\n            }\n            ${input.indicesSet('input_indices', 'i', 'input_index')};\n          }\n          return input_indices;\n      }`;\n\nconst createSliceProgramInfo = (inputs: readonly TensorView[], attributes: SliceAttributes): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const inputSize = ShapeUtil.size(inputShape);\n  const axes = (attributes.axes.length > 0) ? ShapeUtil.normalizeAxes(attributes.axes, inputShape.length) :\n                                              [...Array(inputShape.length).keys()];\n  let steps = readInput(inputs, 4);\n  steps.forEach((step) => step !== 0 || (() => {\n                            throw new Error('step cannot be 0');\n                          }));\n  if (steps.length === 0) {\n    steps = Array(axes.length).fill(1);\n  }\n  const starts = attributes.starts.map((start, i) => fixStartEndValues(start, i, inputShape, axes, steps));\n\n  const ends = attributes.ends.map((end, i) => fixStartEndValues(end, i, inputShape, axes, steps));\n\n  if (axes.length !== starts.length || axes.length !== ends.length) {\n    throw new Error('start, ends and axes should have the same number of elements');\n  }\n\n  if (axes.length !== inputShape.length) {\n    for (let i = 0; i < inputShape.length; ++i) {\n      if (!axes.includes(i)) {\n        starts.splice(i, 0, 0);\n        ends.splice(i, 0, inputShape[i]);\n        steps.splice(i, 0, 1);\n      }\n    }\n  }\n  const signs = steps.map(step => Math.sign(step));\n  // Convert negative steps to positive steps and reverse starts and ends\n  steps.forEach((step, i, array) => {\n    if (step < 0) {\n      const numSteps = (ends[i] - starts[i]) / step;\n      const newEnd = starts[i];\n      const newStart = newEnd + numSteps * steps[i];\n      starts[i] = newStart;\n      ends[i] = newEnd;\n      array[i] = -step;\n    }\n  });\n  // Output rank is expected to be less than or equal to the input rank.\n  const outputShape = inputShape.slice(0);\n  axes.forEach((axis, _) => {\n    outputShape[axis] = Math.ceil((ends[axis] - starts[axis]) / steps[axis]);\n  });\n  const outputTensorInfo: TensorInfo = {dims: outputShape, dataType: inputs[0].dataType};\n\n  const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n  const input = inputVariable('input', inputs[0].dataType, inputs[0].dims.length);\n  const outputSize = ShapeUtil.size(outputShape);\n  const uniforms: UniformsArrayType = [\n    {name: 'outputSize', type: 'u32'}, {name: 'starts', type: 'u32', length: starts.length},\n    {name: 'signs', type: 'i32', length: signs.length}, {name: 'steps', type: 'u32', length: steps.length}\n  ];\n\n  const programUniforms: ProgramUniform[] = [\n    {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: starts},\n    {type: DataType.int32, data: signs}, {type: DataType.uint32, data: steps},\n    ...createTensorShapeVariables(inputs[0].dims, outputShape)\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n      ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)}\n        ${calculateInputIndicesImpl(input, output, inputShape)}\n        ${shaderHelper.mainStart()}\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n          let output_indices = ${output.offsetToIndices('global_idx')};\n          let input_indices = calculateInputIndices(output_indices);\n          ${output.setByOffset('global_idx', input.getByIndices('input_indices'))}\n      }`;\n  return {\n    name: 'Slice',\n    shaderCache: {hint: `${signs.length}_${starts.length}_${steps.length}`, inputDependencies: ['rank']},\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [outputTensorInfo],\n      dispatchGroup: {x: Math.ceil(inputSize / 64 /* workgroup size */)},\n      programUniforms\n    })\n  };\n};\n\nexport const slice = (context: ComputeContext, attributes: SliceAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  const updatedAttributes = createSliceAttributesFromInputs(context.inputs, attributes);\n  context.compute(createSliceProgramInfo(context.inputs, updatedAttributes), {inputs: [0]});\n  // if (ShapeUtil.size(program.outputs[0].dims) > 0) {\n  //   context.compute(programInfoLoader, {inputs: [0]});\n  // } else {\n  //   // TODO: support empty output\n  //   throw new Error('slice: output size is 0');\n  // }\n};\n\nexport const parseSliceAttributes = (attributes: Record<string, unknown>): SliceAttributes => {\n  const starts = attributes.starts as number[];\n  const ends = attributes.ends as number[];\n  const axes = attributes.axes as number[];\n  return createAttributeWithCacheKey({starts, ends, axes});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// TODO: this is the same naive implementation we use for reduce that has\n// performance limitations when the reduced axis is long. Need to add\n// a optimized codepath for this.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {getMaxComponents, inputVariable, outputVariable, ShaderHelper, sumVector, tensorTypeToWsglStorageType} from './common';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Softmax op requires 1 input.');\n  }\n};\n\nexport interface SoftmaxAttributes extends AttributeWithCacheKey {\n  readonly axis: number;\n}\n\nconst createSoftmaxProgramInfo = (input: TensorView, attributes: SoftmaxAttributes): ProgramInfo => {\n  const shape = input.dims;\n  const outputSize = ShapeUtil.size(shape);\n  const WG = 64;\n  let axis = attributes.axis;\n  if (axis < 0) {\n    axis = shape.length + axis;\n  }\n  if (axis < shape.length - 1) {\n    throw new Error('softmax only supports last axis for now.');\n  }\n\n  const cols = shape[axis];\n  const rows = outputSize / cols;\n  const components = getMaxComponents(cols);\n  const packedCols = cols / components;\n\n  const maxVector = (name: string, components: number) => {\n    if (components === 4) {\n      return `max(max(${name}.x, ${name}.y), max(${name}.z, ${name}.w))`;\n    } else if (components === 2) {\n      return `max(${name}.x, ${name}.y)`;\n    } else if (components === 3) {\n      return `max(max(${name}.x, ${name}.y), ${name}.z)`;\n    }\n\n    return name;\n  };\n  const x = inputVariable('x', input.dataType, input.dims, components);\n  const output = outputVariable('result', input.dataType, input.dims, components);\n  const valueType = x.type.value;\n  // 6.2.4 in wgsl spec\n  const threadMaxDecl = tensorTypeToWsglStorageType(input.dataType) === 'f32' ?\n      `var threadMax = ${valueType}(-3.402823e+38f);` :\n      `var threadMax = ${valueType}(-65504.0h);`;\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n      var<workgroup> rowMaxShared : ${valueType};\n      var<workgroup> rowSumShared : ${valueType};\n      var<workgroup> threadShared : array<${valueType}, ${WG}>;\n\n      fn getValue(row: i32, col: i32, row_stride: i32) -> ${valueType} {\n        let index = row * row_stride + col;\n        return x[index];\n      }\n\n      fn setValue(row: i32, col: i32, row_stride: i32, value: ${valueType}) {\n        let index = row * row_stride + col;\n        result[index] = value;\n      }\n      ${shaderHelper.registerUniform('packedCols', 'i32').declareVariables(x, output)}\n      ${shaderHelper.mainStart()}\n        let gindex = i32(global_idx);\n        let lindex = i32(local_idx);\n        const wg = ${WG};\n        let row = gindex / wg;\n        let cols = uniforms.packedCols;\n        let row_stride : i32 = uniforms.packedCols;\n\n        // find the rows max\n        ${threadMaxDecl}\n        for (var col = lindex; col < cols; col += wg) {\n          let value = getValue(row, col, row_stride);\n          threadMax = max(threadMax, value);\n        }\n        if (lindex < cols) {\n          threadShared[lindex] = threadMax;\n        }\n        workgroupBarrier();\n\n        var reduceSize = min(cols, wg);\n        for (var currSize = reduceSize >> 1;  currSize > 0; currSize = reduceSize >> 1) {\n          reduceSize = currSize + (reduceSize & 1);\n          if (lindex < currSize) {\n            threadShared[lindex] = max(threadShared[lindex], threadShared[lindex + reduceSize]);\n          }\n          workgroupBarrier();\n        }\n        if (lindex == 0) {\n          rowMaxShared = ${valueType}(${maxVector('threadShared[0]', components)});\n        }\n        workgroupBarrier();\n\n        // find the rows sum\n        var threadSum = ${valueType}(0.0);\n        for (var col = lindex; col < cols; col += wg) {\n          let subExp = exp(getValue(row, col, row_stride) - rowMaxShared);\n          threadSum += subExp;\n        }\n        threadShared[lindex] = threadSum;\n        workgroupBarrier();\n\n        for (var currSize = wg >> 1;  currSize > 0; currSize = currSize >> 1) {\n          if (lindex < currSize) {\n            threadShared[lindex] = threadShared[lindex] + threadShared[lindex + currSize];\n          }\n          workgroupBarrier();\n        }\n        if (lindex == 0) {\n          rowSumShared = ${valueType}(${sumVector('threadShared[0]', components)});\n        }\n        workgroupBarrier();\n\n        // calculate final value for each element in the row\n        for (var col = lindex; col < cols; col += wg) {\n          let value = exp(getValue(row, col, row_stride) - rowMaxShared) / rowSumShared;\n          setValue(row, col, row_stride, value);\n        }\n      }`;\n  return {\n    name: 'Softmax',\n    shaderCache: {hint: `${components}`, inputDependencies: ['type']},\n    getRunData: () => ({\n      outputs: [{dims: shape, dataType: input.dataType}],\n      dispatchGroup: {x: rows},\n      programUniforms: [{type: DataType.int32, data: packedCols}]\n    }),\n    getShaderSource,\n  };\n};\n\nexport const softmax = (context: ComputeContext, attributes: SoftmaxAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createSoftmaxProgramInfo(context.inputs[0], attributes));\n};\n\nexport const parseSoftmaxAttributes = (attributes: Record<string, unknown>): SoftmaxAttributes =>\n    createAttributeWithCacheKey({axis: attributes.axis as number});\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';\nimport {ComputeContext, ProgramInfo, ProgramUniform, TensorInfo} from '../types';\n\nimport {createTensorShapeVariables, getElementAt, IndicesHelper, inputVariable, outputVariable, ShaderHelper} from './common';\n\nexport interface SplitAttributes extends AttributeWithCacheKey {\n  readonly axis: number;\n  readonly numOutputs: number;\n  readonly splitSizes: number[];\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length < 1) {\n    throw new Error('too few inputs');\n  }\n};\n\nconst createSplitAttributesFromInputs =\n    (inputs: readonly TensorView[], attributes: SplitAttributes): SplitAttributes => {\n      const splitSizes: number[] = [];\n      let numOutputs: number = attributes.numOutputs;\n      if (inputs[1].dims[0] > 0) {\n        inputs[1].getBigInt64Array().forEach(v => splitSizes.push(Number(v)));\n        numOutputs = splitSizes.length;\n      }\n      return createAttributeWithCacheKey({numOutputs, axis: attributes.axis, splitSizes});\n    };\n\nconst calculateOutputIndexImpl = (numberOfTensors: number): string => `\nfn calculateOutputIndex(index: u32) -> u32 {\n    for (var i: u32 = 0u; i < ${numberOfTensors}u; i += 1u ) {\n    if (index < ${getElementAt('uniforms.size_in_split_axis', 'i', numberOfTensors)}) {\n        return i;\n    }\n    }\n    return ${numberOfTensors}u;\n}`;\nconst writeBufferDataImpl = (outputs: readonly IndicesHelper[]) => {\n  const numberOfTensors = outputs.length;\n  const codeLines: string[] = [];\n  for (let i = 0; i < numberOfTensors; ++i) {\n    const returnSnippet = outputs[i].setByIndices('indices', 'input[global_idx]');\n    if (numberOfTensors === 1) {\n      codeLines.push(returnSnippet);\n    } else if (i === 0) {\n      codeLines.push(`if (output_number == ${i}u) { ${returnSnippet} }`);\n    } else if (i === numberOfTensors - 1) {\n      codeLines.push(`else { ${returnSnippet} }`);\n    } else {\n      codeLines.push(`else if (output_number == ${i}) { ${returnSnippet} }`);\n    }\n  }\n  return `\n      fn writeBufferData(output_number: u32, indices: ${outputs[0].type.indices}, global_idx: u32) {\n        ${codeLines.join('\\n')}\n      }`;\n};\n\nconst createSplitProgramInfo = (inputs: readonly TensorView[], attributes: SplitAttributes): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const inputSize = ShapeUtil.size(inputShape);\n  const dataType = inputs[0].dataType;\n  const axis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);\n  const outputs = new Array<IndicesHelper>(attributes.numOutputs);\n  const input = inputVariable('input', dataType, inputShape.length);\n  const sizeInSplitAxis = new Array<number>(attributes.numOutputs);\n  const outputsTensorInfo: TensorInfo[] = [];\n  const outputShapes: number[][] = [];\n  let previousSum = 0;\n  const programUniforms: ProgramUniform[] = [{type: DataType.uint32, data: inputSize}];\n  for (let i = 0; i < attributes.numOutputs; i++) {\n    previousSum += attributes.splitSizes[i];\n    sizeInSplitAxis[i] = previousSum;\n    const outputShape = inputShape.slice();\n    outputShape[attributes.axis] = attributes.splitSizes[i];\n    outputShapes.push(outputShape);\n    outputs[i] = outputVariable(`output${i}`, dataType, outputShape.length);\n    outputsTensorInfo.push({dims: outputShapes[i], dataType: inputs[0].dataType});\n  }\n  programUniforms.push(\n      {type: DataType.uint32, data: sizeInSplitAxis}, ...createTensorShapeVariables(inputShape, ...outputShapes));\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  ${\n      shaderHelper.registerUniform('input_size', 'u32')\n          .registerUniform('size_in_split_axis', 'u32', sizeInSplitAxis.length)\n          .declareVariables(input, ...outputs)}\n  ${calculateOutputIndexImpl(sizeInSplitAxis.length)}\n  ${writeBufferDataImpl(outputs)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.input_size')}\n\n    var indices = ${input.offsetToIndices('global_idx')};\n    var index = ${input.indicesGet('indices', axis)};\n    let output_number = calculateOutputIndex(index);\n    if (output_number != 0) {\n      index -= ${getElementAt('uniforms.size_in_split_axis', 'output_number - 1u', sizeInSplitAxis.length)};\n      ${input.indicesSet('indices', axis, 'index')};\n    }\n    writeBufferData(output_number, indices, global_idx);\n  }`;\n  return {\n    name: 'Split',\n    shaderCache: {hint: attributes.cacheKey, inputDependencies: ['rank']},\n    getShaderSource,\n    getRunData: () => ({\n      outputs: outputsTensorInfo,\n      dispatchGroup: {x: Math.ceil(inputSize / 64 /* workgroup size */)},\n      programUniforms\n    })\n  };\n};\n\nexport const split = (context: ComputeContext, attributes: SplitAttributes): void => {\n  validateInputs(context.inputs);\n  const updatedAttributes =\n      context.inputs.length === 1 ? attributes : createSplitAttributesFromInputs(context.inputs, attributes);\n  context.compute(createSplitProgramInfo(context.inputs, updatedAttributes), {inputs: [0]});\n};\n\nexport const parseSplitAttributes = (attributes: Record<string, unknown>): SplitAttributes => {\n  const axis = attributes.axis as number;\n  const splitSizes: number[] = attributes.splitSizes as number[];\n  const numOutputs = attributes.numOutputs as number < 0 ? splitSizes.length : attributes.numOutputs as number;\n  if (numOutputs !== splitSizes.length) {\n    throw new Error('numOutputs and splitSizes lengh must be equal');\n  }\n  return createAttributeWithCacheKey({axis, numOutputs, splitSizes});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nconst getRepeats = (repeatsTensorView: TensorView): readonly number[] =>\n    Array.from(repeatsTensorView.getBigInt64Array(), Number);\n\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('Tile requires 2 inputs.');\n  }\n\n  if (inputs[0].dataType !== DataType.float && inputs[0].dataType !== DataType.int32 &&\n      inputs[0].dataType !== DataType.uint32) {\n    throw new Error('Tile only support float, int32, and uint32 data types');\n  }\n\n  if (inputs[1].dataType !== DataType.int64) {\n    throw new Error('Tile `repeats` input should be of int64 data type');\n  }\n\n  if (inputs[1].dims.length !== 1) {\n    throw new Error('Tile `repeats` input should be 1-D');\n  }\n\n  const repeats: readonly number[] = getRepeats(inputs[1]);\n\n  if (repeats.length !== inputs[0].dims.length) {\n    throw new Error('Tile `repeats` input should have same number of elements as rank of input data tensor');\n  }\n};\n\nconst getOutputShape = (inputShape: readonly number[], repeats: readonly number[]): readonly number[] => {\n  const outputShape: number[] = [];\n\n  for (let i = 0; i < inputShape.length; ++i) {\n    outputShape.push(inputShape[i] * repeats[i]);\n  }\n\n  return outputShape;\n};\n\nexport const createTileProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const repeats: readonly number[] = getRepeats(inputs[1]);\n  const outputShape = getOutputShape(inputShape, repeats);\n  const outputSize = ShapeUtil.size(outputShape);\n\n  const dataType = inputs[0].dataType;\n  const input = inputVariable('input', dataType, inputShape.length);\n  const output = outputVariable('output', dataType, outputShape.length);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n      const inputShape = ${input.indices(...inputShape)};\n      ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(input, output)}\n      ${shaderHelper.mainStart()}\n      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n      let output_indices = ${output.offsetToIndices('global_idx')};\n      var input_indices: ${input.type.indices};\n      for (var i = 0; i < ${inputShape.length}; i++) {\n        let input_dim_i = ${input.indicesGet('uniforms.input_shape', 'i')};\n        let input_dim_value = ${output.indicesGet('output_indices', 'i')}  % input_dim_i;\n\n        ${input.indicesSet('input_indices', 'i', 'input_dim_value')}\n      }\n      ${output.setByOffset('global_idx', input.getByIndices('input_indices'))}\n    }`;\n\n  return {\n    name: 'Tile',\n    shaderCache: {hint: `${repeats}`, inputDependencies: ['rank']},\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: inputs[0].dataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},\n      programUniforms:\n          [{type: DataType.uint32, data: outputSize}, ...createTensorShapeVariables(inputs[0].dims, outputShape)],\n    }),\n    getShaderSource,\n  };\n};\n\nexport const tile = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  context.compute(createTileProgramInfo(context.inputs), {inputs: [0]});\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {DataType} from '../../../wasm-common';\nimport {TensorView} from '../../tensor-view';\nimport {BroadcastUtil, ShapeUtil} from '../../util';\nimport {ComputeContext, ProgramInfo} from '../types';\n\nimport {createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper} from './common';\n\nconst createWhereOpProgramShader =\n    (shaderHelper: ShaderHelper, inputs: readonly TensorView[], dimsOutput: readonly number[], isBroadcast: boolean,\n     typeOutput: number) => {\n      const output = outputVariable('output_data', typeOutput, dimsOutput.length, 4);\n      const a = inputVariable('a_data', inputs[1].dataType, inputs[1].dims.length, 4);\n      const b = inputVariable('b_data', inputs[2].dataType, inputs[2].dims.length, 4);\n      const c = inputVariable('c_data', inputs[0].dataType, inputs[0].dims.length, 4);\n\n      let assignment: string;\n      const expression = (a: string, b: string, c: string) => `select(${b}, ${a}, ${c})`;\n      if (!isBroadcast) {\n        assignment = output.setByOffset(\n            'global_idx',\n            expression(a.getByOffset('global_idx'), b.getByOffset('global_idx'), c.getByOffset('global_idx')));\n      } else {\n        const singleAssignment = (resStr: string, x: number, typeCast = '') => {\n          const expressionA = `a_data[index_a${x}][component_a${x}]`;\n          const expressionB = `b_data[index_b${x}][component_b${x}]`;\n          // eslint-disable-next-line no-bitwise\n          const expressionC = `bool(c_data[index_c${x}] & (0xffu << (component_c${x} * 8)))`;\n          return `\n            let output_indices${x} = ${output.offsetToIndices(`global_idx * 4u + ${x}u`)};\n            let offset_a${x} = ${a.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n            let offset_b${x} = ${b.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n            let offset_c${x} = ${c.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n            let index_a${x} = offset_a${x} / 4u;\n            let index_b${x} = offset_b${x} / 4u;\n            let index_c${x} = offset_c${x} / 4u;\n            let component_a${x} = offset_a${x} % 4u;\n            let component_b${x} = offset_b${x} % 4u;\n            let component_c${x} = offset_c${x} % 4u;\n            ${resStr}[${x}] = ${typeCast}(${expression(expressionA, expressionB, expressionC)});\n          `;\n        };\n        if (typeOutput === DataType.bool) {\n          assignment = `\n            var data = vec4<u32>(0);\n            ${singleAssignment('data', 0, 'u32')}\n            ${singleAssignment('data', 1, 'u32')}\n            ${singleAssignment('data', 2, 'u32')}\n            ${singleAssignment('data', 3, 'u32')}\n            output_data[global_idx] = dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(data));`;\n        } else {\n          assignment = `\n            ${singleAssignment('output_data[global_idx]', 0)}\n            ${singleAssignment('output_data[global_idx]', 1)}\n            ${singleAssignment('output_data[global_idx]', 2)}\n            ${singleAssignment('output_data[global_idx]', 3)}\n          `;\n        }\n      }\n\n      return `\n        ${shaderHelper.registerUniform('vec_size', 'u32').declareVariables(c, a, b, output)}\n        ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.vec_size')}\n        ${assignment}\n      }`;\n    };\n\nconst createWhereOpProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const dimsA = inputs[1].dims;\n  const dimsB = inputs[2].dims;\n  const dimsC = inputs[0].dims;\n  const outputDataType = inputs[1].dataType;\n\n  const isBroadcast = !(ShapeUtil.areEqual(dimsA, dimsB) && ShapeUtil.areEqual(dimsB, dimsC));\n  let outputShape = dimsA;\n  let outputSize = ShapeUtil.size(dimsA);\n  // TODO: deal with zero-sized tensors (eg. dims=[1,0])\n\n  if (isBroadcast) {\n    const calculatedShape = BroadcastUtil.calcShape(BroadcastUtil.calcShape(dimsA, dimsB, false)!, dimsC, false);\n    if (!calculatedShape) {\n      throw new Error('Can\\'t perform where op on the given tensors');\n    }\n    outputShape = calculatedShape;\n    outputSize = ShapeUtil.size(outputShape);\n  }\n\n  const vecSize = Math.ceil(outputSize / 4);\n\n  return {\n    name: 'Where',\n    shaderCache: {inputDependencies: ['rank', 'rank', 'rank']},\n    getShaderSource: (shaderHelper) =>\n        createWhereOpProgramShader(shaderHelper, inputs, outputShape, isBroadcast, outputDataType),\n    getRunData: () => ({\n      outputs: [{dims: outputShape, dataType: outputDataType}],\n      dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */ / 4 /* vec size */)},\n      programUniforms:\n          [{type: DataType.uint32, data: vecSize}, ...createTensorShapeVariables(dimsC, dimsA, dimsB, outputShape)],\n    }),\n  };\n};\n\nexport const where = (context: ComputeContext): void => {\n  context.compute(createWhereOpProgramInfo(context.inputs));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {argMax, argMin, parseArgMinMaxAttributes} from './ops/argminmax';\nimport {attention} from './ops/attention';\nimport {batchNorm} from './ops/batch-norm';\nimport {biasAdd} from './ops/bias-add';\nimport {biasSplitGelu} from './ops/bias-split-gelu';\nimport * as binaryOps from './ops/binary-op';\nimport {concat, parseConcatAttributes} from './ops/concat';\nimport {conv, parseConvAttributes} from './ops/conv';\nimport {convTranspose, parseConvTransposeAttributes} from './ops/conv-transpose';\nimport {cumsum, parseCumSumAttributes} from './ops/cumsum';\nimport {depthToSpace, parseDepthToSpaceAttributes} from './ops/depth-to-space';\nimport {einsum, parseEinsumAttributes} from './ops/einsum';\nimport {expand} from './ops/expand';\nimport {fastGelu} from './ops/fast-gelu';\nimport {gather, parseGatherAttributes} from './ops/gather';\nimport {gatherElements, parseGatherElementsAttributes} from './ops/gather-elements';\nimport {gemm, parseGemmAttributes} from './ops/gemm';\nimport {instanceNorm} from './ops/instance-norm';\nimport {layerNorm} from './ops/layer-norm';\nimport {matMul} from './ops/matmul';\nimport {matMulNBits, parseMatMulNBitsAttributes} from './ops/matmulnbits';\nimport {multiHeadAttention, parseMultiHeadAttentionAttributes} from './ops/multihead-attentiion';\nimport {pad} from './ops/pad';\nimport * as pool from './ops/pool';\nimport {range} from './ops/range';\nimport {reduceL1, reduceL2, reduceLogSum, reduceLogSumExp, reduceMax, reduceMean, reduceMin, reduceProd, reduceSum, reduceSumSquare} from './ops/reduce';\nimport {parseResizeAttributes, resize} from './ops/resize';\nimport {rotaryEmbedding} from './ops/rotary-embedding';\nimport {skipLayerNorm} from './ops/skip-layer-norm';\nimport {parseSliceAttributes, slice} from './ops/slice';\nimport {parseSoftmaxAttributes, softmax} from './ops/softmax';\nimport {parseSplitAttributes, split} from './ops/split';\nimport {tile} from './ops/tile';\nimport {parseTransposeAttributes, transpose} from './ops/transpose';\nimport * as unaryOps from './ops/unary-op';\nimport {where} from './ops/where';\nimport {ComputeContext} from './types';\n\nexport type RunFunction = (context: ComputeContext, attribute?: unknown) => void;\nexport type ParseAttributeFunction = (attributeRaw: unknown) => unknown;\nexport type OperatorImplementation = [RunFunction]|[RunFunction, ParseAttributeFunction];\n\nexport const WEBGPU_OP_RESOLVE_RULES: Map<string, OperatorImplementation> = new Map([\n  ['Abs', [unaryOps.abs]],\n  ['Acos', [unaryOps.acos]],\n  ['Acosh', [unaryOps.acosh]],\n  ['Add', [binaryOps.add]],\n  ['ArgMax', [argMax, parseArgMinMaxAttributes]],\n  ['ArgMin', [argMin, parseArgMinMaxAttributes]],\n  ['Asin', [unaryOps.asin]],\n  ['Asinh', [unaryOps.asinh]],\n  ['Atan', [unaryOps.atan]],\n  ['Atanh', [unaryOps.atanh]],\n  ['Attention', [attention]],\n  // TODO: support new attributes for AveragePool-10\n  ['AveragePool', [pool.averagePool, pool.parseAveragePoolAttributes]],\n  ['BatchNormalization', [batchNorm]],\n  ['BiasAdd', [biasAdd]],\n  ['BiasSplitGelu', [biasSplitGelu]],\n  ['Cast', [unaryOps.cast, unaryOps.parseCastAttributes]],\n  ['Ceil', [unaryOps.ceil]],\n  ['Clip', [unaryOps.clip]],\n  ['Concat', [concat, parseConcatAttributes]],\n  ['Conv', [conv, parseConvAttributes]],\n  ['ConvTranspose', [convTranspose, parseConvTransposeAttributes]],\n  ['Cos', [unaryOps.cos]],\n  ['Cosh', [unaryOps.cosh]],\n  ['CumSum', [cumsum, parseCumSumAttributes]],\n  ['DepthToSpace', [depthToSpace, parseDepthToSpaceAttributes]],\n  ['Div', [binaryOps.div]],\n  ['Einsum', [einsum, parseEinsumAttributes]],\n  ['Elu', [unaryOps.elu, unaryOps.parseAlphaAttributes]],\n  ['Equal', [binaryOps.equal]],\n  ['Erf', [unaryOps.erf]],\n  ['Exp', [unaryOps.exp]],\n  ['Expand', [expand]],\n  ['FastGelu', [fastGelu]],\n  ['Floor', [unaryOps.floor]],\n  ['FusedConv', [conv, parseConvAttributes]],\n  ['Gather', [gather, parseGatherAttributes]],\n  ['GatherElements', [gatherElements, parseGatherElementsAttributes]],\n  ['Gelu', [unaryOps.gelu]],\n  ['Gemm', [gemm, parseGemmAttributes]],\n  ['GlobalAveragePool', [pool.globalAveragePool, pool.parseGlobalAveragePoolAttributes]],\n  ['GlobalMaxPool', [pool.globalMaxPool, pool.parseGlobalMaxPoolAttributes]],\n  ['Greater', [binaryOps.greater]],\n  ['GreaterOrEqual', [binaryOps.greaterOrEqual]],\n  ['HardSigmoid', [unaryOps.hardSigmoid, unaryOps.parseHardSigmoidAttributes]],\n  ['InstanceNormalization', [instanceNorm]],\n  ['LayerNormalization', [layerNorm]],\n  ['LeakyRelu', [unaryOps.leakyRelu, unaryOps.parseAlphaAttributes]],\n  ['Less', [binaryOps.less]],\n  ['LessOrEqual', [binaryOps.lessOrEqual]],\n  ['Log', [unaryOps.log]],\n  ['MatMul', [matMul]],\n  ['MatMulNBits', [matMulNBits, parseMatMulNBitsAttributes]],\n  // TODO: support new attributes for MaxPool-8 and MaxPool-10\n  ['MaxPool', [pool.maxPool, pool.parseMaxPoolAttributes]],\n  ['Mul', [binaryOps.mul]],\n  ['MultiHeadAttention', [multiHeadAttention, parseMultiHeadAttentionAttributes]],\n  ['Neg', [unaryOps.neg]],\n  ['Not', [unaryOps.not]],\n  ['Pad', [pad]],\n  ['Pow', [binaryOps.pow]],\n  ['Range', [range]],\n  ['Reciprocal', [unaryOps.reciprocal]],\n  ['ReduceMin', [reduceMin]],\n  ['ReduceMean', [reduceMean]],\n  ['ReduceMax', [reduceMax]],\n  ['ReduceSum', [reduceSum]],\n  ['ReduceProd', [reduceProd]],\n  ['ReduceL1', [reduceL1]],\n  ['ReduceL2', [reduceL2]],\n  ['ReduceLogSum', [reduceLogSum]],\n  ['ReduceLogSumExp', [reduceLogSumExp]],\n  ['ReduceSumSquare', [reduceSumSquare]],\n  ['Relu', [unaryOps.relu]],\n  ['Resize', [resize, parseResizeAttributes]],\n  ['RotaryEmbedding', [rotaryEmbedding]],\n  ['Sigmoid', [unaryOps.sigmoid]],\n  ['Sin', [unaryOps.sin]],\n  ['Sinh', [unaryOps.sinh]],\n  ['Slice', [slice, parseSliceAttributes]],\n  ['SkipLayerNormalization', [skipLayerNorm]],\n  ['Split', [split, parseSplitAttributes]],\n  ['Sqrt', [unaryOps.sqrt]],\n  ['Softmax', [softmax, parseSoftmaxAttributes]],\n  ['Sub', [binaryOps.sub]],\n  ['Tan', [unaryOps.tan]],\n  ['Tanh', [unaryOps.tanh]],\n  ['ThresholdedRelu', [unaryOps.thresholdedRelu, unaryOps.parseAlphaAttributes]],\n  ['Tile', [tile]],\n  ['Transpose', [transpose, parseTransposeAttributes]],\n  ['Where', [where]],\n]);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {TRACE_FUNC_BEGIN, TRACE_FUNC_END} from 'onnxruntime-common';\n\nimport {WebGpuBackend} from '../backend-webgpu';\nimport {LOG_DEBUG} from '../log';\n\nimport {createShaderHelper} from './ops/common';\nimport {Artifact, GpuData, ProgramInfo} from './types';\n\n/**\n * ProgramManager is the main class behind running computations\n * It builds ProgramInfo's into Artifacts\n * It compiles given ProgramInfo's into WebGL Prorams (cached as Artifacts)\n * Uses the artifact to run the computation by calling Draw on\n * the WebGL drawing buffer\n * ProgramManager automatically maps (binds) input variables to their\n * corresponding Location's in the binary program\n */\nexport class ProgramManager {\n  repo: Map<unknown, Artifact>;  // this should be per-session object\n  attributesBound: boolean;\n\n  constructor(private backend: WebGpuBackend) {\n    this.repo = new Map();\n    this.attributesBound = false;\n  }\n  getArtifact(key: unknown): Artifact|undefined {\n    return this.repo.get(key);\n  }\n  setArtifact(key: unknown, artifact: Artifact): void {\n    this.repo.set(key, artifact);\n  }\n  run(buildArtifact: Artifact, inputs: GpuData[], outputs: GpuData[], dispatchGroup: [number, number, number],\n      uniformBufferBinding: GPUBindingResource|undefined): void {\n    TRACE_FUNC_BEGIN(buildArtifact.programInfo.name);\n    const device = this.backend.device;\n    const computePassEncoder = this.backend.getComputePassEncoder();\n    this.backend.writeTimestamp(this.backend.pendingDispatchNumber * 2);\n    const entries = [];\n    for (const input of inputs) {\n      entries.push({binding: entries.length, resource: {buffer: input.buffer}});\n    }\n    for (const output of outputs) {\n      entries.push({binding: entries.length, resource: {buffer: output.buffer}});\n    }\n    if (uniformBufferBinding) {\n      entries.push({binding: entries.length, resource: uniformBufferBinding});\n    }\n    const bindGroup = device.createBindGroup(\n        {layout: buildArtifact.computePipeline.getBindGroupLayout(0), entries, label: buildArtifact.programInfo.name});\n\n    if (this.backend.sessionStatus === 'capturing') {\n      const commandInfo = {\n        kernelId: this.backend.currentKernelId!,\n        computePipeline: buildArtifact.computePipeline,\n        bindGroup,\n        dispatchGroup\n      };\n      const sessionCommandList = this.backend.capturedCommandList.get(this.backend.currentSessionId!);\n      sessionCommandList!.push(commandInfo);\n    }\n\n    computePassEncoder.setPipeline(buildArtifact.computePipeline);\n    computePassEncoder.setBindGroup(0, bindGroup);\n    computePassEncoder.dispatchWorkgroups(...dispatchGroup);\n    this.backend.writeTimestamp(this.backend.pendingDispatchNumber * 2 + 1);\n    this.backend.pendingDispatchNumber++;\n\n    if (this.backend.pendingDispatchNumber >= this.backend.maxDispatchNumber ||\n        this.backend.queryType === 'at-passes') {\n      this.backend.endComputePass();\n    }\n    if (this.backend.pendingDispatchNumber >= this.backend.maxDispatchNumber) {\n      this.backend.flush();\n    }\n    TRACE_FUNC_END(buildArtifact.programInfo.name);\n  }\n  dispose(): void {\n    // this.repo.forEach(a => this.glContext.deleteProgram(a.program));\n  }\n  build(programInfo: ProgramInfo, normalizedDispatchGroupSize: [number, number, number]): Artifact {\n    TRACE_FUNC_BEGIN(programInfo.name);\n    const device = this.backend.device;\n    const extensions: string[] = [];\n    if (device.features.has('shader-f16')) {\n      extensions.push('enable f16;');\n    }\n    const shaderHelper = createShaderHelper(normalizedDispatchGroupSize, this.backend.device.limits);\n    const userCode = programInfo.getShaderSource(shaderHelper);\n    const code = `${extensions.join('\\n')}\\n${shaderHelper.additionalImplementations}\\n${userCode}`;\n    const shaderModule = device.createShaderModule({code, label: programInfo.name});\n    LOG_DEBUG('verbose', () => `[WebGPU] ${programInfo.name} shader code: ${code}`);\n\n    const computePipeline = device.createComputePipeline(\n        {compute: {module: shaderModule, entryPoint: 'main'}, layout: 'auto', label: programInfo.name});\n\n    TRACE_FUNC_END(programInfo.name);\n    return {programInfo, computePipeline, uniformVariablesInfo: shaderHelper.variablesInfo};\n  }\n\n  normalizeDispatchGroupSize(dispatchGroup: ReturnType<ProgramInfo['getRunData']>['dispatchGroup']):\n      [number, number, number] {\n    const x = typeof dispatchGroup === 'number' ? dispatchGroup : dispatchGroup.x;\n    const y = typeof dispatchGroup === 'number' ? 1 : (dispatchGroup.y || 1);\n    const z = typeof dispatchGroup === 'number' ? 1 : (dispatchGroup.z || 1);\n    const limitPerDimension = this.backend.device.limits.maxComputeWorkgroupsPerDimension;\n    if (x <= limitPerDimension && y <= limitPerDimension && z <= limitPerDimension) {\n      return [x, y, z];\n    }\n    const size = x * y * z;\n    let dispatchAverage = Math.ceil(Math.sqrt(size));\n    if (dispatchAverage > limitPerDimension) {\n      dispatchAverage = Math.ceil(Math.cbrt(size));\n      if (dispatchAverage > limitPerDimension) {\n        throw new Error('Total dispatch size exceeds WebGPU maximum.');\n      }\n      return [dispatchAverage, dispatchAverage, dispatchAverage];\n    } else {\n      return [dispatchAverage, dispatchAverage, 1];\n    }\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Env, Tensor, TRACE, TRACE_FUNC_BEGIN, TRACE_FUNC_END} from 'onnxruntime-common';\n\nimport {DataType, tensorDataTypeEnumToString} from '../wasm-common';\n\nimport {configureLogger, LOG_DEBUG} from './log';\nimport {createView, TensorView} from './tensor-view';\nimport {createGpuDataManager, downloadGpuData, GpuDataManager} from './webgpu/gpu-data-manager';\nimport {RunFunction, WEBGPU_OP_RESOLVE_RULES} from './webgpu/op-resolve-rules';\nimport {ProgramManager} from './webgpu/program-manager';\nimport {AdapterInfo, ComputeContext, GpuArchitecture, GpuData, GpuVendor, ProgramInfo, ProgramInputTensorInfoDependency, SessionState, TimestampQuery} from './webgpu/types';\n\ninterface CommandInfo {\n  readonly kernelId: number;\n  readonly computePipeline: GPUComputePipeline;\n  readonly bindGroup: GPUBindGroup;\n  readonly dispatchGroup: [number, number, number];\n}\n\ninterface KernelInfo {\n  readonly kernelType: string;\n  readonly kernelName: string;\n  readonly kernelEntry: RunFunction;\n  readonly attributes: [((attribute: unknown) => unknown)|undefined, unknown];\n}\n\ninterface PendingKernelInfo {\n  readonly kernelId: number;\n  readonly programName: string;\n  readonly inputTensorViews: readonly TensorView[];\n  readonly outputTensorViews: readonly TensorView[];\n}\n\nconst getProgramInputTensorInfoDependencyKey =\n    (inputTensors: readonly TensorView[], inputDependencies: readonly ProgramInputTensorInfoDependency[]): string => {\n      if (inputDependencies.length !== inputTensors.length) {\n        throw new Error(`inputDependencies length ${inputDependencies.length} is not equal to inputTensors length ${\n            inputTensors.length}.`);\n      }\n\n      const inputInfos: string[] = [];\n      for (let i = 0; i < inputTensors.length; ++i) {\n        const type = inputTensors[i].dataType;\n        switch (inputDependencies[i]) {\n          case 'none': {\n            inputInfos.push('');\n            break;\n          }\n          case 'type': {\n            inputInfos.push(`${type}`);\n            break;\n          }\n          case 'rank': {\n            const rank = inputTensors[i].dims.length;\n            inputInfos.push(`${type};${rank}`);\n            break;\n          }\n          case 'dims': {\n            const dims = inputTensors[i].dims.join(',');\n            inputInfos.push(`${type};${dims}`);\n            break;\n          }\n          default:\n            throw new Error(`unsupported input dependency: ${inputDependencies[i]}`);\n        }\n      }\n\n      return inputInfos.join('|');\n    };\n\n/**\n * get a unique key representing the program from the program info, input shapes and types.\n *\n * @returns a unique key is a shorter string than the shader source, which contains all the information to identify a\n * program. if the key is the same, the program shader source should be the same, so we can reuse the program.\n *\n */\nconst getProgramInfoUniqueKey =\n    (programInfo: ProgramInfo, inputTensors: readonly TensorView[], is1DimensionDispatch: boolean): string => {\n      // final key format:\n      // <PROGRAM_NAME>[<PROGRAM_CUSTOM_CACHE_HINT>]:is1DimensionDispatch:<INPUTS_INFO_0>|<INPUTS_INFO_1>|...\n      let key = programInfo.name;\n      if (programInfo.shaderCache?.hint) {\n        key += '[' + programInfo.shaderCache.hint + ']';\n      }\n      key += ':' + is1DimensionDispatch +\n          `:${\n                 getProgramInputTensorInfoDependencyKey(\n                     inputTensors,\n                     programInfo.shaderCache?.inputDependencies ??\n                         new Array<ProgramInputTensorInfoDependency>(inputTensors.length).fill('dims'))}`;\n      return key;\n    };\n\nclass AdapterInfoImpl implements AdapterInfo {\n  readonly architecture?: string;\n  readonly vendor?: string;\n\n  constructor(adapterInfo: GPUAdapterInfo) {\n    if (adapterInfo) {\n      this.architecture = adapterInfo.architecture;\n      this.vendor = adapterInfo.vendor;\n    }\n  }\n\n  isArchitecture(architecture: GpuArchitecture): boolean {\n    return this.architecture === architecture;\n  }\n\n  isVendor(vendor: GpuVendor): boolean {\n    return this.vendor === vendor;\n  }\n}\n\n/**\n * this class is designed to store status and being used as a singleton for JSEP. It will be passed to jsepInit() as\n * the first parameter so that it is stored for future use.\n */\nexport class WebGpuBackend {\n  adapterInfo: AdapterInfoImpl;\n  device: GPUDevice;\n  /**\n   * an instance of GpuDataManager to manage a GpuDataId -> GpuBuffer mapping\n   */\n  gpuDataManager: GpuDataManager;\n  /**\n   * an instance of ProgramManager to build and run WebGPU compute shader program, and manage a ProgramKey -> Program\n   * artifacts mapping\n   */\n  programManager: ProgramManager;\n\n  /**\n   * representing the session ID of which is currently being run.\n   * `null` means no session is being run.\n   * only valid when session.run is executed.\n   */\n  currentSessionId: number|null = null;\n\n  /**\n   * representing the kernel ID of which is currently being computed (CPU code perspective).\n   * `null` means no kernel is being computed.\n   * only one kernel can be computed at a moment.\n   */\n  currentKernelId: number|null = null;\n  /**\n   * a list of temporary GPU data for the current kernel. should release when the kernel done computation.\n   */\n  private temporaryData: GpuData[];\n  /**\n   * a KernelID -> a GPU data list, which stores persistent GPU data owned by the specific kernel.\n   */\n  private kernelPersistentData: Map<number, GpuData[]>;\n  /**\n   * a KernelID -> a custom data, which stores custom data owned by the specific kernel.\n   */\n  private kernelCustomData: Map<number, {[key: string]: unknown}>;\n  /**\n   * get the custom data of the current kernel\n   */\n  get currentKernelCustomData(): {[key: string]: unknown} {\n    if (this.currentKernelId === null) {\n      throw new Error('currentKernelCustomData(): currentKernelId is null. (should not happen)');\n    }\n\n    let data = this.kernelCustomData.get(this.currentKernelId);\n    if (!data) {\n      data = {};\n      this.kernelCustomData.set(this.currentKernelId, data);\n    }\n\n    return data;\n  }\n\n  // KernelID -> kernelInfo mapping\n  kernels: Map<number, KernelInfo>;\n  private commandEncoder: GPUCommandEncoder|null = null;\n  private computePassEncoder: GPUComputePassEncoder|null = null;\n  maxDispatchNumber = 16;\n  pendingDispatchNumber = 0;\n\n  // info of kernels pending submission for a single batch\n  private pendingKernels: PendingKernelInfo[] = [];\n  // queryReadBuffer -> pendingKernels mapping for all the batches\n  private pendingQueries: Map<GPUBuffer, PendingKernelInfo[]> = new Map();\n  private queryResolveBuffer?: GPUBuffer;\n  private querySet?: GPUQuerySet;\n  private queryTimeBase?: bigint;\n  queryType: TimestampQuery;\n\n  env: Env;\n  sessionStatus: SessionState = 'default';\n  /**\n   * a SessionID -> CommandInfo[] mapping. It's used to record all GPU commands for corresponding session.\n   */\n  capturedCommandList: Map<number, CommandInfo[]> = new Map();\n\n  /**\n   * a SessionID -> PendingKernelInfo[] mapping for profiling.\n   */\n  private capturedPendingKernels: Map<number, PendingKernelInfo[]> = new Map();\n\n  /**\n   * a SessionID -> a Map of (InputOutputIndex -> [ID, GPUBuffer]) mapping.\n   */\n  sessionExternalDataMapping: Map<number, Map<number, [number, GPUBuffer]>> = new Map();\n\n  async initialize(env: Env, adapter: GPUAdapter): Promise<void> {\n    this.env = env;\n    const requiredFeatures: GPUFeatureName[] = [];\n    const deviceDescriptor: GPUDeviceDescriptor = {\n      requiredLimits: {\n        maxComputeWorkgroupStorageSize: adapter.limits.maxComputeWorkgroupStorageSize,\n        maxComputeWorkgroupsPerDimension: adapter.limits.maxComputeWorkgroupsPerDimension,\n        maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,\n        maxBufferSize: adapter.limits.maxBufferSize,\n        maxComputeInvocationsPerWorkgroup: adapter.limits.maxComputeInvocationsPerWorkgroup,\n        maxComputeWorkgroupSizeX: adapter.limits.maxComputeWorkgroupSizeX,\n        maxComputeWorkgroupSizeY: adapter.limits.maxComputeWorkgroupSizeY,\n        maxComputeWorkgroupSizeZ: adapter.limits.maxComputeWorkgroupSizeZ,\n      },\n      requiredFeatures,\n    };\n\n    if (adapter.features.has('chromium-experimental-timestamp-query-inside-passes')) {\n      requiredFeatures.push('chromium-experimental-timestamp-query-inside-passes' as GPUFeatureName);\n    } else if (adapter.features.has('timestamp-query')) {\n      requiredFeatures.push('timestamp-query');\n    }\n    if (adapter.features.has('shader-f16')) {\n      requiredFeatures.push('shader-f16');\n    }\n\n    this.device = await adapter.requestDevice(deviceDescriptor);\n    this.adapterInfo = new AdapterInfoImpl(await adapter.requestAdapterInfo());\n    this.gpuDataManager = createGpuDataManager(this);\n    this.programManager = new ProgramManager(this);\n    this.kernels = new Map();\n    this.kernelPersistentData = new Map();\n    this.kernelCustomData = new Map();\n\n    // set up flags for logger\n    configureLogger(env.logLevel!, !!env.debug);\n\n    // TODO: set up flags\n\n    this.device.onuncapturederror = ev => {\n      if (ev.error instanceof GPUValidationError) {\n        // eslint-disable-next-line no-console\n        console.error(`An uncaught WebGPU validation error was raised: ${ev.error.message}`);\n      }\n    };\n\n    Object.defineProperty(\n        this.env.webgpu, 'device', {value: this.device, writable: false, enumerable: true, configurable: false});\n    Object.defineProperty(\n        this.env.webgpu, 'adapter', {value: adapter, writable: false, enumerable: true, configurable: false});\n\n    // init queryType, which is necessary for InferenceSession.create\n    this.setQueryType();\n  }\n\n  dispose(): void {\n    if (typeof this.querySet !== 'undefined') {\n      this.querySet.destroy();\n    }\n    this.gpuDataManager.dispose();\n  }\n\n  getCommandEncoder(): GPUCommandEncoder {\n    if (!this.commandEncoder) {\n      this.commandEncoder = this.device.createCommandEncoder();\n    }\n    return this.commandEncoder;\n  }\n\n  getComputePassEncoder(): GPUComputePassEncoder {\n    if (!this.computePassEncoder) {\n      const commandEncoder = this.getCommandEncoder();\n      const computePassDescriptor: GPUComputePassDescriptor = {};\n\n      if (this.queryType === 'at-passes') {\n        computePassDescriptor.timestampWrites = {\n          querySet: this.querySet!,\n          beginningOfPassWriteIndex: this.pendingDispatchNumber * 2,\n          endOfPassWriteIndex: this.pendingDispatchNumber * 2 + 1,\n        };\n      }\n\n      this.computePassEncoder = commandEncoder.beginComputePass(computePassDescriptor);\n    }\n    return this.computePassEncoder;\n  }\n\n  endComputePass(): void {\n    if (this.computePassEncoder) {\n      this.computePassEncoder.end();\n      this.computePassEncoder = null;\n    }\n  }\n\n  flush(): void {\n    if (!this.commandEncoder) {\n      return;\n    }\n\n    TRACE_FUNC_BEGIN();\n\n    this.endComputePass();\n    let queryReadBuffer: GPUBuffer;\n    if (this.queryType !== 'none') {\n      this.commandEncoder.resolveQuerySet(\n          this.querySet!, 0, this.pendingDispatchNumber * 2, this.queryResolveBuffer!, 0);\n\n      queryReadBuffer = this.device.createBuffer(\n          // eslint-disable-next-line no-bitwise\n          {size: this.pendingDispatchNumber * 2 * 8, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST});\n\n      this.pendingQueries.set(queryReadBuffer, this.pendingKernels);\n      this.pendingKernels = [];\n      this.commandEncoder.copyBufferToBuffer(\n          this.queryResolveBuffer!, 0, queryReadBuffer, 0, this.pendingDispatchNumber * 2 * 8);\n    }\n\n    this.device.queue.submit([this.commandEncoder.finish()]);\n    this.gpuDataManager.refreshPendingBuffers();\n    this.commandEncoder = null;\n    this.pendingDispatchNumber = 0;\n\n    if (this.queryType !== 'none') {\n      void queryReadBuffer!.mapAsync(GPUMapMode.READ).then(() => {\n        const mappedData = new BigUint64Array(queryReadBuffer.getMappedRange());\n        const pendingKernels = this.pendingQueries.get(queryReadBuffer)!;\n        for (let i = 0; i < mappedData.length / 2; i++) {\n          const pendingKernelInfo = pendingKernels[i];\n          const kernelId = pendingKernelInfo.kernelId;\n          const kernelInfo = this.kernels.get(kernelId)!;\n          const kernelType = kernelInfo.kernelType;\n          const kernelName = kernelInfo.kernelName;\n          const programName = pendingKernelInfo.programName;\n          const inputTensorViews = pendingKernelInfo.inputTensorViews;\n          const outputTensorViews = pendingKernelInfo.outputTensorViews;\n          const startTimeU64 = mappedData[i * 2];\n          const endTimeU64 = mappedData[i * 2 + 1];\n\n          if (typeof this.queryTimeBase === 'undefined') {\n            this.queryTimeBase = startTimeU64;\n          }\n\n          const startTime = Number(startTimeU64 - this.queryTimeBase);\n          const endTime = Number(endTimeU64 - this.queryTimeBase);\n\n          if (!Number.isSafeInteger(startTime) || !Number.isSafeInteger(endTime)) {\n            throw new RangeError('incorrect timestamp range');\n          }\n\n          if (this.env.webgpu.profiling?.ondata) {\n            this.env.webgpu.profiling.ondata({\n              version: 1,\n              inputsMetadata: inputTensorViews.map(\n                  value => ({dims: value.dims, dataType: tensorDataTypeEnumToString(value.dataType)})),\n              outputsMetadata: outputTensorViews.map(\n                  value => ({dims: value.dims, dataType: tensorDataTypeEnumToString(value.dataType)})),\n              kernelId,\n              kernelType,\n              kernelName,\n              programName,\n              startTime,\n              endTime,\n            });\n          } else {\n            // if no callback is provided, print the profiling message to console\n            let inputShapes = '';\n            inputTensorViews.forEach((value, i) => {\n              inputShapes += `input[${i}]: [${value.dims}] | ${tensorDataTypeEnumToString(value.dataType)}, `;\n            });\n            let outputShapes = '';\n            outputTensorViews.forEach((value, i) => {\n              outputShapes += `output[${i}]: [${value.dims}] | ${tensorDataTypeEnumToString(value.dataType)}, `;\n            });\n            // eslint-disable-next-line no-console\n            console.log(`[profiling] kernel \"${kernelId}|${kernelType}|${kernelName}|${programName}\" ${inputShapes}${\n                outputShapes}execution time: ${endTime - startTime} ns`);\n          }\n          TRACE('GPU', `${programName}::${startTimeU64}::${endTimeU64}`);\n        }\n        queryReadBuffer.unmap();\n        this.pendingQueries.delete(queryReadBuffer);\n      });\n    }\n    TRACE_FUNC_END();\n  }\n\n  /**\n   * run a WebGPU program.\n   * @param program a ProgramInfo instance\n   * @param inputTensorViews a TensorView array. each element represents a value already exists in GPU.\n   * @param outputIndices an indices array. each element can be either -1 (temporary data), -2 (persistent data) or an\n   * index to the kernel's output.\n   * @param createKernelOutput a callback function that create a value to kernel's output with the given index\n   * @param createIntermediateOutput a callback function that create a value as a intermediate value, either temporary\n   * or persistent (owned by the current kernel)\n   * @returns a TensorView array representing the result.\n   */\n  run(program: ProgramInfo, inputTensorViews: readonly TensorView[], outputIndices: readonly number[],\n      createKernelOutput: (index: number, dataType: number, dims: readonly number[]) => TensorView,\n      createIntermediateOutput: (dataType: number, dims: readonly number[]) => TensorView,\n      outputCount: number): TensorView[] {\n    TRACE_FUNC_BEGIN(program.name);\n    // create info for inputs\n    const inputDatas: GpuData[] = [];\n    for (let i = 0; i < inputTensorViews.length; ++i) {\n      const data = inputTensorViews[i].data;\n      // if tensor view data is 0, it means the output is zero-sized tensor, and there is no GPU data for it.\n      if (data === 0) {\n        continue;\n      }\n      const gpuData = this.gpuDataManager.get(data);\n      if (!gpuData) {\n        throw new Error(`no GPU data for input: ${data}`);\n      }\n      inputDatas.push(gpuData);\n    }\n\n    const {outputs, dispatchGroup, programUniforms} = program.getRunData(inputTensorViews);\n\n    // check output indices\n    const validatedOutputIndices = outputIndices.length === 0 ? outputs.map((_, i) => i) : outputIndices;\n    if (validatedOutputIndices.length !== outputs.length) {\n      throw new Error(`Output size ${validatedOutputIndices.length} must be equal to ${outputs.length}.`);\n    }\n\n    // create info for outputs\n    const outputTensorViews: TensorView[] = [];\n    const outputDatas: GpuData[] = [];\n    for (let i = 0; i < outputs.length; ++i) {\n      // value -1 and -2 are used for creating temporary and persistent outputs.\n      // value -3 is used for placeholder output. So -3, -2, -1 and 0, 1, 2, ... are valid\n      // output indices. see type definition of ComputeContextInputsOutputsMapping for more details.\n      if (!Number.isInteger(validatedOutputIndices[i]) || validatedOutputIndices[i] < -3 ||\n          validatedOutputIndices[i] >= outputCount) {\n        throw new Error(`Invalid output index: ${validatedOutputIndices[i]}`);\n      }\n      if (validatedOutputIndices[i] === -3) {\n        continue;\n      }\n      const isTemporary = validatedOutputIndices[i] === -1;\n      const isPersistent = validatedOutputIndices[i] === -2;\n      const tensorView = (isTemporary || isPersistent) ?\n          createIntermediateOutput(outputs[i].dataType, outputs[i].dims) :\n          createKernelOutput(validatedOutputIndices[i], outputs[i].dataType, outputs[i].dims);\n      outputTensorViews.push(tensorView);\n      // if tensor view data is 0, it means the output is zero-sized tensor, and there is no GPU data for it.\n      if (tensorView.data === 0) {\n        continue;\n      }\n      const gpuData = this.gpuDataManager.get(tensorView.data);\n      if (!gpuData) {\n        throw new Error(`no GPU data for output: ${tensorView.data}`);\n      }\n      if (isTemporary) {\n        this.temporaryData.push(gpuData);\n      }\n      if (isPersistent) {\n        let persistentData = this.kernelPersistentData.get(this.currentKernelId!);\n        if (!persistentData) {\n          persistentData = [];\n          this.kernelPersistentData.set(this.currentKernelId!, persistentData);\n        }\n        persistentData.push(gpuData);\n      }\n      outputDatas.push(gpuData);\n    }\n\n    // when there are any zero-sized tensor in the inputs or outputs, we should report error unless all outputs are\n    // zero-sized tensors.\n    if (inputDatas.length !== inputTensorViews.length || outputDatas.length !== outputTensorViews.length) {\n      // if all outputs are zero-sized tensors, there is no need to run the program.\n      if (outputDatas.length === 0) {\n        TRACE_FUNC_END(program.name);\n        return outputTensorViews;\n      }\n      // if some outputs are zero-sized tensors, report an error.\n      //\n      // TODO: so far we don't see any use case that outputs include both zero-sized tensors and non-zero-sized tensors.\n      // If we see such use case, we need to make a change here to support it.\n      throw new Error(\n          `Program ${program.name} has zero-sized tensor(s) in inputs or outputs. This is not supported now.`);\n    }\n\n    // load uniforms\n    // TODO: add cache for uniform (is it necessary?)\n    //\n    let uniformBufferBinding: GPUBindingResource|undefined;\n    if (programUniforms) {\n      let currentOffset = 0;\n      const offsets: number[] = [];\n\n      programUniforms.forEach(v => {\n        const data = typeof v.data === 'number' ? [v.data] : v.data;\n        if (data.length === 0) {\n          return;\n        }\n        // https://www.w3.org/TR/WGSL/#alignof\n        const sizeOfElement = v.type === DataType.float16 ? 2 : 4;\n        let sizeOfVecOrMat;\n        let baseAlignment;\n        if (v.type === DataType.float16) {\n          baseAlignment = data.length > 4 ? 16 : (data.length > 2 ? 8 : data.length * sizeOfElement);\n          sizeOfVecOrMat = data.length > 4 ? 16 : sizeOfElement * data.length;\n        } else {\n          baseAlignment = data.length <= 2 ? data.length * sizeOfElement : 16;\n          sizeOfVecOrMat = 16;\n        }\n        currentOffset = Math.ceil(currentOffset / baseAlignment) * baseAlignment;\n        offsets.push(currentOffset);\n        // For non-float16 type, when data.length > 4, the uniform variable is of type array<vec4<i32|u32|f32>,N>, where\n        // N = Math.ceil(data.length / 4) and SizeOf(vec4<i32|u32|f32>) = 16. The total byte length is N *\n        // SizeOf(vec4<i32|u32|f32>). For float16 type, when data.length > 4, the uniform variable is of type\n        // array<mat2x4<f16>,N>, where N = Math.ceil(data.length / 8) and SizeOf(mat2x4<f16>) = 16. The total byte\n        // length is N * SizeOf(mat2x4<f16>).\n        const elementPerVecOrMat = v.type === DataType.float16 ? 8 : 4;\n        currentOffset += data.length > 4 ? Math.ceil(data.length / elementPerVecOrMat) * sizeOfVecOrMat :\n                                           data.length * sizeOfElement;\n      });\n\n      // Meet alignment of struct here: https://www.w3.org/TR/WGSL/#alignment-and-size. For simplicity, set\n      // maxAlignmentOfField to 16 since the underlying buffer has been rounded up to 16.\n      const maxAlignmentOfField = 16;\n      currentOffset = Math.ceil(currentOffset / maxAlignmentOfField) * maxAlignmentOfField;\n      const arrayBuffer = new ArrayBuffer(currentOffset);\n      programUniforms.forEach((v, i) => {\n        const offset = offsets[i];\n        const data = typeof v.data === 'number' ? [v.data] : v.data;\n        if (v.type === DataType.int32) {\n          new Int32Array(arrayBuffer, offset, data.length).set(data);\n        } else if (v.type === DataType.uint32) {\n          new Uint32Array(arrayBuffer, offset, data.length).set(data);\n        } else if (v.type === DataType.float16) {\n          // TODO: use Float16Array.\n          new Uint16Array(arrayBuffer, offset, data.length).set(data);\n        } else if (v.type === DataType.float) {\n          new Float32Array(arrayBuffer, offset, data.length).set(data);\n        } else {\n          throw new Error(`Unsupported uniform type: ${tensorDataTypeEnumToString(v.type)}`);\n        }\n      });\n\n      const uniformBufferData =\n          // eslint-disable-next-line no-bitwise\n          this.gpuDataManager.create(currentOffset, GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM);\n      this.device.queue.writeBuffer(uniformBufferData.buffer, 0, arrayBuffer, 0, currentOffset);\n      this.gpuDataManager.release(uniformBufferData.id);\n      uniformBufferBinding = {offset: 0, size: currentOffset, buffer: uniformBufferData.buffer};\n    }\n\n    const normalizedDispatchGroup = this.programManager.normalizeDispatchGroupSize(dispatchGroup);\n    const is1DimensionDispatch = normalizedDispatchGroup[1] === 1 && normalizedDispatchGroup[2] === 1;\n    // get program info\n    const key = getProgramInfoUniqueKey(program, inputTensorViews, is1DimensionDispatch);\n    let artifact = this.programManager.getArtifact(key);\n    if (!artifact) {\n      artifact = this.programManager.build(program, normalizedDispatchGroup);\n      this.programManager.setArtifact(key, artifact);\n      LOG_DEBUG('info', () => `[artifact] key: ${key}, programName: ${program.name}`);\n    }\n\n    // validate uniform variables\n    if (programUniforms && artifact.uniformVariablesInfo) {\n      if (programUniforms.length !== artifact.uniformVariablesInfo.length) {\n        throw new Error(`Uniform variables count mismatch: expect ${artifact.uniformVariablesInfo.length}, got ${\n            programUniforms.length} in program \"${artifact.programInfo.name}\".`);\n      }\n      for (let i = 0; i < programUniforms.length; i++) {\n        const uniform = programUniforms[i];\n        const actualType = uniform.type;\n        const actualLength = typeof uniform.data === 'number' ? 1 : uniform.data.length;\n        const [type, length] = artifact.uniformVariablesInfo[i];\n        if (actualType !== type || actualLength !== length) {\n          throw new Error(`Uniform variable ${i} mismatch: expect type ${type} with size ${length}, got type ${\n              actualType} with size ${actualLength} in program \"${artifact.programInfo.name}\".`);\n        }\n      }\n    }\n\n    LOG_DEBUG(\n        'info',\n        () => `[ProgramManager] run \"${program.name}\" (key=${key}) with ${normalizedDispatchGroup[0]}x${\n            normalizedDispatchGroup[1]}x${normalizedDispatchGroup[2]}`);\n\n    if (this.queryType !== 'none' || this.sessionStatus === 'capturing') {\n      const pendingKernelInfo: PendingKernelInfo = {\n        kernelId: this.currentKernelId!,\n        programName: artifact.programInfo.name,\n        inputTensorViews,\n        outputTensorViews,\n      };\n      this.pendingKernels.push(pendingKernelInfo);\n\n      if (this.sessionStatus === 'capturing') {\n        const sessionPendingKernels = this.capturedPendingKernels.get(this.currentSessionId!);\n        sessionPendingKernels!.push(pendingKernelInfo);\n      }\n    }\n\n    this.programManager.run(artifact, inputDatas, outputDatas, normalizedDispatchGroup, uniformBufferBinding);\n\n    TRACE_FUNC_END(program.name);\n    return outputTensorViews;\n  }\n\n  upload(gpuDataId: number, data: Uint8Array): void {\n    this.gpuDataManager.upload(gpuDataId, data);\n  }\n\n  memcpy(src: number, dst: number): void {\n    this.gpuDataManager.memcpy(src, dst);\n  }\n\n  async download(gpuDataId: number, getTargetBuffer: () => Uint8Array): Promise<void> {\n    // the underlying buffer may be changed after the async function is called. so we use a getter function to make sure\n    // the buffer is up-to-date.\n    await this.gpuDataManager.download(gpuDataId, getTargetBuffer);\n  }\n\n  alloc(size: number): number {\n    return this.gpuDataManager.create(size).id;\n  }\n\n  free(ptr: number): number {\n    return this.gpuDataManager.release(ptr);\n  }\n\n  createKernel(kernelType: string, kernelId: number, attribute: unknown, kernelName: string): void {\n    const op = WEBGPU_OP_RESOLVE_RULES.get(kernelType);\n    if (!op) {\n      throw new Error(`kernel not implemented: ${kernelType}`);\n    }\n\n    const kernelInfo: KernelInfo = {\n      kernelType,\n      kernelName,\n      kernelEntry: op[0],\n      attributes: [op[1], attribute],\n    };\n    this.kernels.set(kernelId, kernelInfo);\n  }\n\n  releaseKernel(kernelId: number): void {\n    const persistentData = this.kernelPersistentData.get(kernelId);\n    if (persistentData) {\n      for (const data of persistentData) {\n        this.gpuDataManager.release(data.id);\n      }\n      this.kernelPersistentData.delete(kernelId);\n    }\n\n    this.kernelCustomData.delete(kernelId);\n    this.kernels.delete(kernelId);\n  }\n\n  computeKernel(kernelId: number, context: ComputeContext, errors: Array<Promise<string|null>>): number {\n    const kernel = this.kernels.get(kernelId);\n    if (!kernel) {\n      throw new Error(`kernel not created: ${kernelId}`);\n    }\n    const kernelType = kernel.kernelType;\n    const kernelName = kernel.kernelName;\n    const kernelEntry = kernel.kernelEntry;\n    const attributes = kernel.attributes;\n    if (this.currentKernelId !== null) {\n      throw new Error(`kernel \"[${kernelType}] ${kernelName}\" is not allowed to be called recursively`);\n    }\n    this.currentKernelId = kernelId;\n\n    // parse attributes if necessary\n    if (attributes[0]) {\n      attributes[1] = attributes[0](attributes[1]);\n      attributes[0] = undefined;\n    }\n\n    LOG_DEBUG('info', () => `[WebGPU] Start to run kernel \"[${kernelType}] ${kernelName}\"...`);\n\n    const useErrorScope = this.env.debug;\n\n    this.temporaryData = [];\n    try {\n      if (useErrorScope) {\n        this.device.pushErrorScope('validation');\n      }\n\n      kernelEntry(context, attributes[1]);\n      return 0;  // ORT_OK\n    } catch (e) {\n      errors.push(Promise.resolve(`[WebGPU] Kernel \"[${kernelType}] ${kernelName}\" failed. ${e}`));\n      return 1;  // ORT_FAIL\n    } finally {\n      if (useErrorScope) {\n        errors.push(this.device.popErrorScope().then(\n            err => err ? `GPU validation error for kernel \"[${kernelType}] ${kernelName}\": ${err.message}` : null));\n      }\n\n      for (const data of this.temporaryData) {\n        this.gpuDataManager.release(data.id);\n      }\n      this.temporaryData = [];\n      this.currentKernelId = null;\n    }\n  }\n\n  // #region external buffer\n  registerBuffer(sessionId: number, index: number, buffer: GPUBuffer, size: number): number {\n    let sessionInputOutputMapping = this.sessionExternalDataMapping.get(sessionId);\n    if (!sessionInputOutputMapping) {\n      sessionInputOutputMapping = new Map();\n      this.sessionExternalDataMapping.set(sessionId, sessionInputOutputMapping);\n    }\n\n    const previousBuffer = sessionInputOutputMapping.get(index);\n    const id = this.gpuDataManager.registerExternalBuffer(buffer, size, previousBuffer?.[1]);\n    sessionInputOutputMapping.set(index, [id, buffer]);\n    return id;\n  }\n  unregisterBuffers(sessionId: number): void {\n    const sessionInputOutputMapping = this.sessionExternalDataMapping.get(sessionId);\n    if (sessionInputOutputMapping) {\n      sessionInputOutputMapping.forEach(bufferInfo => this.gpuDataManager.unregisterExternalBuffer(bufferInfo[1]));\n      this.sessionExternalDataMapping.delete(sessionId);\n    }\n  }\n  getBuffer(gpuDataId: number): GPUBuffer {\n    const gpuData = this.gpuDataManager.get(gpuDataId);\n    if (!gpuData) {\n      throw new Error(`no GPU data for buffer: ${gpuDataId}`);\n    }\n    return gpuData.buffer;\n  }\n  createDownloader(gpuBuffer: GPUBuffer, size: number, type: Tensor.GpuBufferDataTypes):\n      () => Promise<Tensor.DataType> {\n    return async () => {\n      const data = await downloadGpuData(this, gpuBuffer, size);\n      return createView(data.buffer, type);\n    };\n  }\n  // #endregion\n  writeTimestamp(index: number): void {\n    if (this.queryType !== 'inside-passes') {\n      return;\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (this.computePassEncoder as any).writeTimestamp(this.querySet, index);\n  }\n  setQueryType(): void {\n    this.queryType = 'none';\n    if (this.env.webgpu.profiling?.mode === 'default' ||\n        (typeof this.env.trace === 'undefined' ? this.env.wasm.trace : this.env.trace)) {\n      if (this.device.features.has('chromium-experimental-timestamp-query-inside-passes')) {\n        this.queryType = 'inside-passes';\n      } else if (this.device.features.has('timestamp-query')) {\n        this.queryType = 'at-passes';\n      }\n\n      if (this.queryType !== 'none' && typeof this.querySet === 'undefined') {\n        this.querySet = this.device.createQuerySet({\n          type: 'timestamp',\n          count: this.maxDispatchNumber * 2,\n        });\n        this.queryResolveBuffer = this.device.createBuffer(\n            // eslint-disable-next-line no-bitwise\n            {size: this.maxDispatchNumber * 2 * 8, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE});\n      }\n    }\n  }\n\n  captureBegin(): void {\n    LOG_DEBUG('info', 'captureBegin');\n    if (!this.capturedCommandList.get(this.currentSessionId!)) {\n      this.capturedCommandList.set(this.currentSessionId!, []);\n    }\n    if (!this.capturedPendingKernels.get(this.currentSessionId!)) {\n      this.capturedPendingKernels.set(this.currentSessionId!, []);\n    }\n    // flush the left commands before we change the status.\n    this.flush();\n    this.sessionStatus = 'capturing';\n  }\n  captureEnd(): void {\n    LOG_DEBUG('info', 'captureEnd');\n    // flush the left commands before we change the status.\n    this.flush();\n    this.sessionStatus = 'default';\n  }\n  replay(): void {\n    LOG_DEBUG('info', 'replay');\n    this.sessionStatus = 'replaying';\n    const sessionCommandList = this.capturedCommandList.get(this.currentSessionId!);\n    const sessionPendingKernels = this.capturedPendingKernels.get(this.currentSessionId!);\n    const length = sessionCommandList!.length;\n    this.pendingKernels = [];\n    for (let i = 0; i < length; i++) {\n      const computePassEncoder = this.getComputePassEncoder();\n      const command = sessionCommandList![i];\n      this.writeTimestamp(this.pendingDispatchNumber * 2);\n      computePassEncoder.setPipeline(command.computePipeline);\n      computePassEncoder.setBindGroup(0, command.bindGroup);\n      computePassEncoder.dispatchWorkgroups(...command.dispatchGroup);\n      this.writeTimestamp(this.pendingDispatchNumber * 2 + 1);\n      this.pendingDispatchNumber++;\n      if (this.queryType !== 'none') {\n        this.pendingKernels.push(sessionPendingKernels![i]);\n      }\n      if (this.pendingDispatchNumber >= this.maxDispatchNumber || this.queryType === 'at-passes') {\n        this.endComputePass();\n      }\n      if (this.pendingDispatchNumber >= this.maxDispatchNumber) {\n        this.flush();\n      }\n    }\n    // flush the left commands before we change the status.\n    this.flush();\n    this.sessionStatus = 'default';\n  }\n\n  onReleaseSession(sessionId: number): void {\n    this.unregisterBuffers(sessionId);\n    if (this.capturedCommandList.has(sessionId)) {\n      this.capturedCommandList.delete(sessionId);\n    }\n    if (this.capturedPendingKernels.has(sessionId)) {\n      this.capturedPendingKernels.delete(sessionId);\n    }\n    this.gpuDataManager.onReleaseSession(sessionId);\n  }\n\n  onRunStart(sessionId: number): void {\n    this.currentSessionId = sessionId;\n    this.setQueryType();\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Env} from 'onnxruntime-common';\n\nimport {OrtWasmModule} from '../binding/ort-wasm';\nimport {DataType, getTensorElementSize} from '../wasm-common';\n\nimport {WebGpuBackend} from './backend-webgpu';\nimport {LOG_DEBUG} from './log';\nimport {TensorView} from './tensor-view';\nimport {ShapeUtil} from './util';\nimport {AdapterInfo, ComputeContext, ComputeContextInputsOutputsMapping, ProgramInfo} from './webgpu/types';\n\n/* eslint-disable no-bitwise */\n\nclass TensorViewImpl implements TensorView {\n  constructor(\n      private module: OrtWasmModule, public readonly dataType: number, public readonly data: number,\n      public readonly dims: readonly number[]) {}\n\n  getFloat32Array(): Float32Array {\n    if (this.dataType !== DataType.float) {\n      throw new Error('Invalid data type');\n    }\n    const elementCount = ShapeUtil.size(this.dims);\n    return elementCount === 0 ? new Float32Array() :\n                                new Float32Array(this.module.HEAP8.buffer, this.data, elementCount);\n  }\n\n  getBigInt64Array(): BigInt64Array {\n    if (this.dataType !== DataType.int64) {\n      throw new Error('Invalid data type');\n    }\n    const elementCount = ShapeUtil.size(this.dims);\n    return elementCount === 0 ? new BigInt64Array() :\n                                new BigInt64Array(this.module.HEAP8.buffer, this.data, elementCount);\n  }\n\n  getInt32Array(): Int32Array {\n    if (this.dataType !== DataType.int32) {\n      throw new Error('Invalid data type');\n    }\n    const elementCount = ShapeUtil.size(this.dims);\n    return elementCount === 0 ? new Int32Array() : new Int32Array(this.module.HEAP8.buffer, this.data, elementCount);\n  }\n\n  reshape(newDims: readonly number[]): TensorView {\n    if (ShapeUtil.size(newDims) !== ShapeUtil.size(this.dims)) {\n      throw new Error('Invalid new shape');\n    }\n    return new TensorViewImpl(this.module, this.dataType, this.data, newDims);\n  }\n}\n\nclass ComputeContextImpl implements ComputeContext {\n  readonly adapterInfo: AdapterInfo;\n  readonly opKernelContext: number;\n  readonly inputs: readonly TensorView[];\n  readonly outputCount: number;\n  get kernelCustomData(): {[key: string]: unknown} {\n    return this.backend.currentKernelCustomData;\n  }\n  get customDataBuffer(): Uint8Array {\n    return this.module.HEAPU8.subarray(this.customDataOffset, this.customDataOffset + this.customDataSize);\n  }\n  private customDataOffset = 0;\n  private customDataSize = 0;\n  constructor(private module: OrtWasmModule, private backend: WebGpuBackend, contextDataOffset: number) {\n    this.adapterInfo = backend.adapterInfo;\n    const heapU32 = module.HEAPU32;\n\n    // extract context data\n    let dataIndex = (contextDataOffset >>> 2);\n    this.opKernelContext = heapU32[dataIndex++];\n    const inputCount = heapU32[dataIndex++];\n    this.outputCount = heapU32[dataIndex++];\n    this.customDataOffset = heapU32[dataIndex++];\n    this.customDataSize = heapU32[dataIndex++];\n\n    const inputs: TensorView[] = [];\n    for (let i = 0; i < inputCount; i++) {\n      const dataType = heapU32[dataIndex++];\n      const data = heapU32[dataIndex++];\n      const dim = heapU32[dataIndex++];\n      const dims: number[] = [];\n      for (let d = 0; d < dim; d++) {\n        dims.push(heapU32[dataIndex++]);\n      }\n      inputs.push(new TensorViewImpl(module, dataType, data, dims));\n    }\n    this.inputs = inputs;\n  }\n\n  getMaxComputeWorkgroupSizes(): [number, number, number] {\n    return [\n      this.backend.device.limits.maxComputeWorkgroupSizeX, this.backend.device.limits.maxComputeWorkgroupSizeY,\n      this.backend.device.limits.maxComputeWorkgroupSizeZ\n    ];\n  }\n\n  getMaxComputeWorkgroupStoragesize(): number {\n    return this.backend.device.limits.maxComputeWorkgroupStorageSize;\n  }\n\n  compute(program: ProgramInfo, inputsOutputsMapping?: ComputeContextInputsOutputsMapping): TensorView[] {\n    // prepare inputs. inputs should always be valid data.\n    const mappedInputs =\n        inputsOutputsMapping?.inputs?.map(i => typeof i === 'number' ? this.inputs[i] : i) ?? this.inputs;\n    // prepare outputs.\n    const outputIndices = inputsOutputsMapping?.outputs ?? [];\n    const createKernelOutput = (index: number, dataType: number, dims: readonly number[]): TensorView =>\n        new TensorViewImpl(this.module, dataType, this.output(index, dims), dims);\n    const createTemporaryOutput = (dataType: number, dims: readonly number[]): TensorView => {\n      const elementSize = getTensorElementSize(dataType);\n      if (!elementSize) {\n        throw new Error(`Unsupported data type: ${dataType}`);\n      }\n      const bufferSize = elementSize * ShapeUtil.size(dims);\n      const gpuDataId = bufferSize > 0 ? this.backend.gpuDataManager.create(bufferSize).id : 0;\n      return new TensorViewImpl(this.module, dataType, gpuDataId, dims);\n    };\n    return this.backend.run(\n        program, mappedInputs, outputIndices, createKernelOutput, createTemporaryOutput, this.outputCount);\n  }\n\n  output(index: number, dims: readonly number[]): number {\n    const stack = this.module.stackSave();\n    try {\n      const data = this.module.stackAlloc((1 + dims.length) * 4 /* sizeof(size_t) */);\n      let offset = data >> 2;\n      this.module.HEAPU32[offset++] = dims.length;\n      for (let i = 0; i < dims.length; i++) {\n        this.module.HEAPU32[offset++] = dims[i];\n      }\n      return this.module._JsepOutput!(this.opKernelContext, index, data);\n    } catch (e) {\n      throw new Error(\n          `Failed to generate kernel's output[${index}] with dims [${dims}]. ` +\n          'If you are running with pre-allocated output, please make sure the output type/dims are correct. ' +\n          `Error: ${e}`);\n    } finally {\n      this.module.stackRestore(stack);\n    }\n  }\n}\n\n/**\n * Initialize JSEP with WebGPU backend.\n *\n * This function will be called after the WebAssembly module is loaded and initialized (\"_OrtInit\" is called), once for\n * each of the following EPs if they are specified:\n * - \"webgpu\"\n * - \"webnn\"\n *\n * For WebGPU, this function expects:\n *  - WebGPU is enabled in build (BUILD_DEFS.DISABLE_WEBGPU === false).\n *  - WebGPU is available in current environment. (a valid GPUAdapter is passed in)\n *\n * For WebNN, this function expects:\n * - WebNN is enabled in build (BUILD_DEFS.DISABLE_WEBGPU === false).\n * - WebNN is available in current environment. (navigator.ml is not undefined)\n *\n * If the WebAssembly module is not built with JSEP support, this function will throw an error. This will invalidate\n * 'webgpu'/'webnn' backend.\n *\n * @param name - the name of the EP, either \"webgpu\" or \"webnn\"\n * @param module - the ORT WebAssembly module\n * @param env - the ORT environment variable (ort.env)\n * @param gpuAdapter - the pre-created GPU adapter\n */\nexport const init =\n    async(name: 'webgpu'|'webnn', module: OrtWasmModule, env: Env, gpuAdapter?: GPUAdapter): Promise<void> => {\n  const jsepInit = module.jsepInit;\n  if (!jsepInit) {\n    throw new Error('Failed to initialize JSEP. The WebAssembly module is not built with JSEP support.');\n  }\n\n  if (name === 'webgpu') {\n    const backend = new WebGpuBackend();\n    await backend.initialize(env, gpuAdapter!);\n\n    jsepInit('webgpu', [\n      // backend\n      backend,\n\n      // jsepAlloc()\n      (size: number) => backend.alloc(size),\n\n      // jsepFree()\n      (ptr: number) => backend.free(ptr),\n\n      // jsepCopy(src, dst, size, isSourceGpu)\n      (src: number, dst: number, size: number, isSourceGpu = false) => {\n        if (isSourceGpu) {\n          LOG_DEBUG('verbose', () => `[WebGPU] jsepCopyGpuToGpu: src=${src}, dst=${dst}, size=${size}`);\n          backend.memcpy(src, dst);\n        } else {\n          LOG_DEBUG('verbose', () => `[WebGPU] jsepCopyCpuToGpu: dataOffset=${src}, gpuDataId=${dst}, size=${size}`);\n          const data = module.HEAPU8.subarray(src >>> 0, (src >>> 0) + size);\n          backend.upload(dst, data);\n        }\n      },\n\n      // jsepCopyAsync(src, dst, size)\n      async(gpuDataId: number, dataOffset: number, size: number):\n          Promise<void> => {\n            LOG_DEBUG(\n                'verbose',\n                () => `[WebGPU] jsepCopyGpuToCpu: gpuDataId=${gpuDataId}, dataOffset=${dataOffset}, size=${size}`);\n\n            await backend.download(\n                gpuDataId, () => module.HEAPU8.subarray(dataOffset >>> 0, (dataOffset >>> 0) + size));\n          },\n\n      // jsepCreateKernel\n      (kernelType: string, kernelId: number, attribute: unknown) => backend.createKernel(\n          kernelType, kernelId, attribute, module.UTF8ToString(module._JsepGetNodeName!(kernelId))),\n\n      // jsepReleaseKernel\n      (kernel: number) => backend.releaseKernel(kernel),\n\n      // jsepRun\n      (kernel: number, contextDataOffset: number, sessionHandle: number, errors: Array<Promise<string|null>>) => {\n        LOG_DEBUG(\n            'verbose',\n            () => `[WebGPU] jsepRun: sessionHandle=${sessionHandle}, kernel=${kernel}, contextDataOffset=${\n                contextDataOffset}`);\n        const context = new ComputeContextImpl(module, backend, contextDataOffset);\n        return backend.computeKernel(kernel, context, errors);\n      },\n      // jsepCaptureBegin\n      () => backend.captureBegin(),\n      // jsepCaptureEnd\n      () => backend.captureEnd(),\n      // jsepReplay\n      () => backend.replay()\n    ]);\n  } else {\n    jsepInit('webnn');\n  }\n};\n", "export const join = undefined;", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport * as path from 'node:path';\nimport {Env} from 'onnxruntime-common';\n\nimport {OrtWasmModule} from './binding/ort-wasm';\nimport {OrtWasmThreadedModule} from './binding/ort-wasm-threaded';\n\n/* eslint-disable @typescript-eslint/no-require-imports */\nlet ortWasmFactory: EmscriptenModuleFactory<OrtWasmModule>;\n\nif (!BUILD_DEFS.DISABLE_TRAINING) {\n  ortWasmFactory = require('./binding/ort-training-wasm-simd.js');\n} else {\n  ortWasmFactory =\n      BUILD_DEFS.DISABLE_WEBGPU ? require('./binding/ort-wasm.js') : require('./binding/ort-wasm-simd.jsep.js');\n}\n\nconst ortWasmFactoryThreaded: EmscriptenModuleFactory<OrtWasmModule> = !BUILD_DEFS.DISABLE_WASM_THREAD ?\n    (BUILD_DEFS.DISABLE_WEBGPU ? require('./binding/ort-wasm-threaded.js') :\n                                 require('./binding/ort-wasm-simd-threaded.jsep.js')) :\n    ortWasmFactory;\n/* eslint-enable @typescript-eslint/no-require-imports */\n\nlet wasm: OrtWasmModule|undefined;\nlet initialized = false;\nlet initializing = false;\nlet aborted = false;\n\nconst isMultiThreadSupported = (numThreads: number): boolean => {\n  // WebAssembly threads are set to 1 (single thread).\n  if (numThreads === 1) {\n    return false;\n  }\n\n  // If 'SharedArrayBuffer' is not available, WebAssembly threads will not work.\n  if (typeof SharedArrayBuffer === 'undefined') {\n    if (typeof self !== 'undefined' && !self.crossOriginIsolated) {\n      // eslint-disable-next-line no-console\n      console.warn(\n          'env.wasm.numThreads is set to ' + numThreads +\n          ', but this will not work unless you enable crossOriginIsolated mode. ' +\n          'See https://web.dev/cross-origin-isolation-guide/ for more info.');\n    }\n    return false;\n  }\n\n  // onnxruntime-web does not support multi-threads in Node.js.\n  if (typeof process !== 'undefined' && process.versions && process.versions.node) {\n    // eslint-disable-next-line no-console\n    console.warn(\n        'env.wasm.numThreads is set to ' + numThreads +\n        ', however, currently onnxruntime-web does not support multi-threads in Node.js. ' +\n        'Please consider using onnxruntime-node for performance critical scenarios.');\n  }\n\n  try {\n    // Test for transferability of SABs (for browsers. needed for Firefox)\n    // https://groups.google.com/forum/#!msg/mozilla.dev.platform/IHkBZlHETpA/dwsMNchWEQAJ\n    if (typeof MessageChannel !== 'undefined') {\n      new MessageChannel().port1.postMessage(new SharedArrayBuffer(1));\n    }\n\n    // Test for WebAssembly threads capability (for both browsers and Node.js)\n    // This typed array is a WebAssembly program containing threaded instructions.\n    return WebAssembly.validate(new Uint8Array([\n      0, 97, 115, 109, 1, 0,  0,  0, 1, 4, 1,  96, 0,   0,  3, 2, 1,  0, 5,\n      4, 1,  3,   1,   1, 10, 11, 1, 9, 0, 65, 0,  254, 16, 2, 0, 26, 11\n    ]));\n  } catch (e) {\n    return false;\n  }\n};\n\nconst isSimdSupported = (): boolean => {\n  try {\n    // Test for WebAssembly SIMD capability (for both browsers and Node.js)\n    // This typed array is a WebAssembly program containing SIMD instructions.\n\n    // The binary data is generated from the following code by wat2wasm:\n    //\n    // (module\n    //   (type $t0 (func))\n    //   (func $f0 (type $t0)\n    //     (drop\n    //       (i32x4.dot_i16x8_s\n    //         (i8x16.splat\n    //           (i32.const 0))\n    //         (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)))))\n\n    return WebAssembly.validate(new Uint8Array([\n      0,   97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 30, 1,   28,  0, 65, 0,\n      253, 15, 253, 12,  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0,  0,  253, 186, 1, 26, 11\n    ]));\n  } catch (e) {\n    return false;\n  }\n};\n\nconst getWasmFileName = (useSimd: boolean, useThreads: boolean) => {\n  if (useSimd) {\n    if (!BUILD_DEFS.DISABLE_TRAINING) {\n      return 'ort-training-wasm-simd.wasm';\n    }\n    return useThreads ? 'ort-wasm-simd-threaded.wasm' : 'ort-wasm-simd.wasm';\n  } else {\n    return useThreads ? 'ort-wasm-threaded.wasm' : 'ort-wasm.wasm';\n  }\n};\n\nexport const initializeWebAssembly = async(flags: Env.WebAssemblyFlags): Promise<void> => {\n  if (initialized) {\n    return Promise.resolve();\n  }\n  if (initializing) {\n    throw new Error('multiple calls to \\'initializeWebAssembly()\\' detected.');\n  }\n  if (aborted) {\n    throw new Error('previous call to \\'initializeWebAssembly()\\' failed.');\n  }\n\n  initializing = true;\n\n  // wasm flags are already initialized\n  const timeout = flags.initTimeout!;\n  const numThreads = flags.numThreads!;\n  const simd = flags.simd!;\n\n  const useThreads = isMultiThreadSupported(numThreads);\n  const useSimd = simd && isSimdSupported();\n\n  const wasmPaths = flags.wasmPaths;\n  const wasmPrefixOverride = typeof wasmPaths === 'string' ? wasmPaths : undefined;\n  const wasmFileName = getWasmFileName(useSimd, useThreads);\n  const wasmPathOverride = typeof wasmPaths === 'object' ? wasmPaths[wasmFileName] : undefined;\n\n  let isTimeout = false;\n\n  const tasks: Array<Promise<void>> = [];\n\n  // promise for timeout\n  if (timeout > 0) {\n    tasks.push(new Promise((resolve) => {\n      setTimeout(() => {\n        isTimeout = true;\n        resolve();\n      }, timeout);\n    }));\n  }\n\n  // promise for module initialization\n  tasks.push(new Promise((resolve, reject) => {\n    const factory = useThreads ? ortWasmFactoryThreaded : ortWasmFactory;\n    const config: Partial<OrtWasmModule> = {\n      locateFile: (fileName: string, scriptDirectory: string) => {\n        if (!BUILD_DEFS.DISABLE_WASM_THREAD && useThreads && fileName.endsWith('.worker.js') &&\n            typeof Blob !== 'undefined') {\n          return URL.createObjectURL(new Blob(\n              [\n                // This require() function is handled by esbuild plugin to load file content as string.\n                // eslint-disable-next-line @typescript-eslint/no-require-imports\n                require('./binding/ort-wasm-threaded.worker.js')\n              ],\n              {type: 'text/javascript'}));\n        }\n\n        if (fileName.endsWith('.wasm')) {\n          if (wasmPathOverride) {\n            return wasmPathOverride;\n          }\n\n          const prefix = wasmPrefixOverride ?? scriptDirectory;\n\n          if (!BUILD_DEFS.DISABLE_WEBGPU) {\n            if (wasmFileName === 'ort-wasm-simd.wasm') {\n              return prefix + 'ort-wasm-simd.jsep.wasm';\n            } else if (wasmFileName === 'ort-wasm-simd-threaded.wasm') {\n              return prefix + 'ort-wasm-simd-threaded.jsep.wasm';\n            }\n          }\n\n          return prefix + wasmFileName;\n        }\n\n        return scriptDirectory + fileName;\n      }\n    };\n\n    if (!BUILD_DEFS.DISABLE_WASM_THREAD && useThreads) {\n      config.numThreads = numThreads;\n      if (typeof Blob === 'undefined') {\n        config.mainScriptUrlOrBlob = path.join(__dirname, 'ort-wasm-threaded.js');\n      } else {\n        const scriptSourceCode = `var ortWasmThreaded=${factory.toString()};`;\n        config.mainScriptUrlOrBlob = new Blob([scriptSourceCode], {type: 'text/javascript'});\n      }\n    }\n\n    factory(config).then(\n        // wasm module initialized successfully\n        module => {\n          initializing = false;\n          initialized = true;\n          wasm = module;\n          resolve();\n        },\n        // wasm module failed to initialize\n        (what) => {\n          initializing = false;\n          aborted = true;\n          reject(what);\n        });\n  }));\n\n  await Promise.race(tasks);\n\n  if (isTimeout) {\n    throw new Error(`WebAssembly backend initializing failed due to timeout: ${timeout}ms`);\n  }\n};\n\nexport const getInstance = (): OrtWasmModule => {\n  if (initialized && wasm) {\n    return wasm;\n  }\n\n  throw new Error('WebAssembly is not initialized yet.');\n};\n\nexport const dispose = (): void => {\n  if (initialized && !initializing && !aborted) {\n    initializing = true;\n\n    (wasm as OrtWasmThreadedModule).PThread?.terminateAllThreads();\n    wasm = undefined;\n\n    initializing = false;\n    initialized = false;\n    aborted = true;\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {getInstance} from './wasm-factory';\n\nexport const allocWasmString = (data: string, allocs: number[]): number => {\n  const wasm = getInstance();\n\n  const dataLength = wasm.lengthBytesUTF8(data) + 1;\n  const dataOffset = wasm._malloc(dataLength);\n  wasm.stringToUTF8(data, dataOffset, dataLength);\n  allocs.push(dataOffset);\n\n  return dataOffset;\n};\n\ninterface ExtraOptionsHandler {\n  (name: string, value: string): void;\n}\n\nexport const iterateExtraOptions =\n    (options: Record<string, unknown>, prefix: string, seen: WeakSet<Record<string, unknown>>,\n     handler: ExtraOptionsHandler): void => {\n      if (typeof options == 'object' && options !== null) {\n        if (seen.has(options)) {\n          throw new Error('Circular reference in options');\n        } else {\n          seen.add(options);\n        }\n      }\n\n      Object.entries(options).forEach(([key, value]) => {\n        const name = (prefix) ? prefix + key : key;\n        if (typeof value === 'object') {\n          iterateExtraOptions(value as Record<string, unknown>, name + '.', seen, handler);\n        } else if (typeof value === 'string' || typeof value === 'number') {\n          handler(name, value.toString());\n        } else if (typeof value === 'boolean') {\n          handler(name, (value) ? '1' : '0');\n        } else {\n          throw new Error(`Can't handle extra config type: ${typeof value}`);\n        }\n      });\n    };\n\n/**\n * check web assembly API's last error and throw error if any error occurred.\n * @param message a message used when an error occurred.\n */\nexport const checkLastError = (message: string): void => {\n  const wasm = getInstance();\n\n  const stack = wasm.stackSave();\n  try {\n    const paramsOffset = wasm.stackAlloc(8);\n    wasm._OrtGetLastError(paramsOffset, paramsOffset + 4);\n    const errorCode = wasm.HEAP32[paramsOffset / 4];\n    const errorMessagePointer = wasm.HEAPU32[paramsOffset / 4 + 1];\n    const errorMessage = errorMessagePointer ? wasm.UTF8ToString(errorMessagePointer) : '';\n    throw new Error(`${message} ERROR_CODE: ${errorCode}, ERROR_MESSAGE: ${errorMessage}`);\n  } finally {\n    wasm.stackRestore(stack);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {InferenceSession} from 'onnxruntime-common';\n\nimport {getInstance} from './wasm-factory';\nimport {allocWasmString, checkLastError, iterateExtraOptions} from './wasm-utils';\n\nexport const setRunOptions = (options: InferenceSession.RunOptions): [number, number[]] => {\n  const wasm = getInstance();\n  let runOptionsHandle = 0;\n  const allocs: number[] = [];\n\n  const runOptions: InferenceSession.RunOptions = options || {};\n\n  try {\n    if (options?.logSeverityLevel === undefined) {\n      runOptions.logSeverityLevel = 2;  // Default to warning\n    } else if (\n        typeof options.logSeverityLevel !== 'number' || !Number.isInteger(options.logSeverityLevel) ||\n        options.logSeverityLevel < 0 || options.logSeverityLevel > 4) {\n      throw new Error(`log serverity level is not valid: ${options.logSeverityLevel}`);\n    }\n\n    if (options?.logVerbosityLevel === undefined) {\n      runOptions.logVerbosityLevel = 0;  // Default to 0\n    } else if (typeof options.logVerbosityLevel !== 'number' || !Number.isInteger(options.logVerbosityLevel)) {\n      throw new Error(`log verbosity level is not valid: ${options.logVerbosityLevel}`);\n    }\n\n    if (options?.terminate === undefined) {\n      runOptions.terminate = false;\n    }\n\n    let tagDataOffset = 0;\n    if (options?.tag !== undefined) {\n      tagDataOffset = allocWasmString(options.tag, allocs);\n    }\n\n    runOptionsHandle = wasm._OrtCreateRunOptions(\n        runOptions.logSeverityLevel!, runOptions.logVerbosityLevel!, !!runOptions.terminate!, tagDataOffset);\n    if (runOptionsHandle === 0) {\n      checkLastError('Can\\'t create run options.');\n    }\n\n    if (options?.extra !== undefined) {\n      iterateExtraOptions(options.extra, '', new WeakSet<Record<string, unknown>>(), (key, value) => {\n        const keyDataOffset = allocWasmString(key, allocs);\n        const valueDataOffset = allocWasmString(value, allocs);\n\n        if (wasm._OrtAddRunConfigEntry(runOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n          checkLastError(`Can't set a run config entry: ${key} - ${value}.`);\n        }\n      });\n    }\n\n    return [runOptionsHandle, allocs];\n  } catch (e) {\n    if (runOptionsHandle !== 0) {\n      wasm._OrtReleaseRunOptions(runOptionsHandle);\n    }\n    allocs.forEach(alloc => wasm._free(alloc));\n    throw e;\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {InferenceSession} from 'onnxruntime-common';\n\nimport {getInstance} from './wasm-factory';\nimport {allocWasmString, checkLastError, iterateExtraOptions} from './wasm-utils';\n\nconst getGraphOptimzationLevel = (graphOptimizationLevel: string|unknown): number => {\n  switch (graphOptimizationLevel) {\n    case 'disabled':\n      return 0;\n    case 'basic':\n      return 1;\n    case 'extended':\n      return 2;\n    case 'all':\n      return 99;\n    default:\n      throw new Error(`unsupported graph optimization level: ${graphOptimizationLevel}`);\n  }\n};\n\nconst getExecutionMode = (executionMode: 'sequential'|'parallel'): number => {\n  switch (executionMode) {\n    case 'sequential':\n      return 0;\n    case 'parallel':\n      return 1;\n    default:\n      throw new Error(`unsupported execution mode: ${executionMode}`);\n  }\n};\n\nconst appendDefaultOptions = (options: InferenceSession.SessionOptions): void => {\n  if (!options.extra) {\n    options.extra = {};\n  }\n  if (!options.extra.session) {\n    options.extra.session = {};\n  }\n  const session = options.extra.session as Record<string, string>;\n  if (!session.use_ort_model_bytes_directly) {\n    // eslint-disable-next-line camelcase\n    session.use_ort_model_bytes_directly = '1';\n  }\n\n  // if using JSEP with WebGPU, always disable memory pattern\n  if (options.executionProviders &&\n      options.executionProviders.some(ep => (typeof ep === 'string' ? ep : ep.name) === 'webgpu')) {\n    options.enableMemPattern = false;\n  }\n};\n\nconst setExecutionProviders =\n    (sessionOptionsHandle: number, executionProviders: readonly InferenceSession.ExecutionProviderConfig[],\n     allocs: number[]): void => {\n      for (const ep of executionProviders) {\n        let epName = typeof ep === 'string' ? ep : ep.name;\n\n        // check EP name\n        switch (epName) {\n          case 'webnn':\n            epName = 'WEBNN';\n            if (typeof ep !== 'string') {\n              const webnnOptions = ep as InferenceSession.WebNNExecutionProviderOption;\n              if (webnnOptions?.deviceType) {\n                const keyDataOffset = allocWasmString('deviceType', allocs);\n                const valueDataOffset = allocWasmString(webnnOptions.deviceType, allocs);\n                if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !==\n                    0) {\n                  checkLastError(`Can't set a session config entry: 'deviceType' - ${webnnOptions.deviceType}.`);\n                }\n              }\n              if (webnnOptions?.numThreads) {\n                let numThreads = webnnOptions.numThreads;\n                // Just ignore invalid webnnOptions.numThreads.\n                if (typeof numThreads != 'number' || !Number.isInteger(numThreads) || numThreads < 0) {\n                  numThreads = 0;\n                }\n                const keyDataOffset = allocWasmString('numThreads', allocs);\n                const valueDataOffset = allocWasmString(numThreads.toString(), allocs);\n                if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !==\n                    0) {\n                  checkLastError(`Can't set a session config entry: 'numThreads' - ${webnnOptions.numThreads}.`);\n                }\n              }\n              if (webnnOptions?.powerPreference) {\n                const keyDataOffset = allocWasmString('powerPreference', allocs);\n                const valueDataOffset = allocWasmString(webnnOptions.powerPreference, allocs);\n                if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !==\n                    0) {\n                  checkLastError(\n                      `Can't set a session config entry: 'powerPreference' - ${webnnOptions.powerPreference}.`);\n                }\n              }\n            }\n            break;\n          case 'webgpu':\n            epName = 'JS';\n            if (typeof ep !== 'string') {\n              const webgpuOptions = ep as InferenceSession.WebGpuExecutionProviderOption;\n              if (webgpuOptions?.preferredLayout) {\n                if (webgpuOptions.preferredLayout !== 'NCHW' && webgpuOptions.preferredLayout !== 'NHWC') {\n                  throw new Error(`preferredLayout must be either 'NCHW' or 'NHWC': ${webgpuOptions.preferredLayout}`);\n                }\n                const keyDataOffset = allocWasmString('preferredLayout', allocs);\n                const valueDataOffset = allocWasmString(webgpuOptions.preferredLayout, allocs);\n                if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !==\n                    0) {\n                  checkLastError(\n                      `Can't set a session config entry: 'preferredLayout' - ${webgpuOptions.preferredLayout}.`);\n                }\n              }\n            }\n            break;\n          case 'wasm':\n          case 'cpu':\n            continue;\n          default:\n            throw new Error(`not supported execution provider: ${epName}`);\n        }\n\n        const epNameDataOffset = allocWasmString(epName, allocs);\n        if (getInstance()._OrtAppendExecutionProvider(sessionOptionsHandle, epNameDataOffset) !== 0) {\n          checkLastError(`Can't append execution provider: ${epName}.`);\n        }\n      }\n    };\n\nexport const setSessionOptions = (options?: InferenceSession.SessionOptions): [number, number[]] => {\n  const wasm = getInstance();\n  let sessionOptionsHandle = 0;\n  const allocs: number[] = [];\n\n  const sessionOptions: InferenceSession.SessionOptions = options || {};\n  appendDefaultOptions(sessionOptions);\n\n  try {\n    const graphOptimizationLevel = getGraphOptimzationLevel(sessionOptions.graphOptimizationLevel ?? 'all');\n    const executionMode = getExecutionMode(sessionOptions.executionMode ?? 'sequential');\n    const logIdDataOffset =\n        typeof sessionOptions.logId === 'string' ? allocWasmString(sessionOptions.logId, allocs) : 0;\n\n    const logSeverityLevel = sessionOptions.logSeverityLevel ?? 2;  // Default to 2 - warning\n    if (!Number.isInteger(logSeverityLevel) || logSeverityLevel < 0 || logSeverityLevel > 4) {\n      throw new Error(`log serverity level is not valid: ${logSeverityLevel}`);\n    }\n\n    const logVerbosityLevel = sessionOptions.logVerbosityLevel ?? 0;  // Default to 0 - verbose\n    if (!Number.isInteger(logVerbosityLevel) || logVerbosityLevel < 0 || logVerbosityLevel > 4) {\n      throw new Error(`log verbosity level is not valid: ${logVerbosityLevel}`);\n    }\n\n    const optimizedModelFilePathOffset = typeof sessionOptions.optimizedModelFilePath === 'string' ?\n        allocWasmString(sessionOptions.optimizedModelFilePath, allocs) :\n        0;\n\n    sessionOptionsHandle = wasm._OrtCreateSessionOptions(\n        graphOptimizationLevel, !!sessionOptions.enableCpuMemArena, !!sessionOptions.enableMemPattern, executionMode,\n        !!sessionOptions.enableProfiling, 0, logIdDataOffset, logSeverityLevel, logVerbosityLevel,\n        optimizedModelFilePathOffset);\n    if (sessionOptionsHandle === 0) {\n      checkLastError('Can\\'t create session options.');\n    }\n\n    if (sessionOptions.executionProviders) {\n      setExecutionProviders(sessionOptionsHandle, sessionOptions.executionProviders, allocs);\n    }\n\n    if (sessionOptions.enableGraphCapture !== undefined) {\n      if (typeof sessionOptions.enableGraphCapture !== 'boolean') {\n        throw new Error(`enableGraphCapture must be a boolean value: ${sessionOptions.enableGraphCapture}`);\n      }\n      const keyDataOffset = allocWasmString('enableGraphCapture', allocs);\n      const valueDataOffset = allocWasmString(sessionOptions.enableGraphCapture.toString(), allocs);\n      if (wasm._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n        checkLastError(\n            `Can't set a session config entry: 'enableGraphCapture' - ${sessionOptions.enableGraphCapture}.`);\n      }\n    }\n\n    if (sessionOptions.freeDimensionOverrides) {\n      for (const [name, value] of Object.entries(sessionOptions.freeDimensionOverrides)) {\n        if (typeof name !== 'string') {\n          throw new Error(`free dimension override name must be a string: ${name}`);\n        }\n        if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {\n          throw new Error(`free dimension override value must be a non-negative integer: ${value}`);\n        }\n        const nameOffset = allocWasmString(name, allocs);\n        if (wasm._OrtAddFreeDimensionOverride(sessionOptionsHandle, nameOffset, value) !== 0) {\n          checkLastError(`Can't set a free dimension override: ${name} - ${value}.`);\n        }\n      }\n    }\n\n    if (sessionOptions.extra !== undefined) {\n      iterateExtraOptions(sessionOptions.extra, '', new WeakSet<Record<string, unknown>>(), (key, value) => {\n        const keyDataOffset = allocWasmString(key, allocs);\n        const valueDataOffset = allocWasmString(value, allocs);\n\n        if (wasm._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n          checkLastError(`Can't set a session config entry: ${key} - ${value}.`);\n        }\n      });\n    }\n\n    return [sessionOptionsHandle, allocs];\n  } catch (e) {\n    if (sessionOptionsHandle !== 0) {\n      wasm._OrtReleaseSessionOptions(sessionOptionsHandle);\n    }\n    allocs.forEach(alloc => wasm._free(alloc));\n    throw e;\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {Env, InferenceSession, Tensor} from 'onnxruntime-common';\n\nimport {SerializableInternalBuffer, SerializableSessionMetadata, SerializableTensorMetadata, TensorMetadata} from './proxy-messages';\nimport {setRunOptions} from './run-options';\nimport {setSessionOptions} from './session-options';\nimport {dataLocationStringToEnum, getTensorElementSize, isGpuBufferSupportedType, logLevelStringToEnum, tensorDataTypeEnumToString, tensorDataTypeStringToEnum, tensorTypeToTypedArrayConstructor} from './wasm-common';\nimport {getInstance} from './wasm-factory';\nimport {allocWasmString, checkLastError} from './wasm-utils';\nimport {loadFile} from './wasm-utils-load-file';\n\n// #region Initializations\n\n/**\n * There are 4 different \"initialization\" steps for ORT. They happen in different places and different time.\n *\n * 1. JavaScript initialization for onnxruntime-common and onnxruntime-web.\n *    This is the first initialization step. In this step, onnxruntime-web calls onnxruntime-common's registerBackend()\n * function multiple times to register all the available backends. The backend registration is very fast. It only\n * registers the backend name with the uninitialized backend object. No heavy initialization is done in this step.\n *    Refer to web/lib/index.ts for the backend registration.\n *\n * 2. WebAssembly artifact initialization.\n *    This happens when any registered wasm backend is used for the first time (ie. `ort.InferenceSession.create()` or\n * `ort.TrainingSession.create()` is called). In this step, onnxruntime-web does the followings:\n *     - create a proxy worker and make sure the proxy worker is ready to receive messages, if proxy is enabled.\n *     - perform feature detection, locate correct WebAssembly artifact path and call the Emscripten generated\n * JavaScript code to initialize the WebAssembly runtime.\n *         - if proxy is enabled, this step happens in the proxy worker using message 'init-wasm'.\n *         - downloading the 'ort-wasm{...}.wasm' file is done in this step.\n *         - if multi-thread is enabled, one or more webworker will be created to initialize the PThread threadpool.\n *\n * 3. ORT environment initialization.\n *    This happens after step 2. In this step, onnxruntime-web performs ONNX Runtime environment initialization.\n * Function `_OrtInit()` is called in this step.\n *     - if proxy is enabled, this step happens in the proxy worker using message 'init-ort'.\n *     - logging level (ort.env.logLevel) and thread number (ort.env.wasm.numThreads) are set in this step.\n *\n * 4. Session initialization.\n *    This happens when `ort.InferenceSession.create()` or `ort.TrainingSession.create()` is called. Unlike the first 3\n * steps (they only called once), this step will be done for each session. In this step, onnxruntime-web does the\n * followings:\n *    If the parameter is a URL:\n *    - download the model data from the URL.\n *    - copy the model data to the WASM heap. (proxy: 'copy-from')\n *    - dereference the model buffer. This step allows the original ArrayBuffer to be garbage collected.\n *    - call `_OrtCreateSession()` to create the session. (proxy: 'create')\n *\n *    If the parameter is a Uint8Array object:\n *    - copy the model data to the WASM heap. (proxy: 'copy-from')\n *    - call `_OrtCreateSession()` to create the session. (proxy: 'create')\n *\n *\n */\n\n/**\n * initialize ORT environment.\n *\n * @param numThreads SetGlobalIntraOpNumThreads(numThreads)\n * @param loggingLevel CreateEnv(static_cast<OrtLoggingLevel>(logging_level))\n */\nconst initOrt = (numThreads: number, loggingLevel: number): void => {\n  const errorCode = getInstance()._OrtInit(numThreads, loggingLevel);\n  if (errorCode !== 0) {\n    checkLastError('Can\\'t initialize onnxruntime.');\n  }\n};\n\n/**\n * intialize runtime environment.\n * @param env passed in the environment config object.\n */\nexport const initRuntime = async(env: Env): Promise<void> => {\n  // init ORT\n  initOrt(env.wasm.numThreads!, logLevelStringToEnum(env.logLevel));\n};\n\n/**\n * perform EP specific initialization.\n *\n * @param env\n * @param epName\n */\nexport const initEp = async(env: Env, epName: string): Promise<void> => {\n  if (!BUILD_DEFS.DISABLE_WEBGPU) {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires\n    const initJsep = require('./jsep/init').init;\n\n    if (epName === 'webgpu') {\n      // perform WebGPU availability check\n      if (typeof navigator === 'undefined' || !navigator.gpu) {\n        throw new Error('WebGPU is not supported in current environment');\n      }\n\n      let adapter = env.webgpu.adapter as GPUAdapter | null;\n      if (!adapter) {\n        // if adapter is not set, request a new adapter.\n        const powerPreference = env.webgpu.powerPreference;\n        if (powerPreference !== undefined && powerPreference !== 'low-power' &&\n            powerPreference !== 'high-performance') {\n          throw new Error(`Invalid powerPreference setting: \"${powerPreference}\"`);\n        }\n        const forceFallbackAdapter = env.webgpu.forceFallbackAdapter;\n        if (forceFallbackAdapter !== undefined && typeof forceFallbackAdapter !== 'boolean') {\n          throw new Error(`Invalid forceFallbackAdapter setting: \"${forceFallbackAdapter}\"`);\n        }\n        adapter = await navigator.gpu.requestAdapter({powerPreference, forceFallbackAdapter});\n        if (!adapter) {\n          throw new Error(\n              'Failed to get GPU adapter. ' +\n              'You may need to enable flag \"--enable-unsafe-webgpu\" if you are using Chrome.');\n        }\n      } else {\n        // if adapter is set, validate it.\n        if (typeof adapter.limits !== 'object' || typeof adapter.features !== 'object' ||\n            typeof adapter.requestDevice !== 'function') {\n          throw new Error('Invalid GPU adapter set in `env.webgpu.adapter`. It must be a GPUAdapter object.');\n        }\n      }\n\n      if (!env.wasm.simd) {\n        throw new Error(\n            'Not supported for WebGPU=ON and SIMD=OFF. Please set `env.wasm.simd` to true when using `webgpu` EP');\n      }\n\n      await initJsep('webgpu', getInstance(), env, adapter);\n    }\n    if (epName === 'webnn') {\n      // perform WebNN availability check\n      if (typeof navigator === 'undefined' || !(navigator as unknown as {ml: unknown}).ml) {\n        throw new Error('WebNN is not supported in current environment');\n      }\n\n      await initJsep('webnn', getInstance(), env);\n    }\n  }\n};\n\n// #endregion Initializations\n\n/**\n * valid data locations for input/output tensors.\n */\ntype SupportedTensorDataLocationForInputOutput = 'cpu'|'cpu-pinned'|'gpu-buffer';\n\ntype IOBindingState = {\n  /**\n   * the handle of IO binding.\n   */\n  readonly handle: number;\n\n  /**\n   * the preferred location for each output tensor.\n   *\n   * value is one of 'cpu', 'cpu-pinned', 'gpu-buffer'.\n   */\n  readonly outputPreferredLocations: readonly SupportedTensorDataLocationForInputOutput[];\n\n  /**\n   * enum value of the preferred location for each output tensor.\n   */\n  readonly outputPreferredLocationsEncoded: readonly number[];\n};\n\n/**\n *  tuple elements are: InferenceSession ID; inputNamesUTF8Encoded; outputNamesUTF8Encoded; bindingState\n */\ntype SessionMetadata = [\n  inferenceSessionId: number, inputNamesUTF8Encoded: number[], outputNamesUTF8Encoded: number[],\n  bindingState: IOBindingState|null, enableGraphCapture: boolean, inputOutputBound: boolean\n];\n\nconst activeSessions = new Map<number, SessionMetadata>();\n\n/**\n * get the input/output count of the session.\n * @param sessionHandle the handle representing the session. should be non-zero.\n * @returns a tuple including 2 numbers, representing the input count and output count.\n */\nconst getSessionInputOutputCount = (sessionHandle: number): [number, number] => {\n  const wasm = getInstance();\n  const stack = wasm.stackSave();\n  try {\n    const dataOffset = wasm.stackAlloc(8);\n    const errorCode = wasm._OrtGetInputOutputCount(sessionHandle, dataOffset, dataOffset + 4);\n    if (errorCode !== 0) {\n      checkLastError('Can\\'t get session input/output count.');\n    }\n    return [wasm.HEAP32[dataOffset / 4], wasm.HEAP32[dataOffset / 4 + 1]];\n  } finally {\n    wasm.stackRestore(stack);\n  }\n};\n\n/**\n * allocate the memory and memcpy the external buffer.\n *\n * @param model - the external buffer containing the model data. Must not be the same buffer as the WASM heap.\n * @returns a 2-elements tuple - the pointer and size of the allocated buffer\n */\nexport const copyFromExternalBuffer = (model: Uint8Array): [number, number] => {\n  const wasm = getInstance();\n  const modelDataOffset = wasm._malloc(model.byteLength);\n  if (modelDataOffset === 0) {\n    throw new Error(`Can't create a session. failed to allocate a buffer of size ${model.byteLength}.`);\n  }\n  wasm.HEAPU8.set(model, modelDataOffset);\n  return [modelDataOffset, model.byteLength];\n};\n\n/**\n * create an inference session from a model data buffer.\n *\n * @param modelData - either a Uint8Array object representing the model data, or a 2-elements tuple containing the\n *     pointer and size of the model data buffer.\n * @param options an optional session options object.\n * @returns a 3-elements tuple containing [session handle, input names, output names]\n */\nexport const createSession = async(\n    modelData: Uint8Array|SerializableInternalBuffer,\n    options?: InferenceSession.SessionOptions): Promise<SerializableSessionMetadata> => {\n  let modelDataOffset: number, modelDataLength: number;\n  const wasm = getInstance();\n\n  if (Array.isArray(modelData)) {\n    // if model data is an array, it must be a 2-elements tuple containing the pointer and size of the model data\n    [modelDataOffset, modelDataLength] = modelData;\n  } else if (modelData.buffer === wasm.HEAPU8.buffer) {\n    // if model data uses the same buffer as the WASM heap, we don't need to copy it.\n    [modelDataOffset, modelDataLength] = [modelData.byteOffset, modelData.byteLength];\n  } else {\n    // otherwise, copy the model data to the WASM heap.\n    [modelDataOffset, modelDataLength] = copyFromExternalBuffer(modelData);\n  }\n\n  let sessionHandle = 0;\n  let sessionOptionsHandle = 0;\n  let ioBindingHandle = 0;\n  let allocs: number[] = [];\n  const inputNamesUTF8Encoded = [];\n  const outputNamesUTF8Encoded = [];\n\n  try {\n    [sessionOptionsHandle, allocs] = setSessionOptions(options);\n\n    if (options?.externalData && wasm.mountExternalData) {\n      const loadingPromises = [];\n      for (const file of options.externalData) {\n        const path = typeof file === 'string' ? file : file.path;\n        loadingPromises.push(loadFile(typeof file === 'string' ? file : file.data).then(data => {\n          wasm.mountExternalData!(path, data);\n        }));\n      }\n\n      // wait for all external data files to be loaded\n      await Promise.all(loadingPromises);\n    }\n\n    sessionHandle = await wasm._OrtCreateSession(modelDataOffset, modelDataLength, sessionOptionsHandle);\n    if (sessionHandle === 0) {\n      checkLastError('Can\\'t create a session.');\n    }\n\n    const [inputCount, outputCount] = getSessionInputOutputCount(sessionHandle);\n\n    const enableGraphCapture = !!options?.enableGraphCapture;\n\n    const inputNames = [];\n    const outputNames = [];\n    const outputPreferredLocations: SupportedTensorDataLocationForInputOutput[] = [];\n    for (let i = 0; i < inputCount; i++) {\n      const name = wasm._OrtGetInputName(sessionHandle, i);\n      if (name === 0) {\n        checkLastError('Can\\'t get an input name.');\n      }\n      inputNamesUTF8Encoded.push(name);\n      inputNames.push(wasm.UTF8ToString(name));\n    }\n    for (let i = 0; i < outputCount; i++) {\n      const name = wasm._OrtGetOutputName(sessionHandle, i);\n      if (name === 0) {\n        checkLastError('Can\\'t get an output name.');\n      }\n      outputNamesUTF8Encoded.push(name);\n      const nameString = wasm.UTF8ToString(name);\n      outputNames.push(nameString);\n\n      if (!BUILD_DEFS.DISABLE_WEBGPU) {\n        if (enableGraphCapture && options?.preferredOutputLocation === undefined) {\n          outputPreferredLocations.push('gpu-buffer');\n          continue;\n        }\n        const location = typeof options?.preferredOutputLocation === 'string' ?\n            options.preferredOutputLocation :\n            options?.preferredOutputLocation?.[nameString] ?? 'cpu';\n        if (location !== 'cpu' && location !== 'cpu-pinned' && location !== 'gpu-buffer') {\n          throw new Error(`Not supported preferred output location: ${location}.`);\n        }\n        if (enableGraphCapture && location !== 'gpu-buffer') {\n          throw new Error(`Not supported preferred output location: ${\n              location}. Only 'gpu-buffer' location is supported when enableGraphCapture is true.`);\n        }\n        outputPreferredLocations.push(location);\n      }\n    }\n\n    // use IO binding only when at least one output is preffered to be on GPU.\n    let bindingState: IOBindingState|null = null;\n    if (!BUILD_DEFS.DISABLE_WEBGPU && outputPreferredLocations.some(l => l === 'gpu-buffer')) {\n      ioBindingHandle = wasm._OrtCreateBinding(sessionHandle);\n      if (ioBindingHandle === 0) {\n        checkLastError('Can\\'t create IO binding.');\n      }\n\n      bindingState = {\n        handle: ioBindingHandle,\n        outputPreferredLocations,\n        outputPreferredLocationsEncoded: outputPreferredLocations.map(l => dataLocationStringToEnum(l)),\n      };\n    }\n\n    activeSessions.set(\n        sessionHandle,\n        [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, bindingState, enableGraphCapture, false]);\n    return [sessionHandle, inputNames, outputNames];\n  } catch (e) {\n    inputNamesUTF8Encoded.forEach(buf => wasm._OrtFree(buf));\n    outputNamesUTF8Encoded.forEach(buf => wasm._OrtFree(buf));\n\n    if (ioBindingHandle !== 0) {\n      wasm._OrtReleaseBinding(ioBindingHandle);\n    }\n\n    if (sessionHandle !== 0) {\n      wasm._OrtReleaseSession(sessionHandle);\n    }\n    throw e;\n  } finally {\n    wasm._free(modelDataOffset);\n    if (sessionOptionsHandle !== 0) {\n      wasm._OrtReleaseSessionOptions(sessionOptionsHandle);\n    }\n    allocs.forEach(alloc => wasm._free(alloc));\n\n    // unmount external data if necessary\n    wasm.unmountExternalData?.();\n  }\n};\n\nexport const releaseSession = (sessionId: number): void => {\n  const wasm = getInstance();\n  const session = activeSessions.get(sessionId);\n  if (!session) {\n    throw new Error(`cannot release session. invalid session id: ${sessionId}`);\n  }\n  const [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture] = session;\n\n  if (ioBindingState) {\n    if (enableGraphCapture) {\n      wasm._OrtClearBoundOutputs(ioBindingState.handle);\n    }\n    wasm._OrtReleaseBinding(ioBindingState.handle);\n  }\n\n  wasm.jsepOnReleaseSession?.(sessionId);\n\n  inputNamesUTF8Encoded.forEach(buf => wasm._OrtFree(buf));\n  outputNamesUTF8Encoded.forEach(buf => wasm._OrtFree(buf));\n  wasm._OrtReleaseSession(sessionHandle);\n  activeSessions.delete(sessionId);\n};\n\nexport const prepareInputOutputTensor =\n    (tensor: TensorMetadata|null, tensorHandles: number[], allocs: number[], sessionId: number, index: number,\n     enableGraphCapture = false): void => {\n      if (!tensor) {\n        tensorHandles.push(0);\n        return;\n      }\n\n      const wasm = getInstance();\n\n      const dataType = tensor[0];\n      const dims = tensor[1];\n      const location = tensor[3];\n\n      let rawData: number;\n      let dataByteLength: number;\n\n      if (dataType === 'string' && location === 'gpu-buffer') {\n        throw new Error('String tensor is not supported on GPU.');\n      }\n\n      if (enableGraphCapture && location !== 'gpu-buffer') {\n        throw new Error(\n            `External buffer must be provided for input/output index ${index} when enableGraphCapture is true.`);\n      }\n\n      if (location === 'gpu-buffer') {\n        const gpuBuffer = tensor[2].gpuBuffer as GPUBuffer;\n        const elementSizeInBytes = getTensorElementSize(tensorDataTypeStringToEnum(dataType))!;\n        dataByteLength = dims.reduce((a, b) => a * b, 1) * elementSizeInBytes;\n\n        const registerBuffer = wasm.jsepRegisterBuffer;\n        if (!registerBuffer) {\n          throw new Error('Tensor location \"gpu-buffer\" is not supported without using WebGPU.');\n        }\n        rawData = registerBuffer(sessionId, index, gpuBuffer, dataByteLength);\n      } else {\n        const data = tensor[2];\n\n        if (Array.isArray(data)) {\n          // string tensor\n          dataByteLength = 4 * data.length;\n          rawData = wasm._malloc(dataByteLength);\n          allocs.push(rawData);\n          let dataIndex = rawData / 4;\n          for (let i = 0; i < data.length; i++) {\n            if (typeof data[i] !== 'string') {\n              throw new TypeError(`tensor data at index ${i} is not a string`);\n            }\n            wasm.HEAPU32[dataIndex++] = allocWasmString(data[i], allocs);\n          }\n        } else {\n          dataByteLength = data.byteLength;\n          rawData = wasm._malloc(dataByteLength);\n          allocs.push(rawData);\n          wasm.HEAPU8.set(new Uint8Array(data.buffer, data.byteOffset, dataByteLength), rawData);\n        }\n      }\n\n      const stack = wasm.stackSave();\n      const dimsOffset = wasm.stackAlloc(4 * dims.length);\n      try {\n        let dimIndex = dimsOffset / 4;\n        dims.forEach(d => wasm.HEAP32[dimIndex++] = d);\n        const tensor = wasm._OrtCreateTensor(\n            tensorDataTypeStringToEnum(dataType), rawData, dataByteLength, dimsOffset, dims.length,\n            dataLocationStringToEnum(location));\n        if (tensor === 0) {\n          checkLastError(`Can't create tensor for input/output. session=${sessionId}, index=${index}.`);\n        }\n        tensorHandles.push(tensor);\n      } finally {\n        wasm.stackRestore(stack);\n      }\n    };\n\n/**\n * perform inference run\n */\nexport const run = async(\n    sessionId: number, inputIndices: number[], inputTensors: TensorMetadata[], outputIndices: number[],\n    outputTensors: Array<TensorMetadata|null>, options: InferenceSession.RunOptions): Promise<TensorMetadata[]> => {\n  const wasm = getInstance();\n  const session = activeSessions.get(sessionId);\n  if (!session) {\n    throw new Error(`cannot run inference. invalid session id: ${sessionId}`);\n  }\n  const sessionHandle = session[0];\n  const inputNamesUTF8Encoded = session[1];\n  const outputNamesUTF8Encoded = session[2];\n  const ioBindingState = session[3];\n  const enableGraphCapture = session[4];\n  const inputOutputBound = session[5];\n\n  const inputCount = inputIndices.length;\n  const outputCount = outputIndices.length;\n\n  let runOptionsHandle = 0;\n  let runOptionsAllocs: number[] = [];\n\n  const inputTensorHandles: number[] = [];\n  const outputTensorHandles: number[] = [];\n  const inputOutputAllocs: number[] = [];\n\n  const beforeRunStack = wasm.stackSave();\n  const inputValuesOffset = wasm.stackAlloc(inputCount * 4);\n  const inputNamesOffset = wasm.stackAlloc(inputCount * 4);\n  const outputValuesOffset = wasm.stackAlloc(outputCount * 4);\n  const outputNamesOffset = wasm.stackAlloc(outputCount * 4);\n\n  try {\n    [runOptionsHandle, runOptionsAllocs] = setRunOptions(options);\n\n    // create input tensors\n    for (let i = 0; i < inputCount; i++) {\n      prepareInputOutputTensor(\n          inputTensors[i], inputTensorHandles, inputOutputAllocs, sessionId, inputIndices[i], enableGraphCapture);\n    }\n\n    // create output tensors\n    for (let i = 0; i < outputCount; i++) {\n      prepareInputOutputTensor(\n          outputTensors[i], outputTensorHandles, inputOutputAllocs, sessionId, inputCount + outputIndices[i],\n          enableGraphCapture);\n    }\n\n    let inputValuesIndex = inputValuesOffset / 4;\n    let inputNamesIndex = inputNamesOffset / 4;\n    let outputValuesIndex = outputValuesOffset / 4;\n    let outputNamesIndex = outputNamesOffset / 4;\n    for (let i = 0; i < inputCount; i++) {\n      wasm.HEAPU32[inputValuesIndex++] = inputTensorHandles[i];\n      wasm.HEAPU32[inputNamesIndex++] = inputNamesUTF8Encoded[inputIndices[i]];\n    }\n    for (let i = 0; i < outputCount; i++) {\n      wasm.HEAPU32[outputValuesIndex++] = outputTensorHandles[i];\n      wasm.HEAPU32[outputNamesIndex++] = outputNamesUTF8Encoded[outputIndices[i]];\n    }\n\n    if (!BUILD_DEFS.DISABLE_WEBGPU && ioBindingState && !inputOutputBound) {\n      const {handle, outputPreferredLocations, outputPreferredLocationsEncoded} = ioBindingState;\n\n      if (inputNamesUTF8Encoded.length !== inputCount) {\n        throw new Error(`input count from feeds (${\n            inputCount}) is expected to be always equal to model's input count (${inputNamesUTF8Encoded.length}).`);\n      }\n\n      // process inputs\n      for (let i = 0; i < inputCount; i++) {\n        const index = inputIndices[i];\n        const errorCode = await wasm._OrtBindInput(handle, inputNamesUTF8Encoded[index], inputTensorHandles[i]);\n        if (errorCode !== 0) {\n          checkLastError(`Can't bind input[${i}] for session=${sessionId}.`);\n        }\n      }\n\n      // process pre-allocated outputs\n      for (let i = 0; i < outputCount; i++) {\n        const index = outputIndices[i];\n        const location = outputTensors[i]?.[3];  // undefined means output is not pre-allocated.\n\n        if (location) {\n          // output is pre-allocated. bind the tensor.\n          const errorCode = wasm._OrtBindOutput(handle, outputNamesUTF8Encoded[index], outputTensorHandles[i], 0);\n          if (errorCode !== 0) {\n            checkLastError(`Can't bind pre-allocated output[${i}] for session=${sessionId}.`);\n          }\n        } else {\n          // output is not pre-allocated. reset preferred location.\n          const errorCode =\n              wasm._OrtBindOutput(handle, outputNamesUTF8Encoded[index], 0, outputPreferredLocationsEncoded[index]);\n          if (errorCode !== 0) {\n            checkLastError(`Can't bind output[${i}] to ${outputPreferredLocations[i]} for session=${sessionId}.`);\n          }\n        }\n      }\n      activeSessions.set(\n          sessionId,\n          [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture, true]);\n    }\n\n    wasm.jsepOnRunStart?.(sessionHandle);\n    let errorCode: number;\n    if (!BUILD_DEFS.DISABLE_WEBGPU && ioBindingState) {\n      errorCode = await wasm._OrtRunWithBinding(\n          sessionHandle, ioBindingState.handle, outputCount, outputValuesOffset, runOptionsHandle);\n    } else {\n      errorCode = await wasm._OrtRun(\n          sessionHandle, inputNamesOffset, inputValuesOffset, inputCount, outputNamesOffset, outputCount,\n          outputValuesOffset, runOptionsHandle);\n    }\n\n    if (errorCode !== 0) {\n      checkLastError('failed to call OrtRun().');\n    }\n\n    const output: TensorMetadata[] = [];\n\n    for (let i = 0; i < outputCount; i++) {\n      const tensor = wasm.HEAPU32[outputValuesOffset / 4 + i];\n      if (tensor === outputTensorHandles[i]) {\n        // output tensor is pre-allocated. no need to copy data.\n        output.push(outputTensors[i]!);\n        continue;\n      }\n\n      const beforeGetTensorDataStack = wasm.stackSave();\n      // stack allocate 4 pointer value\n      const tensorDataOffset = wasm.stackAlloc(4 * 4);\n\n      let keepOutputTensor = false;\n      let type: Tensor.Type|undefined, dataOffset = 0;\n      try {\n        const errorCode = wasm._OrtGetTensorData(\n            tensor, tensorDataOffset, tensorDataOffset + 4, tensorDataOffset + 8, tensorDataOffset + 12);\n        if (errorCode !== 0) {\n          checkLastError(`Can't access output tensor data on index ${i}.`);\n        }\n        let tensorDataIndex = tensorDataOffset / 4;\n        const dataType = wasm.HEAPU32[tensorDataIndex++];\n        dataOffset = wasm.HEAPU32[tensorDataIndex++];\n        const dimsOffset = wasm.HEAPU32[tensorDataIndex++];\n        const dimsLength = wasm.HEAPU32[tensorDataIndex++];\n        const dims = [];\n        for (let i = 0; i < dimsLength; i++) {\n          dims.push(wasm.HEAPU32[dimsOffset / 4 + i]);\n        }\n        wasm._OrtFree(dimsOffset);\n\n        const size = dims.reduce((a, b) => a * b, 1);\n        type = tensorDataTypeEnumToString(dataType);\n\n        const preferredLocation = ioBindingState?.outputPreferredLocations[outputIndices[i]];\n\n        if (type === 'string') {\n          if (preferredLocation === 'gpu-buffer') {\n            throw new Error('String tensor is not supported on GPU.');\n          }\n          const stringData: string[] = [];\n          let dataIndex = dataOffset / 4;\n          for (let i = 0; i < size; i++) {\n            const offset = wasm.HEAPU32[dataIndex++];\n            const maxBytesToRead = i === size - 1 ? undefined : wasm.HEAPU32[dataIndex] - offset;\n            stringData.push(wasm.UTF8ToString(offset, maxBytesToRead));\n          }\n          output.push([type, dims, stringData, 'cpu']);\n        } else {\n          // If a certain output's preferred location is GPU but the tensor is empty, we still need to create a CPU\n          // tensor for it. There is no mapping GPU buffer for an empty tensor.\n          if (preferredLocation === 'gpu-buffer' && size > 0) {\n            const getBuffer = wasm.jsepGetBuffer;\n            if (!getBuffer) {\n              throw new Error('preferredLocation \"gpu-buffer\" is not supported without using WebGPU.');\n            }\n            const gpuBuffer = getBuffer(dataOffset);\n            const elementSize = getTensorElementSize(dataType);\n            if (elementSize === undefined || !isGpuBufferSupportedType(type)) {\n              throw new Error(`Unsupported data type: ${type}`);\n            }\n\n            // do not release the tensor right now. it will be released when user calls tensor.dispose().\n            keepOutputTensor = true;\n\n            output.push([\n              type, dims, {\n                gpuBuffer,\n                download: wasm.jsepCreateDownloader!(gpuBuffer, size * elementSize, type),\n                dispose: () => {\n                  wasm._OrtReleaseTensor(tensor);\n                }\n              },\n              'gpu-buffer'\n            ]);\n          } else {\n            const typedArrayConstructor = tensorTypeToTypedArrayConstructor(type);\n            const data = new typedArrayConstructor(size);\n            new Uint8Array(data.buffer, data.byteOffset, data.byteLength)\n                .set(wasm.HEAPU8.subarray(dataOffset, dataOffset + data.byteLength));\n            output.push([type, dims, data, 'cpu']);\n          }\n        }\n      } finally {\n        wasm.stackRestore(beforeGetTensorDataStack);\n        if (type === 'string' && dataOffset) {\n          wasm._free(dataOffset);\n        }\n        if (!keepOutputTensor) {\n          wasm._OrtReleaseTensor(tensor);\n        }\n      }\n    }\n\n    if (ioBindingState && !enableGraphCapture) {\n      wasm._OrtClearBoundOutputs(ioBindingState.handle);\n      activeSessions.set(\n          sessionId,\n          [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture, false]);\n    }\n    return output;\n  } finally {\n    wasm.stackRestore(beforeRunStack);\n\n    inputTensorHandles.forEach(v => wasm._OrtReleaseTensor(v));\n    outputTensorHandles.forEach(v => wasm._OrtReleaseTensor(v));\n    inputOutputAllocs.forEach(p => wasm._free(p));\n\n    if (runOptionsHandle !== 0) {\n      wasm._OrtReleaseRunOptions(runOptionsHandle);\n    }\n    runOptionsAllocs.forEach(p => wasm._free(p));\n  }\n};\n\n/**\n * end profiling\n */\nexport const endProfiling = (sessionId: number): void => {\n  const wasm = getInstance();\n  const session = activeSessions.get(sessionId);\n  if (!session) {\n    throw new Error('invalid session id');\n  }\n  const sessionHandle = session[0];\n\n  // profile file name is not used yet, but it must be freed.\n  const profileFileName = wasm._OrtEndProfiling(sessionHandle);\n  if (profileFileName === 0) {\n    checkLastError('Can\\'t get an profile file name.');\n  }\n  wasm._OrtFree(profileFileName);\n};\n\nexport const extractTransferableBuffers = (tensors: readonly SerializableTensorMetadata[]): ArrayBufferLike[] => {\n  const buffers: ArrayBufferLike[] = [];\n  for (const tensor of tensors) {\n    const data = tensor[2];\n    if (!Array.isArray(data) && 'buffer' in data) {\n      buffers.push(data.buffer);\n    }\n  }\n  return buffers;\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport * as fs from 'fs';\nimport {readFile} from 'node:fs/promises';\n\n/**\n * Load a file into a Uint8Array.\n *\n * @param file - the file to load. Can be a URL/path, a Blob, an ArrayBuffer, or a Uint8Array.\n * @returns a Uint8Array containing the file data.\n */\nexport const loadFile = async(file: string|Blob|ArrayBufferLike|Uint8Array): Promise<Uint8Array> => {\n  if (typeof file === 'string') {\n    if (typeof process !== 'undefined' && process.versions && process.versions.node) {\n      // load file into ArrayBuffer in Node.js\n      try {\n        return new Uint8Array(await readFile(file));\n      } catch (e) {\n        if (e.code === 'ERR_FS_FILE_TOO_LARGE') {\n          // file is too large, use fs.createReadStream instead\n          const stream = fs.createReadStream(file);\n          const chunks: Uint8Array[] = [];\n          for await (const chunk of stream) {\n            chunks.push(chunk);\n          }\n          return new Uint8Array(Buffer.concat(chunks));\n        }\n        throw e;\n      }\n    } else {\n      // load file into ArrayBuffer in browsers\n      const response = await fetch(file);\n      if (!response.ok) {\n        throw new Error(`failed to load external data file: ${file}`);\n      }\n      const contentLengthHeader = response.headers.get('Content-Length');\n      const fileSize = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;\n      if (fileSize < 1073741824 /* 1GB */) {\n        // when Content-Length header is not set, we cannot determine the file size. We assume it is small enough to\n        // load into memory.\n        return new Uint8Array(await response.arrayBuffer());\n      } else {\n        // file is too large, use stream instead\n        if (!response.body) {\n          throw new Error(`failed to load external data file: ${file}, no response body.`);\n        }\n        const reader = response.body.getReader();\n\n        let buffer;\n        try {\n          // try to create ArrayBuffer directly\n          buffer = new ArrayBuffer(fileSize);\n        } catch (e) {\n          if (e instanceof RangeError) {\n            // use WebAssembly Memory to allocate larger ArrayBuffer\n            const pages = Math.ceil(fileSize / 65536);\n            buffer = new WebAssembly.Memory({initial: pages, maximum: pages}).buffer;\n          } else {\n            throw e;\n          }\n        }\n\n        let offset = 0;\n        // eslint-disable-next-line no-constant-condition\n        while (true) {\n          const {done, value} = await reader.read();\n          if (done) {\n            break;\n          }\n          const chunkSize = value.byteLength;\n          const chunk = new Uint8Array(buffer, offset, chunkSize);\n          chunk.set(value);\n          offset += chunkSize;\n        }\n        return new Uint8Array(buffer, 0, fileSize);\n      }\n    }\n\n  } else if (file instanceof Blob) {\n    return new Uint8Array(await file.arrayBuffer());\n  } else if (file instanceof Uint8Array) {\n    return file;\n  } else {\n    return new Uint8Array(file);\n  }\n};\n", "export const readFile = undefined;export const readFileSync = undefined;export const createReadStream = undefined;", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/// <reference lib=\"webworker\" />\n\n//\n// * type hack for \"HTMLImageElement\"\n//\n// in typescript, the type of \"HTMLImageElement\" is defined in lib.dom.d.ts, which is conflict with lib.webworker.d.ts.\n// when we use webworker, the lib.webworker.d.ts will be used, which does not have HTMLImageElement defined.\n//\n// we will get the following errors complaining that HTMLImageElement is not defined:\n//\n// ====================================================================================================================\n//\n// ../common/dist/cjs/tensor-factory.d.ts:187:29 - error TS2552: Cannot find name 'HTMLImageElement'. Did you mean\n// 'HTMLLIElement'?\n//\n// 187     fromImage(imageElement: HTMLImageElement, options?: TensorFromImageElementOptions):\n// Promise<TypedTensor<'float32'> | TypedTensor<'uint8'>>;\n//                                 ~~~~~~~~~~~~~~~~\n//\n// node_modules/@webgpu/types/dist/index.d.ts:83:7 - error TS2552: Cannot find name 'HTMLImageElement'. Did you mean\n// 'HTMLLIElement'?\n//\n// 83     | HTMLImageElement\n//          ~~~~~~~~~~~~~~~~\n//\n// ====================================================================================================================\n//\n// `HTMLImageElement` is only used in type declaration and not in real code. So we define it as `unknown` here to\n// bypass the type check.\n//\ndeclare global {\n  type HTMLImageElement = unknown;\n}\n\nimport {OrtWasmMessage, SerializableTensorMetadata} from '../proxy-messages';\nimport {createSession, copyFromExternalBuffer, endProfiling, extractTransferableBuffers, initEp, initRuntime, releaseSession, run} from '../wasm-core-impl';\nimport {initializeWebAssembly} from '../wasm-factory';\n\nself.onmessage = (ev: MessageEvent<OrtWasmMessage>): void => {\n  const {type, in : message} = ev.data;\n  try {\n    switch (type) {\n      case 'init-wasm':\n        initializeWebAssembly(message!.wasm)\n            .then(\n                () => {\n                  initRuntime(message!).then(\n                      () => {\n                        postMessage({type});\n                      },\n                      err => {\n                        postMessage({type, err});\n                      });\n                },\n                err => {\n                  postMessage({type, err});\n                });\n        break;\n      case 'init-ep': {\n        const {epName, env} = message!;\n        initEp(env, epName)\n            .then(\n                () => {\n                  postMessage({type});\n                },\n                err => {\n                  postMessage({type, err});\n                });\n        break;\n      }\n      case 'copy-from': {\n        const {buffer} = message!;\n        const bufferData = copyFromExternalBuffer(buffer);\n        postMessage({type, out: bufferData} as OrtWasmMessage);\n        break;\n      }\n      case 'create': {\n        const {model, options} = message!;\n        createSession(model, options)\n            .then(\n                sessionMetadata => {\n                  postMessage({type, out: sessionMetadata} as OrtWasmMessage);\n                },\n                err => {\n                  postMessage({type, err});\n                });\n        break;\n      }\n      case 'release':\n        releaseSession(message!);\n        postMessage({type});\n        break;\n      case 'run': {\n        const {sessionId, inputIndices, inputs, outputIndices, options} = message!;\n        run(sessionId, inputIndices, inputs, outputIndices, new Array(outputIndices.length).fill(null), options)\n            .then(\n                outputs => {\n                  if (outputs.some(o => o[3] !== 'cpu')) {\n                    postMessage({type, err: 'Proxy does not support non-cpu tensor location.'});\n                  } else {\n                    postMessage(\n                        {type, out: outputs} as OrtWasmMessage,\n                        extractTransferableBuffers([...inputs, ...outputs] as SerializableTensorMetadata[]));\n                  }\n                },\n                err => {\n                  postMessage({type, err});\n                });\n        break;\n      }\n      case 'end-profiling':\n        endProfiling(message!);\n        postMessage({type});\n        break;\n      default:\n    }\n  } catch (err) {\n    postMessage({type, err} as OrtWasmMessage);\n  }\n};\n"],
  "mappings": "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YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YACnf,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,GAAE;AAAA,YAAG,IAAG;AAAA,YAAG,IAAG;AAAA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",
  "names": ["join", "env", "pad", "init", "offsets", "indices", "impl", "validateInputs", "reduceOps", "validateInputs", "validateInputs", "i", "validateInputs", "env", "validateInputs", "validateInputs", "a", "b", "transpose", "outputVariable", "innerElementSize", "validateInputs", "validateInputs", "outputShape", "transposedWeight", "convInputs", "innerElementSize", "validateInputs", "validateInputs", "permFunctionBody", "symbol", "reduceOps", "validateInputs", "calculateOutputShape", "fastGelu", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "dataType", "validateInputs", "weightTransposeAttribute", "validateInputs", "validateInputs", "env", "env", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "components", "validateInputs", "validateInputs", "getOutputShape", "a", "b", "c", "fastGelu", "env", "i", "env", "wasm", "wasm", "wasm", "readFile", "readFile", "env", "wasm", "tensor", "errorCode", "i", "env"]
}
\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {env, InferenceSession} from 'onnxruntime-common';\n\nimport {OrtWasmMessage, SerializableInternalBuffer, SerializableSessionMetadata, SerializableTensorMetadata, TensorMetadata} from './proxy-messages';\nimport * as core from './wasm-core-impl';\nimport {initializeWebAssembly} from './wasm-factory';\n\nconst isProxy = (): boolean => !!env.wasm.proxy && typeof document !== 'undefined';\nlet proxyWorker: Worker|undefined;\nlet initializing = false;\nlet initialized = false;\nlet aborted = false;\n\ntype PromiseCallbacks<T = void> = [resolve: (result: T) => void, reject: (reason: unknown) => void];\nlet initWasmCallbacks: PromiseCallbacks;\nconst queuedCallbacks: Map<OrtWasmMessage['type'], Array<PromiseCallbacks<unknown>>> = new Map();\n\nconst enqueueCallbacks = (type: OrtWasmMessage['type'], callbacks: PromiseCallbacks<unknown>): void => {\n  const queue = queuedCallbacks.get(type);\n  if (queue) {\n    queue.push(callbacks);\n  } else {\n    queuedCallbacks.set(type, [callbacks]);\n  }\n};\n\nconst ensureWorker = (): void => {\n  if (initializing || !initialized || aborted || !proxyWorker) {\n    throw new Error('worker not ready');\n  }\n};\n\nconst onProxyWorkerMessage = (ev: MessageEvent<OrtWasmMessage>): void => {\n  switch (ev.data.type) {\n    case 'init-wasm':\n      initializing = false;\n      if (ev.data.err) {\n        aborted = true;\n        initWasmCallbacks[1](ev.data.err);\n      } else {\n        initialized = true;\n        initWasmCallbacks[0]();\n      }\n      break;\n    case 'init-ep':\n    case 'copy-from':\n    case 'create':\n    case 'release':\n    case 'run':\n    case 'end-profiling': {\n      const callbacks = queuedCallbacks.get(ev.data.type)!;\n      if (ev.data.err) {\n        callbacks.shift()![1](ev.data.err);\n      } else {\n        callbacks.shift()![0](ev.data.out!);\n      }\n      break;\n    }\n    default:\n  }\n};\n\nconst scriptSrc = typeof document !== 'undefined' ? (document?.currentScript as HTMLScriptElement)?.src : undefined;\n\nexport const initializeWebAssemblyAndOrtRuntime = async(): Promise<void> => {\n  if (initialized) {\n    return;\n  }\n  if (initializing) {\n    throw new Error('multiple calls to \\'initWasm()\\' detected.');\n  }\n  if (aborted) {\n    throw new Error('previous call to \\'initWasm()\\' failed.');\n  }\n\n  initializing = true;\n\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    // overwrite wasm filepaths\n    if (env.wasm.wasmPaths === undefined) {\n      if (scriptSrc && scriptSrc.indexOf('blob:') !== 0) {\n        env.wasm.wasmPaths = scriptSrc.substr(0, +(scriptSrc).lastIndexOf('/') + 1);\n      }\n    }\n\n    return new Promise<void>((resolve, reject) => {\n      proxyWorker?.terminate();\n\n      const workerUrl = URL.createObjectURL(new Blob(\n          [\n            // This require() function is handled by esbuild plugin to load file content as string.\n            // eslint-disable-next-line @typescript-eslint/no-require-imports\n            require('./proxy-worker/main')\n          ],\n          {type: 'text/javascript'}));\n      proxyWorker = new Worker(workerUrl, {name: 'ort-wasm-proxy-worker'});\n      proxyWorker.onerror = (ev: ErrorEvent) => reject(ev);\n      proxyWorker.onmessage = onProxyWorkerMessage;\n      URL.revokeObjectURL(workerUrl);\n      initWasmCallbacks = [resolve, reject];\n      const message: OrtWasmMessage = {type: 'init-wasm', in : env};\n      proxyWorker.postMessage(message);\n    });\n\n  } else {\n    try {\n      await initializeWebAssembly(env.wasm);\n      await core.initRuntime(env);\n      initialized = true;\n    } catch (e) {\n      aborted = true;\n      throw e;\n    } finally {\n      initializing = false;\n    }\n  }\n};\n\nexport const initializeOrtEp = async(epName: string): Promise<void> => {\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    ensureWorker();\n    return new Promise<void>((resolve, reject) => {\n      enqueueCallbacks('init-ep', [resolve, reject]);\n      const message: OrtWasmMessage = {type: 'init-ep', in : {epName, env}};\n      proxyWorker!.postMessage(message);\n    });\n  } else {\n    await core.initEp(env, epName);\n  }\n};\n\nexport const copyFromExternalBuffer = async(buffer: Uint8Array): Promise<SerializableInternalBuffer> => {\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    ensureWorker();\n    return new Promise<SerializableInternalBuffer>((resolve, reject) => {\n      enqueueCallbacks('copy-from', [resolve, reject]);\n      const message: OrtWasmMessage = {type: 'copy-from', in : {buffer}};\n      proxyWorker!.postMessage(message, [buffer.buffer]);\n    });\n  } else {\n    return core.copyFromExternalBuffer(buffer);\n  }\n};\n\nexport const createSession =\n    async(model: SerializableInternalBuffer|Uint8Array, options?: InferenceSession.SessionOptions):\n        Promise<SerializableSessionMetadata> => {\n          if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n            // check unsupported options\n            if (options?.preferredOutputLocation) {\n              throw new Error('session option \"preferredOutputLocation\" is not supported for proxy.');\n            }\n            ensureWorker();\n            return new Promise<SerializableSessionMetadata>((resolve, reject) => {\n              enqueueCallbacks('create', [resolve, reject]);\n              const message: OrtWasmMessage = {type: 'create', in : {model, options: {...options}}};\n              const transferable: Transferable[] = [];\n              if (model instanceof Uint8Array) {\n                transferable.push(model.buffer);\n              }\n              proxyWorker!.postMessage(message, transferable);\n            });\n          } else {\n            return core.createSession(model, options);\n          }\n        };\n\nexport const releaseSession = async(sessionId: number): Promise<void> => {\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    ensureWorker();\n    return new Promise<void>((resolve, reject) => {\n      enqueueCallbacks('release', [resolve, reject]);\n      const message: OrtWasmMessage = {type: 'release', in : sessionId};\n      proxyWorker!.postMessage(message);\n    });\n  } else {\n    core.releaseSession(sessionId);\n  }\n};\n\nexport const run = async(\n    sessionId: number, inputIndices: number[], inputs: TensorMetadata[], outputIndices: number[],\n    outputs: Array<TensorMetadata|null>, options: InferenceSession.RunOptions): Promise<TensorMetadata[]> => {\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    // check inputs location\n    if (inputs.some(t => t[3] !== 'cpu')) {\n      throw new Error('input tensor on GPU is not supported for proxy.');\n    }\n    // check outputs location\n    if (outputs.some(t => t)) {\n      throw new Error('pre-allocated output tensor is not supported for proxy.');\n    }\n    ensureWorker();\n    return new Promise<SerializableTensorMetadata[]>((resolve, reject) => {\n      enqueueCallbacks('run', [resolve, reject]);\n      const serializableInputs = inputs as SerializableTensorMetadata[];  // every input is on CPU.\n      const message: OrtWasmMessage =\n          {type: 'run', in : {sessionId, inputIndices, inputs: serializableInputs, outputIndices, options}};\n      proxyWorker!.postMessage(message, core.extractTransferableBuffers(serializableInputs));\n    });\n  } else {\n    return core.run(sessionId, inputIndices, inputs, outputIndices, outputs, options);\n  }\n};\n\nexport const endProfiling = async(sessionId: number): Promise<void> => {\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    ensureWorker();\n    return new Promise<void>((resolve, reject) => {\n      enqueueCallbacks('end-profiling', [resolve, reject]);\n      const message: OrtWasmMessage = {type: 'end-profiling', in : sessionId};\n      proxyWorker!.postMessage(message);\n    });\n  } else {\n    core.endProfiling(sessionId);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {InferenceSession, InferenceSessionHandler, SessionHandler, Tensor, TRACE_FUNC_BEGIN, TRACE_FUNC_END} from 'onnxruntime-common';\n\nimport {SerializableInternalBuffer, TensorMetadata} from './proxy-messages';\nimport {copyFromExternalBuffer, createSession, endProfiling, releaseSession, run} from './proxy-wrapper';\nimport {isGpuBufferSupportedType} from './wasm-common';\nimport {loadFile} from './wasm-utils-load-file';\n\nexport const encodeTensorMetadata = (tensor: Tensor, getName: () => string): TensorMetadata => {\n  switch (tensor.location) {\n    case 'cpu':\n      return [tensor.type, tensor.dims, tensor.data, 'cpu'];\n    case 'gpu-buffer':\n      return [tensor.type, tensor.dims, {gpuBuffer: tensor.gpuBuffer}, 'gpu-buffer'];\n    default:\n      throw new Error(`invalid data location: ${tensor.location} for ${getName()}`);\n  }\n};\n\nexport const decodeTensorMetadata = (tensor: TensorMetadata): Tensor => {\n  switch (tensor[3]) {\n    case 'cpu':\n      return new Tensor(tensor[0], tensor[2], tensor[1]);\n    case 'gpu-buffer': {\n      const dataType = tensor[0];\n      if (!isGpuBufferSupportedType(dataType)) {\n        throw new Error(`not supported data type: ${dataType} for deserializing GPU tensor`);\n      }\n      const {gpuBuffer, download, dispose} = tensor[2];\n      return Tensor.fromGpuBuffer(gpuBuffer, {dataType, dims: tensor[1], download, dispose});\n    }\n    default:\n      throw new Error(`invalid data location: ${tensor[3]}`);\n  }\n};\n\nexport class OnnxruntimeWebAssemblySessionHandler implements InferenceSessionHandler {\n  private sessionId: number;\n\n  inputNames: string[];\n  outputNames: string[];\n\n  async fetchModelAndCopyToWasmMemory(path: string): Promise<SerializableInternalBuffer> {\n    // fetch model from url and move to wasm heap.\n    return copyFromExternalBuffer(await loadFile(path));\n  }\n\n  async loadModel(pathOrBuffer: string|Uint8Array, options?: InferenceSession.SessionOptions): Promise<void> {\n    TRACE_FUNC_BEGIN();\n    let model: Parameters<typeof createSession>[0];\n\n    if (typeof pathOrBuffer === 'string') {\n      if (typeof process !== 'undefined' && process.versions && process.versions.node) {\n        // node\n        model = await loadFile(pathOrBuffer);\n      } else {\n        // browser\n        // fetch model and copy to wasm heap.\n        model = await this.fetchModelAndCopyToWasmMemory(pathOrBuffer);\n      }\n    } else {\n      model = pathOrBuffer;\n    }\n\n    [this.sessionId, this.inputNames, this.outputNames] = await createSession(model, options);\n    TRACE_FUNC_END();\n  }\n\n  async dispose(): Promise<void> {\n    return releaseSession(this.sessionId);\n  }\n\n  async run(feeds: SessionHandler.FeedsType, fetches: SessionHandler.FetchesType, options: InferenceSession.RunOptions):\n      Promise<SessionHandler.ReturnType> {\n    TRACE_FUNC_BEGIN();\n    const inputArray: Tensor[] = [];\n    const inputIndices: number[] = [];\n    Object.entries(feeds).forEach(kvp => {\n      const name = kvp[0];\n      const tensor = kvp[1];\n      const index = this.inputNames.indexOf(name);\n      if (index === -1) {\n        throw new Error(`invalid input '${name}'`);\n      }\n      inputArray.push(tensor);\n      inputIndices.push(index);\n    });\n\n    const outputArray: Array<Tensor|null> = [];\n    const outputIndices: number[] = [];\n    Object.entries(fetches).forEach(kvp => {\n      const name = kvp[0];\n      const tensor = kvp[1];\n      const index = this.outputNames.indexOf(name);\n      if (index === -1) {\n        throw new Error(`invalid output '${name}'`);\n      }\n      outputArray.push(tensor);\n      outputIndices.push(index);\n    });\n\n    const inputs =\n        inputArray.map((t, i) => encodeTensorMetadata(t, () => `input \"${this.inputNames[inputIndices[i]]}\"`));\n    const outputs = outputArray.map(\n        (t, i) => t ? encodeTensorMetadata(t, () => `output \"${this.outputNames[outputIndices[i]]}\"`) : null);\n\n    const results = await run(this.sessionId, inputIndices, inputs, outputIndices, outputs, options);\n\n    const resultMap: SessionHandler.ReturnType = {};\n    for (let i = 0; i < results.length; i++) {\n      resultMap[this.outputNames[outputIndices[i]]] = outputArray[i] ?? decodeTensorMetadata(results[i]);\n    }\n    TRACE_FUNC_END();\n    return resultMap;\n  }\n\n  startProfiling(): void {\n    // TODO: implement profiling\n  }\n\n  endProfiling(): void {\n    void endProfiling(this.sessionId);\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {cpus} from 'node:os';\nimport {Backend, env, InferenceSession, InferenceSessionHandler} from 'onnxruntime-common';\n\nimport {initializeOrtEp, initializeWebAssemblyAndOrtRuntime} from './wasm/proxy-wrapper';\nimport {OnnxruntimeWebAssemblySessionHandler} from './wasm/session-handler-inference';\n\n/**\n * This function initializes all flags for WebAssembly.\n *\n * Those flags are accessible from `ort.env.wasm`. Users are allow to set those flags before the first inference session\n * being created, to override default value.\n */\nexport const initializeFlags = (): void => {\n  if (typeof env.wasm.initTimeout !== 'number' || env.wasm.initTimeout < 0) {\n    env.wasm.initTimeout = 0;\n  }\n\n  if (typeof env.wasm.simd !== 'boolean') {\n    env.wasm.simd = true;\n  }\n\n  if (typeof env.wasm.proxy !== 'boolean') {\n    env.wasm.proxy = false;\n  }\n\n  if (typeof env.wasm.trace !== 'boolean') {\n    env.wasm.trace = false;\n  }\n\n  if (typeof env.wasm.numThreads !== 'number' || !Number.isInteger(env.wasm.numThreads) || env.wasm.numThreads <= 0) {\n    // Web: when crossOriginIsolated is false, SharedArrayBuffer is not available so WebAssembly threads will not work.\n    // Node.js: onnxruntime-web does not support multi-threads in Node.js.\n    if ((typeof self !== 'undefined' && !self.crossOriginIsolated) ||\n        (typeof process !== 'undefined' && process.versions && process.versions.node)) {\n      env.wasm.numThreads = 1;\n    }\n    const numCpuLogicalCores = typeof navigator === 'undefined' ? cpus().length : navigator.hardwareConcurrency;\n    env.wasm.numThreads = Math.min(4, Math.ceil((numCpuLogicalCores || 1) / 2));\n  }\n};\n\nexport class OnnxruntimeWebAssemblyBackend implements Backend {\n  /**\n   * This function initializes the WebAssembly backend.\n   *\n   * This function will be called only once for each backend name. It will be called the first time when\n   * `ort.InferenceSession.create()` is called with a registered backend name.\n   *\n   * @param backendName - the registered backend name.\n   */\n  async init(backendName: string): Promise<void> {\n    // populate wasm flags\n    initializeFlags();\n\n    // init wasm\n    await initializeWebAssemblyAndOrtRuntime();\n\n    // performe EP specific initialization\n    await initializeOrtEp(backendName);\n  }\n  createInferenceSessionHandler(path: string, options?: InferenceSession.SessionOptions):\n      Promise<InferenceSessionHandler>;\n  createInferenceSessionHandler(buffer: Uint8Array, options?: InferenceSession.SessionOptions):\n      Promise<InferenceSessionHandler>;\n  async createInferenceSessionHandler(pathOrBuffer: string|Uint8Array, options?: InferenceSession.SessionOptions):\n      Promise<InferenceSessionHandler> {\n    const handler = new OnnxruntimeWebAssemblySessionHandler();\n    await handler.loadModel(pathOrBuffer, options);\n    return Promise.resolve(handler);\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {OnnxruntimeWebAssemblyBackend} from './backend-wasm';\nexport const wasmBackend = new OnnxruntimeWebAssemblyBackend();\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/* eslint-disable @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports */\n// We use \"require\" instead of \"import\" here because import statement must be put in top level. Our current code does\n// not allow bundler to tree-shaking code as expected because some codes are treated as having side effects.\n// So we import code inside the if-clause to allow bundler remove the code safely.\n\nexport * from 'onnxruntime-common';\nimport * as ort from 'onnxruntime-common';\nexport default ort;\n\nimport {registerBackend, env} from 'onnxruntime-common';\nimport {version} from './version';\n\nif (!BUILD_DEFS.DISABLE_WEBGL) {\n  const onnxjsBackend = require('./backend-onnxjs').onnxjsBackend;\n  registerBackend('webgl', onnxjsBackend, -10);\n}\n\nif (!BUILD_DEFS.DISABLE_WASM) {\n  const wasmBackend = BUILD_DEFS.DISABLE_TRAINING ? require('./backend-wasm-inference').wasmBackend :\n                                                    require('./backend-wasm-training').wasmBackend;\n  if (!BUILD_DEFS.DISABLE_WEBGPU) {\n    registerBackend('webgpu', wasmBackend, 5);\n    registerBackend('webnn', wasmBackend, 5);\n  }\n  registerBackend('cpu', wasmBackend, 10);\n  registerBackend('wasm', wasmBackend, 10);\n}\n\nObject.defineProperty(env.versions, 'web', {value: version, enumerable: true});\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// This file is generated by /js/scripts/update-version.ts\n// Do not modify file content manually.\n\nexport const version = '1.18.0';\n"],
  "mappings": "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,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAClf,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,IAAG;AAAA,UAAG,GAAE,SAAS,GAAE;AAAC,mBAAO,MAAI;AAAA,UAAC;AAAA,UAAE,IAAG;AAAA,UAAG,IAAG,SAAS,GAAE,GAAE,GAAE,GAAE;AAAC,mBAAO,GAAG,MAAI,GAAE,MAAI,GAAE,MAAI,GAAE,MAAI,CAAC;AAAA,UAAC;AAAA,QAAC,GAAE,IAAE,WAAU;AAAC,mBAAS,EAAE,GAAE;AAAC,gBAAE,EAAE;AAAQ,gBAAE,GAAG;AACnf,gBAAE,GAAG;AAAE,iBAAG,EAAE;AAAG,eAAG;AAAE,eAAG,QAAQ,EAAE,EAAE;AAAE;AAAK,iBAAG,OAAK,SAAO,OAAK,cAAc,EAAE,GAAE,KAAG,OAAM,OAAK,IAAE,IAAG,KAAG,MAAK,EAAE;AAAI,mBAAO;AAAA,UAAC;AAAC,cAAI,IAAE,EAAC,GAAE,GAAE;AAAE;AAAK,cAAG,EAAE;AAAgB,gBAAG;AAAC,qBAAO,EAAE,gBAAgB,GAAE,CAAC;AAAA,YAAC,SAAO,GAAE;AAAC,gBAAE,sDAAsD,CAAC,EAAE,GAAE,GAAG,CAAC;AAAA,YAAC;AAAC,aAAG,GAAE,SAAS,GAAE;AAAC,cAAE,EAAE,QAAQ;AAAA,UAAC,CAAC,EAAE,MAAM,EAAE;AAAE,iBAAM,CAAC;AAAA,QAAC,EAAE,GAAE,KAAG,QAAI,KAAG,EAAE,IAAI,CAAC;AAAE,UAAE,WAAS,CAAC,GAAE,OAAK,EAAE,WAAS,EAAE,IAAI,GAAE,CAAC;AAAE,UAAE,mBAAiB,CAAC,GAAE,OAAK,EAAE,mBAAiB,EAAE,IAAI,GAAE,CAAC;AACzb,UAAE,2BAAyB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,EAAE,2BAAyB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAE,UAAE,8BAA4B,CAAC,GAAE,OAAK,EAAE,8BAA4B,EAAE,IAAI,GAAE,CAAC;AAAE,UAAE,+BAA6B,CAAC,GAAE,GAAE,OAAK,EAAE,+BAA6B,EAAE,IAAI,GAAE,GAAE,CAAC;AAAE,UAAE,4BAA0B,CAAC,GAAE,GAAE,OAAK,EAAE,4BAA0B,EAAE,IAAI,GAAE,GAAE,CAAC;AAAE,UAAE,4BAA0B,QAAI,EAAE,4BAA0B,EAAE,IAAI,CAAC;AAAE,UAAE,oBAAkB,CAAC,GAAE,GAAE,OAAK,EAAE,oBAAkB,EAAE,IAAI,GAAE,GAAE,CAAC;AAC9d,UAAE,qBAAmB,QAAI,EAAE,qBAAmB,EAAE,IAAI,CAAC;AAAE,UAAE,0BAAwB,CAAC,GAAE,GAAE,OAAK,EAAE,0BAAwB,EAAE,IAAI,GAAE,GAAE,CAAC;AAAE,UAAE,mBAAiB,CAAC,GAAE,OAAK,EAAE,mBAAiB,EAAE,IAAI,GAAE,CAAC;AAAE,UAAE,oBAAkB,CAAC,GAAE,OAAK,EAAE,oBAAkB,EAAE,IAAI,GAAE,CAAC;AAAE,UAAE,WAAS,QAAI,EAAE,WAAS,EAAE,IAAI,CAAC;AAAE,UAAE,mBAAiB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,EAAE,mBAAiB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAE,UAAE,oBAAkB,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,EAAE,oBAAkB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC;AAAE,UAAE,oBAAkB,QAAI,EAAE,oBAAkB,EAAE,IAAI,CAAC;AAC5d,UAAE,uBAAqB,CAAC,GAAE,GAAE,GAAE,OAAK,EAAE,uBAAqB,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC;AAAE,UAAE,wBAAsB,CAAC,GAAE,GAAE,OAAK,EAAE,wBAAsB,EAAE,IAAI,GAAE,GAAE,CAAC;AAAE,UAAE,wBAAsB,QAAI,EAAE,wBAAsB,EAAE,IAAI,CAAC;AAAE,UAAE,oBAAkB,QAAI,EAAE,oBAAkB,EAAE,IAAI,CAAC;AAAE,UAAE,gBAAc,CAAC,GAAE,GAAE,OAAK,EAAE,gBAAc,EAAE,IAAI,GAAE,GAAE,CAAC;AAAE,UAAE,iBAAe,CAAC,GAAE,GAAE,GAAE,OAAK,EAAE,iBAAe,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC;AAAE,UAAE,wBAAsB,QAAI,EAAE,wBAAsB,EAAE,IAAI,CAAC;AAAE,UAAE,qBAAmB,QAAI,EAAE,qBAAmB,EAAE,IAAI,CAAC;AACxe,UAAE,qBAAmB,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,EAAE,qBAAmB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC;AAAE,UAAE,UAAQ,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,EAAE,UAAQ,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAE,UAAE,mBAAiB,QAAI,EAAE,mBAAiB,EAAE,IAAI,CAAC;AAAE,UAAE,cAAY,CAAC,GAAE,GAAE,OAAK,EAAE,cAAY,EAAE,IAAI,GAAE,GAAE,CAAC;AAAE,UAAE,mBAAiB,QAAI,EAAE,mBAAiB,EAAE,IAAI,CAAC;AAC/R,YAAI,KAAG,EAAE,UAAQ,QAAI,KAAG,EAAE,UAAQ,EAAE,IAAI,CAAC,GAAE,IAAE,EAAE,QAAM,QAAI,IAAE,EAAE,QAAM,EAAE,IAAI,CAAC,GAAE,IAAE,CAAC,GAAE,OAAK,IAAE,EAAE,IAAI,GAAE,CAAC,GAAE,KAAG,QAAI,KAAG,EAAE,IAAI,CAAC,GAAE,IAAE,QAAI,IAAE,EAAE,IAAI,CAAC,GAAE,KAAG,QAAI,KAAG,EAAE,IAAI,CAAC,GAAE,IAAE,OAAK,IAAE,EAAE,IAAI,GAAE,KAAG,QAAI,KAAG,EAAE,IAAI,CAAC,GAAE,KAAG,QAAI,KAAG,EAAE,IAAI,CAAC,GAAE,KAAG,CAAC,GAAE,GAAE,OAAK,KAAG,EAAE,IAAI,GAAE,GAAE,CAAC,GAAE,KAAG,QAAI,KAAG,EAAE,IAAI,CAAC,GAAE,cAAY,EAAE,cAAY,CAAC,GAAE,GAAE,OAAK,cAAY,EAAE,cAAY,EAAE,IAAI,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,eAAa,CAAC,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,eAAa,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC,GAAE,cAAY,EAAE,cAAY,CAAC,GAAE,GAAE,OAAK,cAAY,EAAE,cAAY,EAAE,IAAI,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,aAAW,CAAC,GAAE,OAAK,KAAG,EAAE,aACnf,EAAE,IAAI,GAAE,CAAC,GAAE,KAAG,EAAE,kBAAgB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,kBAAgB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,aAAW,EAAE,aAAW,CAAC,GAAE,OAAK,aAAW,EAAE,aAAW,EAAE,IAAI,GAAE,CAAC,GAAE,YAAU,EAAE,YAAU,QAAI,YAAU,EAAE,YAAU,EAAE,IAAI,CAAC,GAAE,KAAG,EAAE,iBAAe,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,iBAAe,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,eAAa,CAAC,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,eAAa,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gBAAc,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gBAAc,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,eAAa,CAAC,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,eAAa,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,iBAC3e,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,iBAAe,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gBAAc,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gBAAc,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,kBAAgB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,kBAAgB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gBAAc,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gBAAc,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,uBAAqB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,uBAAqB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,oBAAkB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,oBAAkB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,cAAY,CAAC,GAAE,GAAE,OACnf,KAAG,EAAE,cAAY,EAAE,IAAI,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,cAAY,CAAC,GAAE,GAAE,OAAK,KAAG,EAAE,cAAY,EAAE,IAAI,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,cAAY,CAAC,GAAE,GAAE,OAAK,KAAG,EAAE,cAAY,EAAE,IAAI,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,cAAY,CAAC,GAAE,GAAE,OAAK,KAAG,EAAE,cAAY,EAAE,IAAI,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,YAAU,QAAI,KAAG,EAAE,YAAU,EAAE,IAAI,CAAC,GAAE,KAAG,EAAE,oBAAkB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,oBAAkB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,kBAAgB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,kBAAgB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,aAAW,CAAC,GAAE,OAAK,KAAG,EAAE,aAAW,EAAE,IAAI,GAAE,CAAC,GAAE,KAAG,EAAE,eAAa,CAAC,GAAE,GAAE,GAAE,OAAK,KACpf,EAAE,eAAa,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,uBAAqB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,uBAAqB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,qBAAmB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,qBAAmB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,aAAW,CAAC,GAAE,OAAK,KAAG,EAAE,aAAW,EAAE,IAAI,GAAE,CAAC,GAAE,KAAG,EAAE,iBAAe,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,iBAAe,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,YAAU,QAAI,KAAG,EAAE,YAAU,EAAE,IAAI,CAAC,GAAE,KAAG,EAAE,cAAY,CAAC,GAAE,GAAE,OAAK,KAAG,EAAE,cAAY,EAAE,IAAI,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,uBAAqB,CAAC,GAAE,GAAE,GAAE,GACnf,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,uBAAqB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,uBAAqB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,uBAAqB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,mBAAiB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,mBAAiB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,mBAAiB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,mBAAiB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,oBAAkB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,oBAAkB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,yBAAuB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GACnf,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,yBAAuB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,oBAAkB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,oBAAkB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,sBAAoB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,sBAAoB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,oBAAkB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,oBAAkB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,aAAW,CAAC,GAAE,OAAK,KAAG,EAAE,aAAW,EAAE,IAAI,GAAE,CAAC,GAAE,KAAG,EAAE,cAAY,CAAC,GAAE,GAAE,OAAK,KAAG,EAAE,cAAY,EAAE,IAAI,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,aAAW,CAAC,GAAE,OAAK,KACnf,EAAE,aAAW,EAAE,IAAI,GAAE,CAAC,GAAE,KAAG,EAAE,cAAY,CAAC,GAAE,GAAE,OAAK,KAAG,EAAE,cAAY,EAAE,IAAI,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,eAAa,CAAC,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,eAAa,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,qBAAmB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,qBAAmB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,kBAAgB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,kBAAgB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,eAAa,CAAC,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,eAAa,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,kBAAgB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,kBAAgB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,kBAAgB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GACpf,OAAK,KAAG,EAAE,kBAAgB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,sBAAoB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,sBAAoB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,uBAAqB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,uBAAqB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,eAAa,CAAC,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,eAAa,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,mBAAiB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,mBAAiB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gBAAc,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gBAAc,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,uBACve,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,uBAAqB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,eAAa,CAAC,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,eAAa,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,2BAAyB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,2BAAyB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,iBAAe,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,iBAAe,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,oBAAkB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,oBAAkB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gBAAc,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gBACze,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,yBAAuB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,yBAAuB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,aAAW,CAAC,GAAE,OAAK,KAAG,EAAE,aAAW,EAAE,IAAI,GAAE,CAAC,GAAE,KAAG,EAAE,cAAY,CAAC,GAAE,GAAE,OAAK,KAAG,EAAE,cAAY,EAAE,IAAI,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,qBAAmB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,qBAAmB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gBAAc,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gBAAc,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,kBAAgB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,kBAAgB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,mBACtf,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,mBAAiB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gBAAc,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gBAAc,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,yBAAuB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,yBAAuB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,sBAAoB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,sBAAoB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,4BAA0B,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,4BAA0B,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GACrf,KAAG,EAAE,wBAAsB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,wBAAsB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,+BAA6B,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,+BAA6B,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,qBAAmB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,qBAAmB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,kBAAgB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,kBAAgB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,sBAAoB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GACpf,OAAK,KAAG,EAAE,sBAAoB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,iBAAe,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,iBAAe,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,kBAAgB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,kBAAgB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,iBAAe,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,iBAAe,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,yBAAuB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,yBAAuB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,6BAA2B,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,6BAC1e,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,4BAA0B,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,4BAA0B,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,2BAAyB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,2BAAyB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,0BAAwB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,0BAAwB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gCAA8B,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GACpf,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gCAA8B,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,8BAA4B,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,8BAA4B,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,6BAA2B,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,6BAA2B,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gCAA8B,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gCACjf,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,wBAAsB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,wBAAsB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,qBAAmB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,qBAAmB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,wBAAsB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,wBAAsB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,0BAAwB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,0BAAwB,EAAE;AAAA,UAAI;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UACpf;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,QAAC,GAAE,KAAG,EAAE,gBAAc,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gBAAc,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,qBAAmB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,qBAAmB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,oBAAkB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,oBAAkB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,yBAAuB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,yBAAuB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,iBAAe,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,iBAAe,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,wBAAsB,CAAC,GAAE,GAAE,GACpf,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,wBAAsB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,kBAAgB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,kBAAgB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,iBAAe,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,iBAAe,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,wBAAsB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,wBAAsB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,sBAAoB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,sBAAoB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gBAAc,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gBACnf,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,mBAAiB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,mBAAiB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,mBAAiB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,mBAAiB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,eAAa,CAAC,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,eAAa,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,qBAAmB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,qBAAmB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,oBAAkB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,oBAAkB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,oBAAkB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,oBAChf,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,qBAAmB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,qBAAmB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,iBAAe,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,iBAAe,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,uBAAqB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,uBAAqB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,mBAAiB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,mBAAiB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,yBAAuB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,yBAAuB,EAAE;AAAA,UAAI;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UACnf;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,QAAC,GAAE,KAAG,EAAE,0BAAwB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,0BAAwB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,cAAY,CAAC,GAAE,GAAE,OAAK,KAAG,EAAE,cAAY,EAAE,IAAI,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,eAAa,CAAC,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,eAAa,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,eAAa,CAAC,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,eAAa,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,eAAa,CAAC,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,eAAa,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,qBAAmB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,qBAAmB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,qCAClf,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,IAAG,IAAG,QAAM,KAAG,EAAE,qCAAmC,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,IAAG,IAAG,EAAE,GAAE,KAAG,EAAE,iBAAe,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,iBAAe,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,wBAAsB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,wBAAsB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,wBAAsB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,wBAAsB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gCAC3d,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gCAA8B,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,wBAAsB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,wBAAsB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,yBAAuB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,yBAAuB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,8BAA4B,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,8BAA4B,EAAE;AAAA,UAAI;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UACpf;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,QAAC,GAAE,KAAG,EAAE,+BAA6B,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,+BAA6B,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,2BAAyB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,2BAAyB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,4BAA0B,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,4BAA0B,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,mBAAiB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAClf,EAAE,mBAAiB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,iBAAe,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,iBAAe,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,sBAAoB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,sBAAoB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,sBAAoB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,sBAAoB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,+BAA6B,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,+BAA6B,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gBAC3e,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gBAAc,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,qBAAmB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,qBAAmB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gBAAc,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gBAAc,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gBAAc,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gBAAc,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,kBAAgB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,kBAAgB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,iBAAe,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,iBAAe,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,iBAAe,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,iBAAe,EAAE;AAAA,UAAI;AAAA,UACzf;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,UAAE;AAAA,QAAC,GAAE,KAAG,EAAE,oBAAkB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,oBAAkB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,mBAAiB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,mBAAiB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,iBAAe,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,iBAAe,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,iBAAe,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,iBAAe,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,uBAAqB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,uBAAqB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,mBAAiB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,mBACnf,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,sBAAoB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,sBAAoB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,kBAAgB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,kBAAgB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,wBAAsB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,wBAAsB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,kBAAgB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,kBAAgB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,kBAAgB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,kBAAgB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,cAC7e,CAAC,GAAE,GAAE,OAAK,KAAG,EAAE,cAAY,EAAE,IAAI,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,eAAa,CAAC,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,eAAa,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,eAAa,CAAC,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,eAAa,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,eAAa,CAAC,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,eAAa,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gBAAc,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gBAAc,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gBAAc,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gBAAc,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,iBAAe,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,iBAAe,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,uBAAqB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,uBACrf,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,wBAAsB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,wBAAsB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gBAAc,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gBAAc,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,kBAAgB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,kBAAgB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,wBAAsB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,wBAAsB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,gBAAc,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,gBAAc,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,cACze,CAAC,GAAE,GAAE,OAAK,KAAG,EAAE,cAAY,EAAE,IAAI,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,0BAAwB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,0BAAwB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,EAAE,eAAa,CAAC,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,eAAa,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,QAAI,KAAG,EAAE,IAAI,CAAC,GAAE,KAAG,OAAK,KAAG,EAAE,IAAI,GAAE,KAAG,QAAI,KAAG,EAAE,IAAI,CAAC,GAAE,KAAG,OAAK,KAAG,EAAE,IAAI;AAAE,UAAE,iBAAe;AAAQ,UAAE,gBAAc;AAAQ,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACnc,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,YAAY,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,wBAAY,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,uBAAW,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAC9c,iBAAS,GAAG,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,sBAAU,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAC/d,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAClf,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAE,mBAAO;AAAA,UAAE;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACzd,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAC3Y,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAC7c,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAC7d,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAE,mBAAO;AAAA,UAAE;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACld,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAClf,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAC1Z,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAE,mBAAO;AAAA,UAAE;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACxa,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAC3Z,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACra,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAE,mBAAO;AAAA,UAAE;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACvb,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAC3Z,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACxc,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAC7e,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACtd,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACvZ,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAC/b,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACvY,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAC3d,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAE,mBAAO;AAAA,UAAE;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAC3a,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACzc,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACna,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACta,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACtb,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAC3d,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,IAAG,IAAG,IAAG;AAAC,cAAI,KAAG,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,IAAG,IAAG,EAAE;AAAA,UAAC,SAAO,IAAG;AAAC,cAAE,EAAE;AAAE,gBAAG,OAAK,KAAG;AAAE,oBAAM;AAAG,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACze,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAC9V,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACvZ,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACvb,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACtV,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACle,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAE,mBAAO;AAAA,UAAE;AAAA,QAAC;AACna,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAC7Z,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACpZ,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACnd,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAE,mBAAO;AAAA,UAAE;AAAA,QAAC;AAC7b,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACpd,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACld,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAE,mBAAO;AAAA,UAAE;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAC7Y,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,eAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,cAAI,IAAE,EAAE;AAAE,cAAG;AAAC,mBAAO,GAAG,GAAE,GAAE,CAAC;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAE,gBAAG,MAAI,IAAE;AAAE,oBAAM;AAAE,cAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,KAAI;AAAC,cAAI,IAAE;AAAE,cAAE,OAAO,OAAO,CAAC,GAAE,CAAC;AAAE,cAAI,IAAE,OAAG,OAAG,EAAE,CAAC,MAAI;AAAE,YAAE,KAAG,EAAE,EAAE,EAAE;AAAE,YAAE,KAAG,EAAE,EAAE,EAAE;AAAE,YAAE,KAAG,EAAE,EAAE,EAAE;AAAE,YAAE,MAAI,OAAG,MAAI,EAAE,MAAI,GAAG,EAAE,EAAE;AAAE,iBAAO;AAAA,QAAC;AAAC,UAAE,YAAU,MAAI,EAAE;AAAE,UAAE,eAAa,OAAG,EAAE,CAAC;AACpf,UAAE,aAAW,OAAG,GAAG,CAAC;AAAE,UAAE,eAAa;AAAE,UAAE,eAAa,CAAC,GAAE,GAAE,MAAI,EAAE,GAAE,GAAE,GAAE,CAAC;AAAE,UAAE,kBAAgB;AAAG,YAAI;AAAG,aAAG,SAAS,KAAI;AAAC,gBAAI,GAAG;AAAE,iBAAK,KAAG;AAAA,QAAG;AAAE,iBAAS,KAAI;AAAC,cAAG,EAAE,IAAE,KAAI;AAAC,gBAAG,EAAE;AAAO,mBAAI,cAAY,OAAO,EAAE,WAAS,EAAE,SAAO,CAAC,EAAE,MAAM,IAAG,EAAE,OAAO,UAAQ;AAAC,oBAAI,IAAE,EAAE,OAAO,MAAM;AAAE,mBAAG,QAAQ,CAAC;AAAA,cAAC;AAAC,mBAAK,IAAE,GAAG;AAAQ,iBAAG,MAAM,EAAE,CAAC;AAAE,gBAAG,EAAE,IAAE,MAAI,OAAK,KAAG,MAAG,EAAE,YAAU,MAAG,KAAI;AAAC,qBAAK,IAAE,GAAG;AAAQ,mBAAG,MAAM,EAAE,CAAC;AAAE,mBAAI,GAAG,CAAC,GAAE,IAAE,GAAG;AAAQ,mBAAG,MAAM,EAAE,CAAC;AAAA,YAAC;AAAA,UAAC;AAAA,QAAC;AAAC,WAAG;AAGnb,eAAO;AAAA,MACT;AAAA,IAEA,GAAG;AACH,QAAI,OAAO,YAAY,YAAY,OAAO,WAAW;AACnD,aAAO,UAAU;AAAA,aACV,OAAO,WAAW,cAAc,OAAO,KAAK;AACnD,aAAO,CAAC,GAAG,MAAM,OAAO;AAAA;AAAA;;;AC7K1B;AAAA;AAAA;AAAA;;;ACAA;AAAA;AAAA;AAAA;;;ACAA;AAAA;AAAA,cAAAC;AAAA;AAAA,IAAaA;AAAb;AAAA;AAAO,IAAMA,QAAO;AAAA;AAAA;;;ACApB;AAAA;AAAA;AACA,QAAI,mBAAmB,MAAM;AAC3B,UAAI,aAAa,OAAO,aAAa,eAAe,SAAS,gBAAgB,SAAS,cAAc,MAAM;AAC1G,UAAI,OAAO,eAAe;AAAa,qBAAa,cAAc;AAClE,aACF,SAAS,YAAY,CAAC,GAAG;AAEzB,iBAAS,IAAG;AAAC,YAAE,UAAQ,EAAE,UAAQ,EAAE;AAAE,iBAAO;AAAA,QAAC;AAAC,iBAAS,IAAG;AAAC,YAAE,UAAQ,EAAE,UAAQ,EAAE;AAAE,iBAAO;AAAA,QAAE;AAAC,iBAAS,IAAG;AAAC,YAAE,UAAQ,EAAE,UAAQ,EAAE;AAAE,iBAAO;AAAA,QAAE;AAAC,iBAAS,IAAG;AAAC,YAAE,UAAQ,EAAE,UAAQ,EAAE;AAAE,iBAAO;AAAA,QAAE;AAAC,iBAAS,KAAI;AAAC,YAAE,UAAQ,EAAE,UAAQ,EAAE;AAAE,iBAAO;AAAA,QAAE;AAAC,YAAI,IAAE,WAAU,IAAG;AAAE,UAAE,QAAM,IAAI,QAAQ,CAAC,GAAE,MAAI;AAAC,eAAG;AAAE,cAAE;AAAA,QAAC,CAAC;AAAE;AACvS,UAAE,WAAS,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,YAAE,KAAG;AAAE,YAAE,KAAG;AAAE,YAAE,KAAG;AAAE,YAAE,KAAG;AAAE,YAAE,KAAG;AAAE,YAAE,KAAG;AAAE,YAAE,KAAG;AAAE,YAAE,KAAG;AAAE,cAAE,CAAC,GAAE,GAAE,MAAI,IAAI,MAAI;AAAC,kBAAM,IAAE,GAAE,IAAE,IAAI;AAAE,gBAAE,EAAE,GAAG,CAAC;AAAE,kBAAM,IAAE,IAAI;AAAE,kBAAI,MAAI,IAAE,GAAE,EAAE,CAAC,GAAE,IAAE,IAAE;AAAM,mBAAO,KAAG,IAAE,GAAG,IAAE;AAAA,UAAC;AAAE,cAAE,OAAG,UAAS,MAAI;AAAC,gBAAG;AAAC,kBAAG,EAAE;AAAG,sBAAM,MAAM,yBAAyB;AAAE,oBAAM,IAAE,EAAE,KAAG,EAAC,IAAG,EAAE,CAAC,GAAE,QAAO,CAAC,EAAC,GAAE,IAAE,MAAM,EAAE,GAAG,CAAC;AAAE,kBAAG,EAAE,OAAK;AAAE,sBAAM,MAAM,kBAAkB;AAAE,gBAAE,MAAM;AAAE,oBAAM,IAAE,EAAE;AAAO,kBAAG,IAAE,EAAE,QAAO;AAAC,oBAAI,IAAE,MAAM,QAAQ,IAAI,CAAC;AAAE,oBAAE,EAAE,OAAO,OAAG,CAAC;AAAE,oBAAG,IAAE,EAAE;AAAO,wBAAM,MAAM,EAAE,KAAK,IAAI,CAAC;AAAA,cAAE;AAAC,qBAAO;AAAA,YAAC,UAAC;AAAQ,gBAAE,KACzf;AAAA,YAAI;AAAA,UAAC;AAAE,YAAE,UAAQ,EAAE,EAAE,EAAE,SAAQ,MAAI,EAAE,SAAQ,OAAG,EAAE,UAAQ,CAAC,CAAC;AAAE,YAAE,qBAAmB,EAAE,EAAE,EAAE,oBAAmB,MAAI,EAAE,oBAAmB,OAAG,EAAE,qBAAmB,CAAC,CAAC;AAAE,YAAE,gBAAc,EAAE,EAAE,eAAc,MAAI,EAAE,eAAc,OAAG,EAAE,gBAAc,CAAC;AAAE,YAAE,qBAAmB,CAAC,GAAE,GAAE,GAAE,MAAI,EAAE,eAAe,GAAE,GAAE,GAAE,CAAC;AAAE,YAAE,wBAAsB,OAAG;AAAC,cAAE,kBAAkB,CAAC;AAAA,UAAC;AAAE,YAAE,gBAAc,OAAG,EAAE,UAAU,CAAC;AAAE,YAAE,uBAAqB,CAAC,GAAE,GAAE,MAAI,EAAE,iBAAiB,GAAE,GAAE,CAAC;AAAA,QAAC;AACtb,YAAI,KAAG,OAAO,OAAO,CAAC,GAAE,CAAC,GAAE,KAAG,kBAAiB,IAAE,CAAC,GAAE,MAAI;AAAC,gBAAM;AAAA,QAAE,GAAE,KAAG,YAAU,OAAO,QAAO,IAAE,cAAY,OAAO,eAAc,IAAE,YAAU,OAAO,WAAS,YAAU,OAAO,QAAQ,YAAU,YAAU,OAAO,QAAQ,SAAS,MAAK,IAAE,EAAE,0BAAwB,OAAG,IAAE;AAAG,iBAAS,GAAG,GAAE;AAAC,iBAAO,EAAE,aAAW,EAAE,WAAW,GAAE,CAAC,IAAE,IAAE;AAAA,QAAC;AAAC,YAAI,IAAG,GAAE;AAC7U,YAAG,GAAE;AAAC,cAAI,KAAG,uCAAc,KAAG;AAAgB,cAAE,IAAE,GAAG,QAAQ,CAAC,IAAE,MAAI,YAAU;AAAI,eAAG,CAAC,GAAE,MAAI;AAAC,gBAAE,EAAE,WAAW,SAAS,IAAE,IAAI,IAAI,CAAC,IAAE,GAAG,UAAU,CAAC;AAAE,mBAAO,GAAG,aAAa,GAAE,IAAE,SAAO,MAAM;AAAA,UAAC;AAAE,eAAG,OAAG;AAAC,gBAAE,GAAG,GAAE,IAAE;AAAE,cAAE,WAAS,IAAE,IAAI,WAAW,CAAC;AAAG,mBAAO;AAAA,UAAC;AAAE,cAAE,CAAC,GAAE,GAAE,GAAE,IAAE,SAAK;AAAC,gBAAE,EAAE,WAAW,SAAS,IAAE,IAAI,IAAI,CAAC,IAAE,GAAG,UAAU,CAAC;AAAE,eAAG,SAAS,GAAE,IAAE,SAAO,QAAO,CAAC,GAAE,MAAI;AAAC,kBAAE,EAAE,CAAC,IAAE,EAAE,IAAE,EAAE,SAAO,CAAC;AAAA,YAAC,CAAC;AAAA,UAAC;AAAE,WAAC,EAAE,eAAa,IAAE,QAAQ,KAAK,WAAS,KAAG,QAAQ,KAAK,CAAC,EAAE,QAAQ,OAAM,GAAG;AAAG,kBAAQ,KAAK,MAAM,CAAC;AAAE,cAAE,CAAC,GAAE,MAAI;AAAC,oBAAQ,WACtf;AAAE,kBAAM;AAAA,UAAE;AAAE,YAAE,UAAQ,MAAI;AAA6B,cAAI;AAAE,cAAG;AAAC,gBAAE;AAAA,UAAyB,SAAO,GAAE;AAAC,kBAAM,QAAQ,MAAM,yGAAyG,GAAE;AAAA,UAAE;AAAC,iBAAO,SAAO,EAAE;AAAA,QAAM,WAAS,MAAI;AAAE,cAAE,IAAE,KAAK,SAAS,OAAK,eAAa,OAAO,YAAU,SAAS,kBAAgB,IAAE,SAAS,cAAc,MAAM,OAAO,eAAe,eAAe,eAAc,IAAE,aAAY,MAAI,EAAE,QAAQ,OAAO,IAAE,IAAE,EAAE,OAAO,GAAE,EAAE,QAAQ,UAAS,EAAE,EAAE,YAAY,GAAG,IAAE,CAAC,IAAE,IAAE,IAAG,MAAI,KAAG,OAAG;AAAC,gBAAI,IAC9hB,IAAI;AAAe,cAAE,KAAK,OAAM,GAAE,KAAE;AAAE,cAAE,KAAK,IAAI;AAAE,mBAAO,EAAE;AAAA,UAAY,GAAE,MAAI,KAAG,OAAG;AAAC,gBAAI,IAAE,IAAI;AAAe,cAAE,KAAK,OAAM,GAAE,KAAE;AAAE,cAAE,eAAa;AAAc,cAAE,KAAK,IAAI;AAAE,mBAAO,IAAI,WAAW,EAAE,QAAQ;AAAA,UAAC,IAAG,IAAE,CAAC,GAAE,GAAE,MAAI;AAAC,gBAAI,IAAE,IAAI;AAAe,cAAE,KAAK,OAAM,GAAE,IAAE;AAAE,cAAE,eAAa;AAAc,cAAE,SAAO,MAAI;AAAC,qBAAK,EAAE,UAAQ,KAAG,EAAE,UAAQ,EAAE,WAAS,EAAE,EAAE,QAAQ,IAAE,EAAE;AAAA,YAAC;AAAE,cAAE,UAAQ;AAAE,cAAE,KAAK,IAAI;AAAA,UAAC;AAAG,aAAG,eAAa,OAAO,gBAAc,OAAO,cAAY,qBAAsB;AACrd,YAAI,KAAG,QAAQ,IAAI,KAAK,OAAO,GAAE,KAAG,QAAQ,MAAM,KAAK,OAAO;AAAE,cAAI,KAAG,IAAI,MAAI,GAAG,UAAU,GAAE,EAAE,KAAK,GAAG,IAAE,IAAI,GAAE,KAAG,IAAI,MAAI,GAAG,UAAU,GAAE,EAAE,KAAK,GAAG,IAAE,IAAI;AAAG,YAAI,KAAG,EAAE,SAAO,IAAG,IAAE,EAAE,YAAU;AAAG,eAAO,OAAO,GAAE,EAAE;AAAE,aAAG;AAAK,UAAE,gBAAc,KAAG,EAAE;AAAa,UAAE,SAAO,IAAE,EAAE;AAAM,YAAI;AAAE,UAAE,eAAa,IAAE,EAAE;AAAY,YAAI,gBAAc,EAAE,iBAAe;AAAG,oBAAU,OAAO,eAAa,EAAE,iCAAiC;AAAE,YAAI,GAAE,GAAE,IAAG,IAAE,OAAG,GAAE,GAAE,IAAG,IAAG,IAAG;AAC7b,iBAAS,IAAG;AAAC,cAAI,IAAE,EAAE;AAAO,YAAE,QAAM,IAAE,IAAI,UAAU,CAAC;AAAE,YAAE,SAAO,IAAI,WAAW,CAAC;AAAE,YAAE,SAAO,KAAG,IAAI,WAAW,CAAC;AAAE,YAAE,SAAO,KAAG,IAAI,WAAW,CAAC;AAAE,YAAE,UAAQ,IAAI,YAAY,CAAC;AAAE,YAAE,UAAQ,KAAG,IAAI,YAAY,CAAC;AAAE,YAAE,UAAQ,IAAI,aAAa,CAAC;AAAE,YAAE,UAAQ,KAAG,IAAI,aAAa,CAAC;AAAA,QAAC;AAAC,YAAI,KAAG,EAAE,kBAAgB;AAAS,mBAAS,MAAI,EAAE,0DAAwD,KAAG,wBAAwB;AAC9Y,YAAG;AAAE,cAAE,EAAE;AAAA,iBAAmB,EAAE;AAAW,cAAE,EAAE;AAAA,iBAAmB,IAAE,IAAI,YAAY,OAAO,EAAC,SAAQ,KAAG,OAAM,SAAQ,OAAM,QAAO,KAAE,CAAC,GAAE,EAAE,EAAE,kBAAkB;AAAmB,gBAAM,EAAE,6NAA6N,GAAE,KAAG,EAAE,2GAA2G,GACrgB,MAAM,YAAY;AAAE,UAAE;AAAE,aAAG,EAAE,OAAO;AAAW,YAAI,KAAG,CAAC,GAAE,KAAG,CAAC,GAAE,KAAG,CAAC,GAAE,KAAG;AAAE,iBAAS,KAAI;AAAC,iBAAO,iBAAe,IAAE;AAAA,QAAE;AAAC,YAAI,IAAE,GAAE,KAAG,MAAK,IAAE;AAAK,iBAAS,KAAI;AAAC;AAAI,YAAE,0BAAwB,EAAE,uBAAuB,CAAC;AAAA,QAAC;AAAC,iBAAS,KAAI;AAAC;AAAI,YAAE,0BAAwB,EAAE,uBAAuB,CAAC;AAAE,cAAG,KAAG,MAAI,SAAO,OAAK,cAAc,EAAE,GAAE,KAAG,OAAM,IAAG;AAAC,gBAAI,IAAE;AAAE,gBAAE;AAAK,cAAE;AAAA,UAAC;AAAA,QAAC;AAClW,iBAAS,EAAE,GAAE;AAAC,cAAG,EAAE;AAAQ,cAAE,QAAQ,CAAC;AAAE,cAAE,aAAW,IAAE;AAAI,YAAE,CAAC;AAAE,cAAE;AAAG,cAAE;AAAE,cAAE,IAAI,YAAY,aAAa,IAAE,0CAA0C;AAAE,YAAE,CAAC;AAAE,gBAAM;AAAA,QAAE;AAAC,iBAAS,GAAG,GAAE;AAAC,iBAAO,EAAE,WAAW,uCAAuC;AAAA,QAAC;AAAC,YAAI;AAAE,YAAE;AAA8B,WAAG,CAAC,MAAI,IAAE,GAAG,CAAC;AAAG,iBAAS,GAAG,GAAE;AAAC,cAAG,KAAG,KAAG;AAAE,mBAAO,IAAI,WAAW,CAAC;AAAE,cAAG;AAAG,mBAAO,GAAG,CAAC;AAAE,gBAAK;AAAA,QAAkD;AACpa,iBAAS,GAAG,GAAE;AAAC,cAAG,CAAC,MAAI,MAAI,IAAG;AAAC,gBAAG,cAAY,OAAO,SAAO,CAAC,EAAE,WAAW,SAAS;AAAE,qBAAO,MAAM,GAAE,EAAC,aAAY,cAAa,CAAC,EAAE,KAAK,OAAG;AAAC,oBAAG,CAAC,EAAE;AAAG,wBAAK,yCAAuC,IAAE;AAAI,uBAAO,EAAE,YAAY;AAAA,cAAC,CAAC,EAAE,MAAM,MAAI,GAAG,CAAC,CAAC;AAAE,gBAAG;AAAE,qBAAO,IAAI,QAAQ,CAAC,GAAE,MAAI;AAAC,kBAAE,GAAE,OAAG,EAAE,IAAI,WAAW,CAAC,CAAC,GAAE,CAAC;AAAA,cAAC,CAAC;AAAA,UAAC;AAAC,iBAAO,QAAQ,QAAQ,EAAE,KAAK,MAAI,GAAG,CAAC,CAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,iBAAO,GAAG,CAAC,EAAE,KAAK,OAAG,YAAY,YAAY,GAAE,CAAC,CAAC,EAAE,KAAK,OAAG,CAAC,EAAE,KAAK,GAAE,OAAG;AAAC,cAAE,4CAA0C,CAAC;AAAE,cAAE,CAAC;AAAA,UAAC,CAAC;AAAA,QAAC;AAC1e,iBAAS,GAAG,GAAE,GAAE;AAAC,cAAI,IAAE;AAAE,iBAAO,KAAG,cAAY,OAAO,YAAY,wBAAsB,GAAG,CAAC,KAAG,EAAE,WAAW,SAAS,KAAG,KAAG,cAAY,OAAO,QAAM,GAAG,GAAE,GAAE,CAAC,IAAE,MAAM,GAAE,EAAC,aAAY,cAAa,CAAC,EAAE,KAAK,OAAG,YAAY,qBAAqB,GAAE,CAAC,EAAE,KAAK,GAAE,SAAS,GAAE;AAAC,cAAE,oCAAkC,CAAC;AAAE,cAAE,2CAA2C;AAAE,mBAAO,GAAG,GAAE,GAAE,CAAC;AAAA,UAAC,CAAC,CAAC;AAAA,QAAC;AAC7W,YAAI,GAAE,KAAG;AAAA,UAAC,QAAO,OAAG;AAAC,cAAE,GAAG,OAAM,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,OAAM,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,SAAQ,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,QAAO,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,cAAa,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,QAAO,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,OAAM,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,OAAM,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,WAAU,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,OAAM,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,OAAM,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,OAAM,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,OAAM,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,QAAO,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE;AAAA,cAAG;AAAA,cACxf;AAAA,cAAE;AAAA,YAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,QAAO,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,QAAO,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,QAAO,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,SAAQ,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,SAAQ,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,SAAQ,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,QAAO,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,OAAM,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,WAAU,GAAE,EAAC,KAAI,GAAE,KAAI,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,QAAO,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,MAAI;AAAC,cAAE,GAAG,OAAM,GAAE,EAAC,OAAM,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,QAAO,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,MAAI;AAAC,cAAE,GAAG,aAAY,GAAE,EAAC,OAAM,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,MACnf;AAAC,cAAE,GAAG,mBAAkB,GAAE,EAAC,OAAM,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,MAAI;AAAC,cAAE,GAAG,QAAO,GAAE,EAAC,IAAG,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,OAAM,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,OAAM,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,OAAM,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,OAAM,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,OAAM,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,SAAQ,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,WAAU,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,kBAAiB,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,QAAO,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,eAAc,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,cAAa,GAAE;AAAA,cAAC,UAAS,CAAC,CAAC;AAAA,cAAE,mBAAkB,CAAC,CAAC;AAAA,cAC3f,MAAK,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC;AAAA,YAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,aAAY,GAAE,EAAC,UAAS,CAAC,CAAC,GAAE,mBAAkB,CAAC,CAAC,GAAE,MAAK,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,aAAY,GAAE,EAAC,UAAS,CAAC,CAAC,GAAE,mBAAkB,CAAC,CAAC,GAAE,MAAK,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,cAAa,GAAE,EAAC,UAAS,CAAC,CAAC,GAAE,mBAAkB,CAAC,CAAC,GAAE,MAAK,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,aAAY,GAAE;AAAA,cAAC,UAAS,CAAC,CAAC;AAAA,cAAE,mBAAkB,CAAC,CAAC;AAAA,cACngB,MAAK,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC;AAAA,YAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,YAAW,GAAE,EAAC,UAAS,CAAC,CAAC,GAAE,mBAAkB,CAAC,CAAC,GAAE,MAAK,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,YAAW,GAAE,EAAC,UAAS,CAAC,CAAC,GAAE,mBAAkB,CAAC,CAAC,GAAE,MAAK,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,gBAAe,GAAE,EAAC,UAAS,CAAC,CAAC,GAAE,mBAAkB,CAAC,CAAC,GAAE,MAAK,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,mBAAkB,GAAE;AAAA,cAAC,UAAS,CAAC,CAAC;AAAA,cACnf,mBAAkB,CAAC,CAAC;AAAA,cAAE,MAAK,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC;AAAA,YAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,mBAAkB,GAAE,EAAC,UAAS,CAAC,CAAC,GAAE,mBAAkB,CAAC,CAAC,GAAE,MAAK,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,SAAQ,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,aAAY,GAAE,EAAC,MAAK,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,QAAO,GAAE,EAAC,QAAO,IAAE,SAAO,QAAO,UAAS,GAAE,WAAU,CAAC,CAAC,GAAE,OAAM,GAAE,cAAa,CAAC,CAAC,GAAE,MAAK,CAAC,GAAE,CAAC,GAAE,SAAQ,CAAC,CAAC,GAAE,YAAW,MAAI,CAAC,CAAC,EAAE,EAAE,MAClf,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,QAAO,GAAE,EAAC,QAAO,IAAE,SAAO,QAAO,UAAS,GAAE,WAAU,CAAC,GAAE,CAAC,GAAE,OAAM,GAAE,cAAa,CAAC,GAAE,CAAC,GAAE,MAAK,CAAC,GAAE,GAAE,GAAE,CAAC,GAAE,SAAQ,CAAC,GAAE,CAAC,GAAE,YAAW,MAAI,CAAC,CAAC,EAAE,EAAE,MAAI,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,QAAO,GAAE,EAAC,QAAO,IAAE,SAAO,QAAO,UAAS,GAAE,WAAU,CAAC,CAAC,GAAE,OAAM,GAAE,cAAa,CAAC,CAAC,GAAE,MAAK,CAAC,GAAE,CAAC,GAAE,SAAQ,CAAC,CAAC,GAAE,YAAW,MAAI,CAAC,CAAC,EAAE,EAAE,MAAI,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,QAAO,GAAE,EAAC,QAAO,IAAE,SAAO,QAAO,UAAS,GAAE,WAAU,CAAC,GAAE,CAAC,GAAE,OAAM,GAAE,cAAa;AAAA,cAAC;AAAA,cACpf;AAAA,YAAC,GAAE,MAAK,CAAC,GAAE,GAAE,GAAE,CAAC,GAAE,SAAQ,CAAC,GAAE,CAAC,GAAE,YAAW,MAAI,CAAC,CAAC,EAAE,EAAE,MAAI,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,iBAAgB,GAAE,EAAC,QAAO,IAAE,SAAO,QAAO,SAAQ,GAAE,WAAU,CAAC,CAAC,GAAE,OAAM,GAAE,cAAa,CAAC,CAAC,GAAE,MAAK,CAAC,GAAE,CAAC,GAAE,SAAQ,CAAC,CAAC,GAAE,UAAS,MAAI,CAAC,CAAC,EAAE,EAAE,MAAI,CAAC,GAAE,eAAc,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,GAAE,aAAY,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,iBAAgB,GAAE,EAAC,QAAO,IAAE,SAAO,QAAO,SAAQ,GAAE,WAAU,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IACpf,MAAI,CAAC,CAAC,GAAE,OAAM,GAAE,aAAY,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,GAAE,MAAK,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,GAAE,SAAQ,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,GAAE,UAAS,MAAI,CAAC,CAAC,EAAE,EAAE,MAAI,CAAC,GAAE,eAAc,IAAE,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,GAAE,aAAY,IAAE,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,iBAAgB,GAAE,EAAC,QAAO,IAAE,SAAO,QAAO,SAAQ,GAAE,WAAU,CAAC,CAAC,GAAE,OAAM,GAAE,cAAa,CAAC,CAAC,GAAE,MAAK,CAAC,GAAE,CAAC,GAAE,SAAQ,CAAC,CAAC,GAAE,UAAS,MAAI,CAAC,CAAC,EAAE,EAAE,MAAI,CAAC,GAAE,eAAc,IAC5f,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,GAAE,aAAY,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,iBAAgB,GAAE,EAAC,QAAO,IAAE,SAAO,QAAO,SAAQ,GAAE,WAAU,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,GAAE,OAAM,GAAE,aAAY,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,GAAE,MAAK,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,GAAE,SAAQ,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,GAAE,UAAS,MAAI,CAAC,CAAC,EAAE,EAAE,MAAI,CAAC,GAAE,eAAc,IAAE,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,GAAE,aAAY,IACnf,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,MAAI;AAAC,cAAE,GAAG,qBAAoB,GAAE,EAAC,QAAO,IAAE,SAAO,OAAM,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,eAAc,GAAE,EAAC,QAAO,IAAE,SAAO,QAAO,UAAS,GAAE,WAAU,GAAE,mBAAkB,GAAE,eAAc,GAAE,WAAU,CAAC,GAAE,CAAC,GAAE,cAAa,CAAC,GAAE,CAAC,GAAE,MAAK,CAAC,GAAE,GAAE,GAAE,CAAC,GAAE,SAAQ,CAAC,GAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,MAAI;AAAC,cAAE,GAAG,qBAAoB,GAAE,EAAC,QAAO,IAAE,SAAO,OAAM,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,eAAc,GAAE;AAAA,cAAC,QAAO,IAAE,SAAO;AAAA,cAAO,UAAS;AAAA,cAAE,WAAU;AAAA,cAC7f,mBAAkB;AAAA,cAAE,eAAc;AAAA,cAAE,WAAU,CAAC,GAAE,CAAC;AAAA,cAAE,cAAa,CAAC,GAAE,CAAC;AAAA,cAAE,MAAK,CAAC,GAAE,GAAE,GAAE,CAAC;AAAA,cAAE,SAAQ,CAAC,GAAE,CAAC;AAAA,YAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,MAAI;AAAC,cAAE,GAAG,iBAAgB,GAAE,EAAC,QAAO,IAAE,SAAO,OAAM,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,WAAU,GAAE,EAAC,QAAO,IAAE,SAAO,QAAO,UAAS,GAAE,WAAU,GAAE,mBAAkB,GAAE,eAAc,GAAE,WAAU,CAAC,GAAE,CAAC,GAAE,cAAa,CAAC,GAAE,CAAC,GAAE,MAAK,CAAC,GAAE,GAAE,GAAE,CAAC,GAAE,SAAQ,CAAC,GAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,MAAI;AAAC,cAAE,GAAG,iBAAgB,GAAE,EAAC,QAAO,IAAE,SAAO,OAAM,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE;AAAA,cAAG;AAAA,cAC3e;AAAA,cAAE,EAAC,QAAO,IAAE,SAAO,QAAO,UAAS,GAAE,WAAU,GAAE,mBAAkB,GAAE,eAAc,GAAE,WAAU,CAAC,GAAE,CAAC,GAAE,cAAa,CAAC,GAAE,CAAC,GAAE,MAAK,CAAC,GAAE,GAAE,GAAE,CAAC,GAAE,SAAQ,CAAC,GAAE,CAAC,EAAC;AAAA,YAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,QAAO,GAAE,EAAC,OAAM,GAAE,MAAK,GAAE,QAAO,GAAE,QAAO,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,UAAS,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,UAAS,GAAE,EAAC,UAAS,CAAC,CAAC,GAAE,iBAAgB,CAAC,CAAC,GAAE,MAAK,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,UAAS,GAAE,EAAC,UAAS,CAAC,CAAC,GAAE,iBAAgB,CAAC,CAAC,GAAE,MAAK,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,MAAI;AAAC,cAAE,GAAG,WAAU,GAAE,EAAC,MAAK,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,MAAI;AAAC,cAAE,GAAG,UAAS,GAAE,EAAC,MAAK,EAAC,CAAC;AAAA,UAAC;AAAA,UACrf,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,SAAQ,GAAE,EAAC,MAAK,GAAE,YAAW,GAAE,YAAW,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,UAAS,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,MAAI;AAAC,cAAE,GAAG,UAAS,GAAE,EAAC,MAAK,OAAO,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,MAAI;AAAC,cAAE,GAAG,kBAAiB,GAAE,EAAC,MAAK,OAAO,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,UAAS,GAAE,EAAC,WAAU,GAAE,MAAK,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,GAAE,yBAAwB,EAAE,CAAC,GAAE,aAAY,GAAE,gBAAe,GAAE,oBAAmB,GAAE,uBAAsB,EAAE,CAAC,GAAE,MAAK,EAAE,CAAC,GAAE,aAAY,EAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAC5f,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,SAAQ,GAAE,EAAC,QAAO,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,GAAE,MAAK,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,GAAE,MAAK,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,QAAO,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,sBAAqB,GAAE,EAAC,MAAK,OAAO,CAAC,GAAE,SAAQ,OAAO,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,yBAAwB,GAAE,EAAC,SAAQ,GAAE,QAAO,IAAE,SAAO,OAAM,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,yBAAwB,GAAE,EAAC,SAAQ,GAAE,QAAO,IAAE,SAAO,OAAM,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE;AAAA,cAAG;AAAA,cAClf;AAAA,cAAE;AAAA,YAAM;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,MAAI;AAAC,cAAE,GAAG,UAAS,GAAE,EAAC,UAAS,EAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,OAAM,GAAE,EAAC,MAAK,GAAE,OAAM,GAAE,MAAK,IAAE,MAAM,KAAK,EAAE,EAAE,SAAS,MAAI,GAAE,IAAE,MAAI,CAAC,CAAC,IAAE,CAAC,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,QAAO,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,WAAU,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,iBAAgB,GAAE,MAAM;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,MAAI;AAAC,cAAE,GAAG,0BAAyB,GAAE,EAAC,SAAQ,EAAC,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,OAAG;AAAC,cAAE,GAAG,CAAC;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,MAAI,EAAE,GAAG,GAAE,GAAE,EAAE,GAAG,IAAG,EAAE,GAAG,MAAM;AAAA,UAAE,QAAO,OAAG,EAAE,GAAG,CAAC;AAAA,UAAE,QAAO,OAAG,EAAE,GAAG,CAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,GAAE,GAAE,GAAE,IAAE;AAAA,UAAC;AAAA,UAAE,QAAO,CAAC,GAAE,GAAE,MAAI;AAAC,cAAE,GAAG,GAAE,GAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AACpf,iBAAS,GAAG,GAAE;AAAC,eAAK,OAAK;AAAa,eAAK,UAAQ,gCAAgC,CAAC;AAAI,eAAK,SAAO;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE;AAAC,YAAE,UAAU;AAAE,YAAE,YAAU,MAAI;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE;AAAC,WAAC,IAAE,EAAE,GAAG,CAAC,MAAI,EAAE;AAAE,YAAE,GAAG,CAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE;AAAC,cAAI,IAAE,EAAE,GAAG;AAAE,cAAG,CAAC;AAAE,mBAAO;AAAE,YAAE,GAAG,KAAK,CAAC;AAAE,YAAE,GAAG,EAAE,EAAE,IAAE;AAAE,YAAE,KAAG,EAAE;AAAG,cAAI,IAAE,EAAC,KAAI,OAAM,eAAc,EAAE,IAAG,KAAI,EAAE,IAAG,aAAY,EAAE,GAAE;AAAE,eAAG,EAAE,MAAM;AAAE,YAAE,YAAY,GAAE,EAAE,EAAE;AAAE,iBAAO;AAAA,QAAC;AACvX,YAAI,KAAG,eAAa,OAAO,cAAY,IAAI,YAAY,MAAM,IAAE,QAAO,KAAG,CAAC,GAAE,GAAE,MAAI;AAAC,iBAAK;AAAE,cAAI,IAAE,IAAE;AAAE,eAAI,IAAE,GAAE,EAAE,CAAC,KAAG,EAAE,KAAG;AAAI,cAAE;AAAE,cAAG,KAAG,IAAE,KAAG,EAAE,UAAQ;AAAG,mBAAO,GAAG,OAAO,EAAE,kBAAkB,oBAAkB,EAAE,MAAM,GAAE,CAAC,IAAE,EAAE,SAAS,GAAE,CAAC,CAAC;AAAE,eAAI,IAAE,IAAG,IAAE,KAAG;AAAC,gBAAI,IAAE,EAAE,GAAG;AAAE,gBAAG,IAAE,KAAI;AAAC,kBAAI,IAAE,EAAE,GAAG,IAAE;AAAG,kBAAG,QAAM,IAAE;AAAK,qBAAG,OAAO,cAAc,IAAE,OAAK,IAAE,CAAC;AAAA,mBAAM;AAAC,oBAAI,IAAE,EAAE,GAAG,IAAE;AAAG,oBAAE,QAAM,IAAE,QAAM,IAAE,OAAK,KAAG,KAAG,IAAE,KAAG,IAAE,MAAI,KAAG,KAAG,KAAG,KAAG,IAAE,EAAE,GAAG,IAAE;AAAG,wBAAM,IAAE,KAAG,OAAO,aAAa,CAAC,KAAG,KAAG,OAAM,KAAG,OAAO,aAAa,QAAM,KACpf,IAAG,QAAM,IAAE,IAAI;AAAA,cAAE;AAAA,YAAC;AAAM,mBAAG,OAAO,aAAa,CAAC;AAAA,UAAC;AAAC,iBAAO;AAAA,QAAC,GAAE,IAAE,CAAC,GAAE,OAAK,OAAK,KAAG,GAAG,EAAE,GAAE,GAAE,CAAC,IAAE;AAAG,iBAAS,GAAG,GAAE;AAAC,cAAG;AAAE,mBAAO,EAAE,GAAE,GAAE,CAAC;AAAE,cAAE;AAAE,cAAG,CAAC,GAAG,GAAE;AAAC,cAAE,GAAG;AAAE,gBAAG,EAAE;AAAO,gBAAE,OAAO,CAAC;AAAE,gBAAE;AAAA,UAAE;AAAC,YAAE,GAAE,IAAI,GAAG,CAAC,CAAC;AAAA,QAAC;AACjM,YAAI,KAAG,OAAG;AAAC,cAAE;AAAE,cAAG;AAAE,kBAAM,GAAG,CAAC,GAAE;AAAS,aAAG,CAAC;AAAA,QAAC,GAAE,IAAE;AAAA,UAAC,IAAG,CAAC;AAAA,UAAE,IAAG,CAAC;AAAA,UAAE,IAAG,CAAC;AAAA,UAAE,IAAG,CAAC;AAAA,UAAE,IAAG,WAAU;AAAC,gBAAE,EAAE,GAAG,IAAE,EAAE,GAAG;AAAA,UAAC;AAAA,UAAE,IAAG,WAAU;AAAC,eAAG,QAAQ,MAAI;AAAC,iBAAG;AAAE,gBAAE,GAAG,MAAI,GAAG,CAAC;AAAA,YAAC,CAAC;AAAA,UAAC;AAAA,UAAE,IAAG,WAAU;AAAC,cAAE,wBAAsB,EAAE;AAAG,cAAE,gBAAc,EAAE;AAAG,cAAE,gBAAc,EAAE;AAAG,4BAAc;AAAA,UAAE;AAAA,UAAE,IAAG,SAAS,GAAE;AAAC,gBAAE;AAAA,UAAC;AAAA,UAAE,IAAG,CAAC,kBAAkB;AAAA,UAAE,IAAG,WAAU;AAAC,qBAAQ,KAAK,EAAE;AAAG,iBAAG,CAAC;AAAE,iBAAI,KAAK,EAAE;AAAG,iBAAG,CAAC;AAAE,cAAE,KAAG,CAAC;AAAE,cAAE,KAAG,CAAC;AAAE,cAAE,KAAG,CAAC;AAAA,UAAC;AAAA,UAAE,IAAG,SAAS,GAAE;AAAC,gBAAI,IAAE,EAAE;AAAG,mBAAO,EAAE,GAAG,CAAC;AAAE,cAAE,GAAG,KAAK,CAAC;AAAE,cAAE,GAAG,OAAO,EAAE,GAAG,QAAQ,CAAC,GAAE,CAAC;AAAE,cAAE,KAAG;AAAE,eAAG,CAAC;AAAA,UAAC;AAAA,UAAE,IAAG,WAAU;AAAA,UAAC;AAAA,UACtf,IAAG,WAAU;AAAC,cAAE,GAAG,QAAQ,OAAG,EAAE,CAAC;AAAA,UAAC;AAAA,UAAE,IAAG,OAAG,IAAI,QAAQ,OAAG;AAAC,cAAE,YAAU,OAAG;AAAC,kBAAE,EAAE;AAAK,kBAAI,IAAE,EAAE;AAAI,kBAAG,EAAE,gBAAc,EAAE,gBAAc,GAAG,GAAE;AAAC,oBAAI,IAAE,EAAE,GAAG,EAAE,EAAE;AAAE,oBAAE,EAAE,YAAY,GAAE,EAAE,YAAY,IAAE,EAAE,4CAA0C,IAAE,yBAAuB,EAAE,eAAa,qCAAqC;AAAA,cAAC,WAAS,mBAAiB;AAAE,mBAAG;AAAA,uBAAU,kBAAgB;AAAE,mBAAG,CAAC;AAAA,uBAAU,oBAAkB;AAAE,mBAAG,EAAE,MAAM;AAAA,uBAAU,iBAAe;AAAE,oBAAE,EAAE,QAAO,IAAE,EAAE,GAAG,CAAC,GAAE,OAAO,EAAE,GAAG,CAAC,GAAE,GAAG,CAAC,GAAE,GAAG,CAAC,GAAE,EAAE,GAAG;AAAA,kBAAO,EAAE,GAAG,QAAQ,CAAC;AAAA,kBAClgB;AAAA,gBAAC,GAAE,EAAE,KAAG;AAAA,uBAAU,mBAAiB;AAAE,kBAAE,GAAG,EAAE,MAAM,EAAE,YAAY,EAAC,KAAI,SAAQ,CAAC;AAAA,uBAAU,aAAW;AAAE,kBAAE,SAAO,MAAG,EAAE,CAAC;AAAA,uBAAU,YAAU;AAAE,sBAAM,YAAU,EAAE,WAAS,OAAK,EAAE,IAAI;AAAA,uBAAU,mBAAiB,EAAE;AAAO,kBAAE,YAAY,CAAC;AAAA,uBAAU,kBAAgB;AAAE,kBAAE,EAAE,OAAO,EAAE,GAAG,EAAE,IAAI;AAAA;AAAO,qBAAG,EAAE,oCAAkC,CAAC;AAAA,YAAC;AAAE,cAAE,UAAQ,OAAG;AAAC,gBAAE,2BAAyB,EAAE,WAAS,MAAI,EAAE,SAAO,OAAK,EAAE,OAAO;AAAE,oBAAM;AAAA,YAAE;AAAE,kBAAI,EAAE,GAAG,WAAU,SAAS,GAAE;AAAC,gBAAE,UAAU,EAAC,MAAK,EAAC,CAAC;AAAA,YAAC,CAAC,GAAE,EAAE,GAAG,SAAQ,SAAS,GAAE;AAAC,gBAAE,QAAQ,CAAC;AAAA,YAAC,CAAC;AAC/f,gBAAI,IAAE,CAAC,GAAE,IAAE,CAAC,UAAS,WAAU,SAAQ,UAAU,GAAE;AAAE,iBAAI,KAAK;AAAE,gBAAE,eAAe,CAAC,KAAG,EAAE,KAAK,CAAC;AAAE,cAAE,YAAY,EAAC,KAAI,QAAO,UAAS,GAAE,WAAU,EAAE,uBAAqB,YAAW,YAAW,GAAE,YAAW,GAAE,CAAC;AAAA,UAAC,CAAC;AAAA,UAAE,IAAG,SAAS,GAAE;AAAC,cAAE;AAAA,UAAC;AAAA,UAAE,IAAG,WAAU;AAAC,gBAAI,IAAE,GAAG,kCAAkC;AAAE,gBAAE,IAAI,OAAO,CAAC;AAAE,cAAE,GAAG,KAAK,CAAC;AAAA,UAAC;AAAA,UAAE,IAAG,WAAU;AAAC,iBAAG,EAAE,GAAG,WAAS,EAAE,GAAG,GAAE,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAAG,mBAAO,EAAE,GAAG,IAAI;AAAA,UAAC;AAAA,QAAC;AAAE,UAAE,UAAQ;AAAE,YAAI,KAAG,OAAG;AAAC,iBAAK,IAAE,EAAE;AAAQ,cAAE,MAAM,EAAE,CAAC;AAAA,QAAC;AACzb,UAAE,sBAAoB,WAAU;AAAC,cAAI,IAAE,GAAG,GAAE,IAAE,EAAE,EAAE,IAAE,MAAI,MAAI,CAAC;AAAE,cAAE,EAAE,EAAE,IAAE,MAAI,MAAI,CAAC;AAAE,aAAG,GAAE,IAAE,CAAC;AAAE,aAAG,CAAC;AAAA,QAAC;AAAE,iBAAS,GAAG,GAAE;AAAC,cAAG;AAAE,mBAAO,EAAE,GAAE,GAAE,CAAC;AAAE,aAAG,CAAC;AAAA,QAAC;AAAC,UAAE,mBAAiB,SAAS,GAAE,GAAE;AAAC,cAAE,GAAG,MAAM,MAAK,CAAC,GAAE,CAAC,CAAC;AAAE,aAAG,IAAE,EAAE,GAAG,CAAC,IAAE,GAAG,CAAC;AAAA,QAAC;AAAE,iBAAS,GAAG,GAAE;AAAC,eAAK,KAAG,IAAE;AAAG,eAAK,KAAG,SAAS,GAAE;AAAC,cAAE,EAAE,KAAK,KAAG,KAAG,MAAI,CAAC,IAAE;AAAA,UAAC;AAAE,eAAK,KAAG,SAAS,GAAE;AAAC,cAAE,EAAE,KAAK,KAAG,KAAG,MAAI,CAAC,IAAE;AAAA,UAAC;AAAE,eAAK,KAAG,SAAS,GAAE,GAAE;AAAC,iBAAK,GAAG;AAAE,iBAAK,GAAG,CAAC;AAAE,iBAAK,GAAG,CAAC;AAAA,UAAC;AAAE,eAAK,KAAG,WAAU;AAAC,cAAE,EAAE,KAAK,KAAG,MAAI,MAAI,CAAC,IAAE;AAAA,UAAC;AAAA,QAAC;AAAC,YAAI,KAAG,GAAE,KAAG;AAC/b,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,iBAAO,IAAE,EAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,IAAE,GAAG,GAAE,GAAE,GAAE,CAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,iBAAK;AAAE,iBAAK;AAAE,iBAAK;AAAE,iBAAK;AAAE,cAAG,eAAa,OAAO;AAAkB,mBAAO,EAAE,qFAAqF,GAAE;AAAE,cAAI,IAAE,CAAC;AAAE,cAAG,KAAG,MAAI,EAAE;AAAO,mBAAO,GAAG,GAAE,GAAE,GAAE,CAAC;AAAE,cAAE,EAAC,IAAG,GAAE,IAAG,GAAE,IAAG,GAAE,IAAG,EAAC;AAAE,iBAAO,KAAG,EAAE,KAAG,eAAc,YAAY,GAAE,CAAC,GAAE,KAAG,GAAG,CAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,iBAAO,IAAE,EAAE,GAAE,GAAE,GAAE,GAAE,CAAC,IAAE;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE;AAAC,cAAG;AAAE,mBAAO,EAAE,GAAE,GAAE,GAAE,CAAC;AAAA,QAAC;AACrc,YAAI,KAAG,OAAG;AAAC,mBAAQ,IAAE,GAAE,IAAE,GAAE,IAAE,EAAE,QAAO,EAAE,GAAE;AAAC,gBAAI,IAAE,EAAE,WAAW,CAAC;AAAE,mBAAK,IAAE,MAAI,QAAM,IAAE,KAAG,IAAE,SAAO,KAAG,SAAO,KAAG,KAAG,GAAE,EAAE,KAAG,KAAG;AAAA,UAAC;AAAC,iBAAO;AAAA,QAAC,GAAE,KAAG,CAAC,GAAE,GAAE,GAAE,MAAI;AAAC,iBAAK;AAAE,cAAG,EAAE,IAAE;AAAG,mBAAO;AAAE,cAAI,IAAE;AAAE,cAAE,IAAE,IAAE;AAAE,mBAAQ,IAAE,GAAE,IAAE,EAAE,QAAO,EAAE,GAAE;AAAC,gBAAI,IAAE,EAAE,WAAW,CAAC;AAAE,gBAAG,SAAO,KAAG,SAAO,GAAE;AAAC,kBAAI,IAAE,EAAE,WAAW,EAAE,CAAC;AAAE,kBAAE,UAAQ,IAAE,SAAO,MAAI,IAAE;AAAA,YAAI;AAAC,gBAAG,OAAK,GAAE;AAAC,kBAAG,KAAG;AAAE;AAAM,gBAAE,QAAM,CAAC,IAAE;AAAA,YAAC,OAAK;AAAC,kBAAG,QAAM,GAAE;AAAC,oBAAG,IAAE,KAAG;AAAE;AAAM,kBAAE,QAAM,CAAC,IAAE,MAAI,KAAG;AAAA,cAAC,OAAK;AAAC,oBAAG,SAAO,GAAE;AAAC,sBAAG,IAAE,KAAG;AAAE;AAAM,oBAAE,QAAM,CAAC,IAAE,MAAI,KAAG;AAAA,gBAAE,OAAK;AAAC,sBAAG,IAAE,KAAG;AAAE;AAAM,oBAAE,QAAM,CAAC,IAAE,MAAI,KACpf;AAAG,oBAAE,QAAM,CAAC,IAAE,MAAI,KAAG,KAAG;AAAA,gBAAE;AAAC,kBAAE,QAAM,CAAC,IAAE,MAAI,KAAG,IAAE;AAAA,cAAE;AAAC,gBAAE,QAAM,CAAC,IAAE,MAAI,IAAE;AAAA,YAAE;AAAA,UAAC;AAAC,YAAE,MAAI,CAAC,IAAE;AAAE,iBAAO,IAAE;AAAA,QAAC,GAAE,KAAG,CAAC,GAAE,GAAE,MAAI,GAAG,GAAE,EAAE,GAAE,GAAE,CAAC;AAAE,iBAAS,GAAG,GAAE,GAAE;AAAC,cAAG;AAAE,mBAAO,EAAE,GAAE,GAAE,GAAE,CAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,cAAG;AAAE,mBAAO,EAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,iBAAO,IAAE,EAAE,GAAE,GAAE,GAAE,GAAE,CAAC,IAAE;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE;AAAC,cAAG;AAAE,mBAAO,EAAE,GAAE,GAAE,GAAE,CAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,cAAG;AAAE,mBAAO,EAAE,IAAG,GAAE,GAAE,GAAE,CAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAG;AAAE,mBAAO,EAAE,IAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAG;AAAE,mBAAO,EAAE,IAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAG;AAAE,mBAAO,EAAE,IAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,QAAC;AAC9d,iBAAS,GAAG,GAAE;AAAC,cAAG;AAAE,mBAAO,EAAE,IAAG,GAAE,CAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE;AAAC,cAAG;AAAE,mBAAO,EAAE,IAAG,GAAE,GAAE,CAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE;AAAC,cAAG;AAAE,mBAAO,EAAE,IAAG,GAAE,GAAE,GAAE,CAAC;AAAA,QAAC;AAAC,YAAI,KAAG,OAAG;AAAC,cAAG,CAAC;AAAE,gBAAG;AAAC,kBAAG,EAAE,GAAE,CAAC,GAAG;AAAE,oBAAG;AAAC,sBAAE,GAAG,CAAC,IAAE,GAAG,CAAC;AAAA,gBAAC,SAAO,GAAE;AAAC,+BAAa,MAAI,YAAU,KAAG,EAAE,GAAE,CAAC;AAAA,gBAAC;AAAA,YAAC,SAAO,GAAE;AAAC,2BAAa,MAAI,YAAU,KAAG,EAAE,GAAE,CAAC;AAAA,YAAC;AAAA,QAAC;AAAE,iBAAS,GAAG,GAAE;AAAC,iBAAK;AAAE,yBAAa,OAAO,QAAQ,OAAK,QAAQ,GAAG,EAAE,GAAE,KAAG,GAAE,CAAC,EAAE,MAAM,KAAK,EAAE,GAAE,KAAG,KAAI,QAAQ,MAAM,EAAE,GAAE,KAAG,GAAE,CAAC;AAAA,QAAE;AAAC,UAAE,oCAAkC;AAAG,iBAAS,KAAI;AAAC,cAAI,IAAE,GAAG;AAAE,gBAAI,GAAG,CAAC,GAAE,GAAG,MAAI,GAAG,CAAC;AAAA,QAAE;AAAC,UAAE,eAAa;AACpf,YAAI,IAAE,OAAG,MAAI,IAAE,MAAI,MAAI,IAAE,OAAK,MAAI,IAAE,MAAK,KAAG,CAAC,GAAE,IAAG,IAAG,IAAG,KAAI,KAAI,KAAI,KAAI,KAAI,KAAI,KAAI,GAAG,GAAE,KAAG,CAAC,GAAE,IAAG,IAAG,IAAG,KAAI,KAAI,KAAI,KAAI,KAAI,KAAI,KAAI,GAAG;AAAE,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,iBAAO,IAAE,EAAE,IAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,IAAE;AAAA,QAAG;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,cAAG;AAAE,mBAAO,EAAE,IAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAA,QAAC;AAAC,YAAI,KAAG,OAAG;AAAC,cAAI,IAAE,GAAG,CAAC,IAAE,GAAE,IAAE,GAAG,CAAC;AAAE,eAAG,GAAG,GAAE,GAAE,CAAC;AAAE,iBAAO;AAAA,QAAC,GAAE,KAAG,CAAC,GAAE,KAAG,CAAC,GAAE,MAAI;AAAC,aAAG,SAAO;AAAE,cAAI;AAAE,eAAI,MAAI,GAAE,IAAE,EAAE,EAAE,QAAM,CAAC;AAAG,iBAAG,OAAK,IAAE,GAAE,GAAG,KAAK,OAAK,IAAE,EAAE,EAAE,MAAI,CAAC,IAAE,GAAG,EAAE,QAAM,CAAC,CAAC,GAAE,EAAE;AAAE,iBAAO;AAAA,QAAE,GAAE,KAAG,OAAG;AAAC,cAAI,IAAE,GAAG;AAAE,cAAE,EAAE;AAAE,aAAG,CAAC;AAAE,iBAAO;AAAA,QAAC;AACve,iBAAS,EAAE,GAAE,GAAE;AAAC,cAAI,IAAE,UAAU,SAAO,GAAE,IAAE;AAAU,iBAAO,GAAG,MAAI;AAAC,qBAAQ,IAAE,GAAG,IAAE,CAAC,GAAE,IAAE,KAAG,GAAE,IAAE,GAAE,IAAE,GAAE,KAAI;AAAC,kBAAI,IAAE,EAAE,IAAE,CAAC;AAAE,iBAAG,EAAE,IAAE,MAAI,CAAC,IAAE;AAAA,YAAC;AAAC,mBAAO,GAAG,GAAE,GAAE,GAAE,CAAC;AAAA,UAAC,CAAC;AAAA,QAAC;AAC3J,YAAI,KAAG,CAAC,GAAE,KAAG,CAAC,GAAE,KAAG,MAAI;AAAC,cAAG,CAAC,IAAG;AAAC,gBAAI,IAAE,EAAC,MAAK,YAAW,SAAQ,YAAW,MAAK,KAAI,KAAI,KAAI,MAAK,kBAAiB,OAAM,YAAU,OAAO,aAAW,UAAU,aAAW,UAAU,UAAU,CAAC,KAAG,KAAK,QAAQ,KAAI,GAAG,IAAE,UAAS,GAAE,MAAI,iBAAgB,GAAE;AAAE,iBAAI,KAAK;AAAG,yBAAS,GAAG,CAAC,IAAE,OAAO,EAAE,CAAC,IAAE,EAAE,CAAC,IAAE,GAAG,CAAC;AAAE,gBAAI,IAAE,CAAC;AAAE,iBAAI,KAAK;AAAE,gBAAE,KAAK,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE;AAAE,iBAAG;AAAA,UAAC;AAAC,iBAAO;AAAA,QAAE,GAAE;AACtW,iBAAS,GAAG,GAAE,GAAE;AAAC,cAAG;AAAE,mBAAO,EAAE,IAAG,GAAE,GAAE,CAAC;AAAE,iBAAK;AAAE,iBAAK;AAAE,cAAI,IAAE;AAAE,aAAG,EAAE,QAAQ,SAAS,GAAE,GAAE;AAAC,gBAAI,IAAE,IAAE;AAAE,gBAAE,EAAE,EAAE,IAAE,IAAE,KAAG,MAAI,CAAC,IAAE;AAAE,iBAAI,IAAE,GAAE,IAAE,EAAE,QAAO,EAAE;AAAE,gBAAE,EAAE,OAAK,MAAI,CAAC,IAAE,EAAE,WAAW,CAAC;AAAE,cAAE,EAAE,KAAG,MAAI,CAAC,IAAE;AAAE,iBAAG,EAAE,SAAO;AAAA,UAAC,CAAC;AAAE,iBAAO;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE,GAAE;AAAC,cAAG;AAAE,mBAAO,EAAE,IAAG,GAAE,GAAE,CAAC;AAAE,iBAAK;AAAE,iBAAK;AAAE,cAAI,IAAE,GAAG;AAAE,YAAE,EAAE,KAAG,MAAI,CAAC,IAAE,EAAE;AAAO,cAAI,IAAE;AAAE,YAAE,QAAQ,SAAS,GAAE;AAAC,iBAAG,EAAE,SAAO;AAAA,UAAC,CAAC;AAAE,YAAE,EAAE,KAAG,MAAI,CAAC,IAAE;AAAE,iBAAO;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE;AAAC,iBAAO,IAAE,EAAE,IAAG,GAAE,CAAC,IAAE;AAAA,QAAE;AAAC,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,iBAAO,IAAE,EAAE,IAAG,GAAE,GAAE,GAAE,GAAE,CAAC,IAAE;AAAA,QAAE;AAC/c,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE;AAAC,iBAAO,IAAE,EAAE,IAAG,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC,IAAE;AAAA,QAAE;AAAC,YAAI,KAAG,CAAC,MAAK,CAAC,GAAE,CAAC,CAAC;AAAE,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,cAAG;AAAE,mBAAO,EAAE,IAAG,GAAE,GAAE,GAAE,GAAE,CAAC;AAAE,iBAAK;AAAE,iBAAK;AAAE,iBAAK;AAAE,mBAAQ,IAAE,GAAE,IAAE,GAAE,IAAE,GAAE,KAAI;AAAC,gBAAI,IAAE,EAAE,EAAE,KAAG,MAAI,CAAC,GAAE,IAAE,EAAE,EAAE,IAAE,KAAG,MAAI,CAAC;AAAE,iBAAG;AAAE,qBAAQ,IAAE,GAAE,IAAE,GAAE,KAAI;AAAC,kBAAI,IAAE,EAAE,EAAE,IAAE,MAAI,CAAC,GAAE,IAAE,GAAG,CAAC;AAAE,oBAAI,KAAG,OAAK,MAAI,MAAI,IAAE,KAAG,GAAG,GAAG,GAAE,CAAC,CAAC,GAAE,EAAE,SAAO,KAAG,EAAE,KAAK,CAAC;AAAA,YAAC;AAAC,iBAAG;AAAA,UAAC;AAAC,YAAE,EAAE,KAAG,MAAI,CAAC,IAAE;AAAE,iBAAO;AAAA,QAAC;AAAC,YAAI,KAAG,CAAC,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,EAAE,GAAE,KAAG,CAAC,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,EAAE;AAAE,iBAAS,GAAG,GAAE;AAAC,cAAI,IAAE,MAAM,GAAG,CAAC,IAAE,CAAC;AAAE,aAAG,GAAE,GAAE,GAAE,EAAE,MAAM;AAAE,iBAAO;AAAA,QAAC;AACjf,YAAI,KAAG,CAAC,GAAE,MAAI;AAAC,YAAE,EAAE,IAAI,GAAE,MAAI,CAAC;AAAA,QAAC;AAC/B,iBAAS,GAAG,GAAE,GAAE,GAAE,GAAE;AAAC,mBAAS,EAAE,GAAE,GAAE,GAAE;AAAC,iBAAI,IAAE,YAAU,OAAO,IAAE,EAAE,SAAS,IAAE,KAAG,IAAG,EAAE,SAAO;AAAG,kBAAE,EAAE,CAAC,IAAE;AAAE,mBAAO;AAAA,UAAC;AAAC,mBAAS,EAAE,GAAE,GAAE;AAAC,mBAAO,EAAE,GAAE,GAAE,GAAG;AAAA,UAAC;AAAC,mBAAS,EAAE,GAAE,GAAE;AAAC,qBAAS,EAAE,IAAG;AAAC,qBAAO,IAAE,KAAG,KAAG,IAAE,KAAG,IAAE;AAAA,YAAC;AAAC,gBAAI;AAAE,mBAAK,IAAE,EAAE,EAAE,YAAY,IAAE,EAAE,YAAY,CAAC,MAAI,OAAK,IAAE,EAAE,EAAE,SAAS,IAAE,EAAE,SAAS,CAAC,OAAK,IAAE,EAAE,EAAE,QAAQ,IAAE,EAAE,QAAQ,CAAC;AAAG,mBAAO;AAAA,UAAC;AAAC,mBAAS,EAAE,GAAE;AAAC,oBAAO,EAAE,OAAO,GAAE;AAAA,cAAC,KAAK;AAAE,uBAAO,IAAI,KAAK,EAAE,YAAY,IAAE,GAAE,IAAG,EAAE;AAAA,cAAE,KAAK;AAAE,uBAAO;AAAA,cAAE,KAAK;AAAE,uBAAO,IAAI,KAAK,EAAE,YAAY,GAAE,GAAE,CAAC;AAAA,cAAE,KAAK;AAAE,uBAAO,IAAI;AAAA,kBAAK,EAAE,YAAY;AAAA,kBAC5f;AAAA,kBAAE;AAAA,gBAAC;AAAA,cAAE,KAAK;AAAE,uBAAO,IAAI,KAAK,EAAE,YAAY,GAAE,GAAE,CAAC;AAAA,cAAE,KAAK;AAAE,uBAAO,IAAI,KAAK,EAAE,YAAY,IAAE,GAAE,IAAG,EAAE;AAAA,cAAE,KAAK;AAAE,uBAAO,IAAI,KAAK,EAAE,YAAY,IAAE,GAAE,IAAG,EAAE;AAAA,YAAC;AAAA,UAAC;AAAC,mBAAS,EAAE,GAAE;AAAC,gBAAI,IAAE,EAAE;AAAG,iBAAI,IAAE,IAAI,KAAM,IAAI,KAAK,EAAE,KAAG,MAAK,GAAE,CAAC,EAAG,QAAQ,CAAC,GAAE,IAAE,KAAG;AAAC,kBAAI,IAAE,EAAE,SAAS,GAAE,KAAG,EAAE,EAAE,YAAY,CAAC,IAAE,KAAG,IAAI,CAAC;AAAE,kBAAG,IAAE,IAAE,EAAE,QAAQ;AAAE,qBAAG,IAAE,EAAE,QAAQ,IAAE,GAAE,EAAE,QAAQ,CAAC,GAAE,KAAG,IAAE,EAAE,SAAS,IAAE,CAAC,KAAG,EAAE,SAAS,CAAC,GAAE,EAAE,YAAY,EAAE,YAAY,IAAE,CAAC;AAAA,mBAAO;AAAC,kBAAE,QAAQ,EAAE,QAAQ,IAAE,CAAC;AAAE;AAAA,cAAK;AAAA,YAAC;AAAC,gBAAE,IAAI,KAAK,EAAE,YAAY,IAAE,GAAE,GAAE,CAAC;AAAE,gBAAE,EAAE,IAAI;AAAA,cAAK,EAAE,YAAY;AAAA,cACnf;AAAA,cAAE;AAAA,YAAC,CAAC;AAAE,gBAAE,EAAE,CAAC;AAAE,mBAAO,KAAG,EAAE,GAAE,CAAC,IAAE,KAAG,EAAE,GAAE,CAAC,IAAE,EAAE,YAAY,IAAE,IAAE,EAAE,YAAY,IAAE,EAAE,YAAY,IAAE;AAAA,UAAC;AAAC,iBAAK;AAAE,iBAAK;AAAE,iBAAK;AAAE,iBAAK;AAAE,cAAI,IAAE,EAAE,EAAE,IAAE,MAAI,MAAI,CAAC;AAAE,cAAE,EAAC,IAAG,EAAE,EAAE,KAAG,MAAI,CAAC,GAAE,IAAG,EAAE,EAAE,IAAE,KAAG,MAAI,CAAC,GAAE,IAAG,EAAE,EAAE,IAAE,KAAG,MAAI,CAAC,GAAE,IAAG,EAAE,EAAE,IAAE,MAAI,MAAI,CAAC,GAAE,IAAG,EAAE,EAAE,IAAE,MAAI,MAAI,CAAC,GAAE,IAAG,EAAE,EAAE,IAAE,MAAI,MAAI,CAAC,GAAE,IAAG,EAAE,EAAE,IAAE,MAAI,MAAI,CAAC,GAAE,IAAG,EAAE,EAAE,IAAE,MAAI,MAAI,CAAC,GAAE,IAAG,EAAE,EAAE,IAAE,MAAI,MAAI,CAAC,GAAE,IAAG,EAAE,EAAE,IAAE,MAAI,MAAI,CAAC,GAAE,IAAG,IAAE,EAAE,CAAC,IAAE,GAAE;AAAE,cAAE,EAAE,CAAC;AAAE,cAAE;AAAA,YAAC,MAAK;AAAA,YAAuB,MAAK;AAAA,YAAW,MAAK;AAAA,YAAW,MAAK;AAAA,YAAK,MAAK;AAAA,YAAc,MAAK;AAAA,YAAQ,MAAK;AAAA,YAAW,MAAK;AAAA,YAAW,MAAK;AAAA,YACxf,OAAM;AAAA,YAAK,OAAM;AAAA,YAAK,OAAM;AAAA,YAAW,OAAM;AAAA,YAAW,OAAM;AAAA,YAAK,OAAM;AAAA,YAAK,OAAM;AAAA,YAAK,OAAM;AAAA,YAAK,OAAM;AAAA,YAAK,OAAM;AAAA,YAAK,OAAM;AAAA,YAAK,OAAM;AAAA,YAAK,OAAM;AAAA,YAAK,OAAM;AAAA,YAAK,OAAM;AAAA,YAAK,OAAM;AAAA,YAAK,OAAM;AAAA,YAAK,OAAM;AAAA,YAAK,OAAM;AAAA,UAAI;AAAE,mBAAQ,KAAK;AAAE,gBAAE,EAAE,QAAQ,IAAI,OAAO,GAAE,GAAG,GAAE,EAAE,CAAC,CAAC;AAAE,cAAI,IAAE,2DAA2D,MAAM,GAAG,GAAE,IAAE,wFAAwF,MAAM,GAAG;AAAE,cAAE,EAAC,MAAK,OAAG,EAAE,EAAE,EAAE,EAAE,UAAU,GAAE,CAAC,GAAE,MAAK,OAAG,EAAE,EAAE,EAAE,GAAE,MAAK,OACzf,EAAE,EAAE,EAAE,EAAE,UAAU,GAAE,CAAC,GAAE,MAAK,OAAG,EAAE,EAAE,EAAE,GAAE,MAAK,OAAG,GAAG,EAAE,KAAG,QAAM,MAAI,GAAE,CAAC,GAAE,MAAK,OAAG,EAAE,EAAE,IAAG,CAAC,GAAE,MAAK,OAAG,EAAE,EAAE,IAAG,GAAE,GAAG,GAAE,MAAK,OAAG,EAAE,CAAC,EAAE,SAAS,EAAE,UAAU,CAAC,GAAE,MAAK,OAAG,EAAE,CAAC,GAAE,MAAK,OAAG,EAAE,EAAE,IAAG,CAAC,GAAE,MAAK,OAAG;AAAC,gBAAE,EAAE;AAAG,iBAAG,IAAE,IAAE,KAAG,KAAG,MAAI,KAAG;AAAI,mBAAO,EAAE,GAAE,CAAC;AAAA,UAAC,GAAE,MAAK,OAAG;AAAC,qBAAQ,IAAE,GAAE,IAAE,GAAE,KAAG,EAAE,KAAG,GAAE,MAAI,EAAE,EAAE,KAAG,IAAI,IAAE,KAAG,IAAI,GAAG;AAAE;AAAC,mBAAO,EAAE,EAAE,KAAG,GAAE,CAAC;AAAA,UAAC,GAAE,MAAK,OAAG,EAAE,EAAE,KAAG,GAAE,CAAC,GAAE,MAAK,OAAG,EAAE,EAAE,IAAG,CAAC,GAAE,MAAK,MAAI,MAAK,MAAK,OAAG,KAAG,EAAE,MAAI,KAAG,EAAE,KAAG,OAAK,MAAK,MAAK,OAAG,EAAE,EAAE,IAAG,CAAC,GAAE,MAAK,MAAI,KAAK,MAAK,OAAG,EAAE,MAAI,GAAE,MAAK,OAAG,EAAE,KAAK,OAAO,EAAE,KAAG,IAAE,EAAE,MAAI,CAAC,GAAE,CAAC,GAAE,MAAK,OACnf;AAAC,gBAAI,IAAE,KAAK,OAAO,EAAE,KAAG,KAAG,EAAE,KAAG,KAAG,KAAG,CAAC;AAAE,kBAAI,EAAE,KAAG,MAAI,EAAE,KAAG,KAAG,KAAG;AAAI,gBAAG;AAAE,oBAAI,MAAI,KAAG,EAAE,KAAG,MAAI,EAAE,MAAI,GAAE,KAAG,KAAG,KAAG,KAAG,EAAE,EAAE,EAAE,MAAI,IAAE;AAAA,iBAAQ;AAAC,kBAAE;AAAG,kBAAI,KAAG,EAAE,KAAG,IAAE,EAAE,KAAG,KAAG;AAAE,eAAC,KAAG,KAAG,KAAG,KAAG,EAAE,EAAE,KAAG,MAAI,CAAC,MAAI;AAAA,YAAG;AAAC,mBAAO,EAAE,GAAE,CAAC;AAAA,UAAC,GAAE,MAAK,OAAG,EAAE,IAAG,MAAK,OAAG,EAAE,KAAK,OAAO,EAAE,KAAG,KAAG,EAAE,KAAG,KAAG,KAAG,CAAC,GAAE,CAAC,GAAE,MAAK,QAAI,EAAE,KAAG,MAAM,SAAS,EAAE,UAAU,CAAC,GAAE,MAAK,OAAG,EAAE,KAAG,MAAK,MAAK,OAAG;AAAC,gBAAE,EAAE;AAAG,gBAAI,IAAE,KAAG;AAAE,gBAAE,KAAK,IAAI,CAAC,IAAE;AAAG,oBAAO,IAAE,MAAI,OAAK,OAAO,UAAQ,IAAE,KAAG,MAAI,IAAE,GAAG,EAAE,MAAM,EAAE;AAAA,UAAC,GAAE,MAAK,OAAG,EAAE,IAAG,MAAK,MAAI,IAAG;AAAE,cAAE,EAAE,QAAQ,OAAM,MAAU;AAAE,eAAI,KAAK;AAAE,cAAE,SAAS,CAAC,MACrgB,IAAE,EAAE,QAAQ,IAAI,OAAO,GAAE,GAAG,GAAE,EAAE,CAAC,EAAE,CAAC,CAAC;AAAG,cAAE,EAAE,QAAQ,SAAQ,GAAG;AAAE,cAAE,GAAG,CAAC;AAAE,cAAG,EAAE,SAAO;AAAE,mBAAO;AAAE,aAAG,GAAE,CAAC;AAAE,iBAAO,EAAE,SAAO;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE;AAAC,cAAG;AAAC,cAAE;AAAA,UAAC,SAAO,GAAE;AAAC,cAAE,CAAC;AAAA,UAAC;AAAA,QAAC;AAAC,iBAAS,GAAG,GAAE;AAAC,cAAI,IAAE,CAAC,GAAE;AAAE,eAAI,KAAK;AAAE,aAAC,SAAS,GAAE;AAAC,kBAAI,IAAE,EAAE,CAAC;AAAE,gBAAE,CAAC,IAAE,cAAY,OAAO,IAAE,WAAU;AAAC,mBAAG,KAAK,CAAC;AAAE,oBAAG;AAAC,yBAAO,EAAE,MAAM,MAAK,SAAS;AAAA,gBAAC,UAAC;AAAQ,wBAAI,GAAG,IAAI,MAAI,KAAG,EAAE,GAAE,KAAG,MAAI,KAAG,MAAI,GAAG,WAAS,IAAE,GAAE,MAAI,GAAE,GAAG,EAAE,GAAE,eAAa,OAAO,UAAQ,OAAO,GAAG;AAAA,gBAAG;AAAA,cAAC,IAAE;AAAA,YAAC,GAAG,CAAC;AAAE,iBAAO;AAAA,QAAC;AAAC,YAAI,IAAE,GAAE,IAAE,MAAK,KAAG,GAAE,KAAG,CAAC,GAAE,KAAG,CAAC,GAAE,KAAG,CAAC,GAAE,KAAG,GAAE,KAAG,MAAK,KAAG,CAAC;AAC7e,iBAAS,KAAI;AAAC,iBAAO,IAAI,QAAQ,CAAC,GAAE,MAAI;AAAC,iBAAG,EAAC,SAAQ,GAAE,QAAO,EAAC;AAAA,UAAC,CAAC;AAAA,QAAC;AAAC,iBAAS,KAAI;AAAC,cAAI,IAAE,GAAG,KAAK,GAAE,IAAE,IAAE;AAAG,YAAE,EAAE,KAAG,MAAI,CAAC,IAAE;AAAE,YAAE,EAAE,IAAE,KAAG,MAAI,CAAC,IAAE,IAAE;AAAM,cAAE,GAAG,CAAC;AAAE,cAAI,IAAE,GAAG,CAAC;AAAE,qBAAS,MAAI,IAAE,MAAK,GAAG,CAAC,IAAE,GAAE,GAAG,CAAC,IAAE;AAAG,cAAE;AAAE,YAAE,EAAE,IAAE,KAAG,MAAI,CAAC,IAAE;AAAE,iBAAO;AAAA,QAAC;AAAC,iBAAS,KAAI;AAAC,cAAI,IAAE,EAAE,EAAE,IAAE,KAAG,MAAI,CAAC;AAAE,cAAE,EAAE,GAAG,CAAC,CAAC;AAAE,YAAE;AAAG,iBAAO,EAAE;AAAA,QAAC;AACtS,iBAAS,GAAG,GAAE;AAAC,cAAG,CAAC,GAAE;AAAC,gBAAG,MAAI,GAAE;AAAC,kBAAI,IAAE,OAAG,IAAE;AAAG,gBAAE,CAAC,IAAE,MAAI;AAAC,oBAAG,CAAC,MAAI,KAAG,GAAE,IAAE,MAAG,IAAG;AAAC,sBAAE;AAAE,qBAAG,MAAI,GAAG,CAAC,CAAC;AAAE,iCAAa,OAAO,WAAS,QAAQ,GAAG,MAAI,QAAQ,GAAG,OAAO;AAAE,sBAAE;AAAG,sBAAG;AAAC,wBAAI,IAAE,GAAG;AAAA,kBAAC,SAAO,GAAE;AAAC,wBAAE,GAAE,IAAE;AAAA,kBAAE;AAAC,sBAAI,IAAE;AAAG,sBAAG,CAAC,GAAE;AAAC,wBAAI,IAAE;AAAG,0BAAI,KAAG,OAAM,IAAE,EAAE,SAAO,EAAE,SAAS,CAAC,GAAE,IAAE;AAAA,kBAAG;AAAC,sBAAG,KAAG,CAAC;AAAE,0BAAM;AAAA,gBAAE;AAAA,cAAC,CAAC;AAAE,kBAAE;AAAG,oBAAI,IAAE,GAAE,IAAE,GAAG,GAAE,eAAa,OAAO,WAAS,QAAQ,GAAG,MAAI,QAAQ,GAAG,MAAM,GAAE,GAAG,MAAI,GAAG,CAAC,CAAC;AAAA,YAAE;AAAM,oBAAI,KAAG,IAAE,GAAE,GAAG,EAAE,GAAE,GAAG,CAAC,GAAE,IAAE,MAAK,GAAG,QAAQ,OAAG,GAAG,CAAC,CAAC,KAAG,EAAE,kBAAkB,CAAC,EAAE;AAAE,mBAAO;AAAA,UAAE;AAAA,QAAC;AAC/d,iBAAS,GAAG,GAAE;AAAC,iBAAO,GAAG,OAAG;AAAC,cAAE,EAAE,KAAK,CAAC;AAAA,UAAC,CAAC;AAAA,QAAC;AAAC,UAAE,GAAG;AAChD,YAAI,KAAG,CAAC,MAAK,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,IAAG,EAAE,GAAE,KAAG;AAAA,UAAC,GAAE,SAAS,GAAE,GAAE,GAAE;AAAC,mBAAO,GAAG,YAAS;AAAC,oBAAM,EAAE,GAAG,GAAE,GAAE,CAAC;AAAA,YAAC,CAAC;AAAA,UAAC;AAAA,UAAE,GAAE,SAAS,GAAE,GAAE,GAAE;AAAC,mBAAK;AAAE,YAAC,IAAI,GAAG,CAAC,EAAG,GAAG,MAAI,GAAE,MAAI,CAAC;AAAE,iBAAG;AAAE;AAAK,kBAAM;AAAA,UAAG;AAAA,UAAE,GAAE,SAAS,GAAE;AAAC,eAAG,MAAI,GAAE,CAAC,GAAE,GAAE,CAAC,IAAG,QAAO,KAAE;AAAE,cAAE,GAAG;AAAA,UAAC;AAAA,UAAE,GAAE,SAAS,GAAE;AAAC,mBAAK;AAAE,gBAAE,YAAY,EAAC,KAAI,iBAAgB,QAAO,EAAC,CAAC,IAAE,GAAG,CAAC;AAAA,UAAC;AAAA,UAAE,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE,MAAI;AAAA,UAAG,GAAE,SAAS,GAAE,GAAE;AAAC,mBAAK;AAAE,iBAAG,MAAI,IAAE,WAAW,MAAI,GAAG,CAAC,IAAE,IAAE,YAAY;AAAA,cAAC,cAAa;AAAA,cAC5f,KAAI;AAAA,YAAc,CAAC,KAAG,IAAE,EAAE,GAAG,CAAC,MAAI,EAAE,YAAY,EAAC,KAAI,eAAc,CAAC;AAAA,UAAC;AAAA,UAAE,GAAE,WAAU;AAAC,mBAAM;AAAA,UAAE;AAAA,UAAE,GAAE;AAAA,UAAG,GAAE,SAAS,GAAE;AAAC,iBAAG,EAAE,GAAG,MAAI,CAAC,EAAE,IAAI;AAAA,UAAC;AAAA,UAAE,GAAE,SAAS,GAAE,GAAE,GAAE;AAAC,gBAAE,IAAE,YAAU,IAAE,UAAQ,CAAC,CAAC,KAAG,MAAI,KAAG,aAAW,IAAE;AAAI,mBAAK;AAAE,gBAAE,IAAI,KAAK,MAAI,CAAC;AAAE,cAAE,EAAE,KAAG,MAAI,CAAC,IAAE,EAAE,cAAc;AAAE,cAAE,EAAE,IAAE,KAAG,MAAI,CAAC,IAAE,EAAE,cAAc;AAAE,cAAE,EAAE,IAAE,KAAG,MAAI,CAAC,IAAE,EAAE,YAAY;AAAE,cAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE,EAAE,WAAW;AAAE,cAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE,EAAE,YAAY;AAAE,cAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE,EAAE,eAAe,IAAE;AAAK,cAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE,EAAE,UAAU;AAAE,iBAAG,EAAE,QAAQ,IAAE,KAAK;AAAA,cAAI,EAAE,eAAe;AAAA,cAC3f;AAAA,cAAE;AAAA,cAAE;AAAA,cAAE;AAAA,cAAE;AAAA,cAAE;AAAA,YAAC,KAAG,QAAM;AAAE,cAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE;AAAA,UAAC;AAAA,UAAE,GAAE,SAAS,GAAE,GAAE,GAAE;AAAC,gBAAE,IAAE,YAAU,IAAE,UAAQ,CAAC,CAAC,KAAG,MAAI,KAAG,aAAW,IAAE;AAAI,mBAAK;AAAE,gBAAE,IAAI,KAAK,MAAI,CAAC;AAAE,cAAE,EAAE,KAAG,MAAI,CAAC,IAAE,EAAE,WAAW;AAAE,cAAE,EAAE,IAAE,KAAG,MAAI,CAAC,IAAE,EAAE,WAAW;AAAE,cAAE,EAAE,IAAE,KAAG,MAAI,CAAC,IAAE,EAAE,SAAS;AAAE,cAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE,EAAE,QAAQ;AAAE,cAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE,EAAE,SAAS;AAAE,cAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE,EAAE,YAAY,IAAE;AAAK,cAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE,EAAE,OAAO;AAAE,iBAAG,EAAE,EAAE,YAAY,CAAC,IAAE,KAAG,IAAI,EAAE,SAAS,CAAC,IAAE,EAAE,QAAQ,IAAE,IAAE;AAAE,cAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE;AAAE,cAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE,EAAE,KAAG,EAAE,kBAAkB;AAAG,gBAAG,IAAI;AAAA,cAAK,EAAE,YAAY;AAAA,cACrf;AAAA,cAAE;AAAA,YAAC,EAAG,kBAAkB;AAAE,gBAAI,IAAG,IAAI,KAAK,EAAE,YAAY,GAAE,GAAE,CAAC,EAAG,kBAAkB;AAAE,iBAAG,KAAG,KAAG,EAAE,kBAAkB,KAAG,KAAK,IAAI,GAAE,CAAC,KAAG;AAAE,cAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE;AAAA,UAAC;AAAA,UAAE,GAAE,SAAS,GAAE;AAAC,mBAAK;AAAE,gBAAI,IAAE,IAAI,KAAK,EAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE,MAAK,EAAE,EAAE,IAAE,MAAI,MAAI,CAAC,GAAE,EAAE,EAAE,IAAE,MAAI,MAAI,CAAC,GAAE,EAAE,EAAE,IAAE,KAAG,MAAI,CAAC,GAAE,EAAE,EAAE,IAAE,KAAG,MAAI,CAAC,GAAE,EAAE,EAAE,KAAG,MAAI,CAAC,GAAE,CAAC,GAAE,IAAE,EAAE,EAAE,IAAE,MAAI,MAAI,CAAC,GAAE,IAAE,EAAE,kBAAkB,GAAE,IAAG,IAAI,KAAK,EAAE,YAAY,GAAE,GAAE,CAAC,EAAG,kBAAkB,GAAE,IAAG,IAAI,KAAK,EAAE,YAAY,GAAE,GAAE,CAAC,EAAG,kBAAkB,GAAE,IAAE,KAAK,IAAI,GAAE,CAAC;AAAE,gBAAE,IAAE,EAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE,OAAO,KAAG,KAAG,KAAG,CAAC,IACnf,IAAE,MAAI,KAAG,OAAK,IAAE,KAAK,IAAI,GAAE,CAAC,GAAE,EAAE,QAAQ,EAAE,QAAQ,IAAE,QAAM,IAAE,IAAE,IAAE,KAAG,EAAE;AAAG,cAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE,EAAE,OAAO;AAAE,iBAAG,EAAE,EAAE,YAAY,CAAC,IAAE,KAAG,IAAI,EAAE,SAAS,CAAC,IAAE,EAAE,QAAQ,IAAE,IAAE;AAAE,cAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE;AAAE,cAAE,EAAE,KAAG,MAAI,CAAC,IAAE,EAAE,WAAW;AAAE,cAAE,EAAE,IAAE,KAAG,MAAI,CAAC,IAAE,EAAE,WAAW;AAAE,cAAE,EAAE,IAAE,KAAG,MAAI,CAAC,IAAE,EAAE,SAAS;AAAE,cAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE,EAAE,QAAQ;AAAE,cAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE,EAAE,SAAS;AAAE,cAAE,EAAE,IAAE,MAAI,MAAI,CAAC,IAAE,EAAE,QAAQ;AAAE,gBAAE,EAAE,QAAQ,IAAE;AAAI,mBAAO,IAAI,IAAE,GAAE,KAAG,CAAC,KAAK,IAAI,CAAC,IAAE,IAAE,IAAE,CAAC,KAAK,MAAM,IAAE,UAAU,MAAI,IAAE,CAAC,CAAC,CAAC,KAAK,MAAM,IAAE,EAAE,CAAC,CAAC,MAAI,MAAI,UAAU,MAAI,IAAE,EAAE,GAAE,MAAI;AAAA,UAAC;AAAA,UAAE,GAAE;AAAA,UAAG,GAAE;AAAA,UACpf,GAAE,SAAS,GAAE,GAAE,GAAE;AAAC,qBAAS,EAAE,GAAE;AAAC,sBAAO,IAAE,EAAE,aAAa,EAAE,MAAM,mBAAmB,KAAG,EAAE,CAAC,IAAE;AAAA,YAAK;AAAC,mBAAK;AAAE,mBAAK;AAAE,mBAAK;AAAE,gBAAI,KAAG,oBAAI,QAAM,YAAY,GAAE,IAAE,IAAI,KAAK,GAAE,GAAE,CAAC,GAAE,IAAE,IAAI,KAAK,GAAE,GAAE,CAAC;AAAE,gBAAE,EAAE,kBAAkB;AAAE,gBAAI,IAAE,EAAE,kBAAkB,GAAE,IAAE,KAAK,IAAI,GAAE,CAAC;AAAE,cAAE,EAAE,KAAG,MAAI,CAAC,IAAE,KAAG;AAAE,cAAE,EAAE,KAAG,MAAI,CAAC,IAAE,OAAO,KAAG,CAAC;AAAE,gBAAE,EAAE,CAAC;AAAE,gBAAE,EAAE,CAAC;AAAE,gBAAE,GAAG,CAAC;AAAE,gBAAE,GAAG,CAAC;AAAE,gBAAE,KAAG,EAAE,EAAE,KAAG,MAAI,CAAC,IAAE,GAAE,EAAE,EAAE,IAAE,KAAG,MAAI,CAAC,IAAE,MAAI,EAAE,EAAE,KAAG,MAAI,CAAC,IAAE,GAAE,EAAE,EAAE,IAAE,KAAG,MAAI,CAAC,IAAE;AAAA,UAAE;AAAA,UAAE,GAAE,MAAI;AAAC,cAAE,EAAE;AAAA,UAAC;AAAA,UAAE,GAAE,SAAS,GAAE,GAAE,GAAE;AAAC,mBAAK;AAAE,gBAAE,GAAG,MAAI,GAAE,MAAI,CAAC;AAAE,mBAAO,GAAG,CAAC,EAAE,MAAM,MAAK,CAAC;AAAA,UAAC;AAAA,UAAE,GAAE,SAAS,GACtf,GAAE,GAAE;AAAC,mBAAK;AAAE,gBAAE,GAAG,MAAI,GAAE,MAAI,CAAC;AAAE,mBAAO,GAAG,CAAC,EAAE,MAAM,MAAK,CAAC;AAAA,UAAC;AAAA,UAAE,GAAE,WAAU;AAAA,UAAC;AAAA,UAAE,GAAE,WAAU;AAAC,mBAAO,KAAK,IAAI;AAAA,UAAC;AAAA,UAAE,GAAE,MAAI;AAAC,kBAAI;AAAE,kBAAK;AAAA,UAAS;AAAA,UAAE,GAAE,WAAU;AAAC,mBAAO;AAAA,UAAU;AAAA,UAAE,GAAE,MAAI,YAAY,aAAW,YAAY,IAAI;AAAA,UAAE,GAAE,WAAU;AAAC,mBAAO,IAAE,sCAAc,KAAK,EAAE,SAAO,UAAU;AAAA,UAAmB;AAAA,UAAE,GAAE,SAAS,GAAE,GAAE,GAAE,GAAE;AAAC,cAAE,KAAG,MAAI;AAAE,eAAG,SAAO;AAAE,gBAAE,MAAI,KAAG;AAAE,iBAAI,IAAE,GAAE,IAAE,GAAE;AAAI,iBAAG,CAAC,IAAE,GAAG,EAAE,IAAE,MAAI,CAAC;AAAE,oBAAO,IAAE,IAAE,GAAG,CAAC,IAAE,CAAC,IAAE,GAAG,CAAC,GAAG,MAAM,MAAK,EAAE;AAAA,UAAC;AAAA,UAAE,GAAE,SAAS,GAAE;AAAC,mBAAK;AAAE,gBAAI,IAAE,EAAE,EAAE;AAAO,gBAAG,KAAG,KAAG,aAAW;AAAE,qBAAM;AAAG,qBAAQ,IACxf,GAAE,KAAG,GAAE,KAAG,GAAE;AAAC,kBAAI,IAAE,KAAG,IAAE,MAAG;AAAG,kBAAE,KAAK,IAAI,GAAE,IAAE,SAAS;AAAE,kBAAI,IAAE;AAAK,kBAAE,KAAK,IAAI,GAAE,CAAC;AAAE,iBAAE;AAAC,oBAAE,EAAE,IAAI,KAAK,GAAE,YAAW,KAAG,QAAM,IAAE,SAAO,KAAK,IAAE,EAAE,OAAO,aAAW,UAAQ;AAAG,oBAAG;AAAC,oBAAE,KAAK,CAAC;AAAE,oBAAE;AAAE,sBAAI,IAAE;AAAE,wBAAM;AAAA,gBAAC,SAAO,GAAE;AAAA,gBAAC;AAAC,oBAAE;AAAA,cAAM;AAAC,kBAAG;AAAE,uBAAM;AAAA,YAAE;AAAC,mBAAM;AAAA,UAAE;AAAA,UAAE,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE;AAAA,UAAG,GAAE,KAAG,EAAE;AAAA,UAAW,GAAE;AAAA,UAAG,GAAE,SAAS,GAAE,GAAE,GAAE,GAAE;AAAC,mBAAO,GAAG,MAAI,GAAE,MAAI,GAAE,MAAI,GAAE,MAAI,CAAC;AAAA,UAAC;AAAA,QAAC;AACtW,SAAC,WAAU;AAAC,mBAAS,EAAE,GAAE,GAAE;AAAC,gBAAE,EAAE;AAAQ,gBAAE,GAAG,CAAC;AAAE,gBAAE,IAAE,GAAG,CAAC;AAAE,cAAE,GAAG,KAAK,EAAE,EAAE;AAAE,eAAG,QAAQ,EAAE,CAAC;AAAE,iBAAG;AAAE,eAAG;AAAE,mBAAO;AAAA,UAAC;AAAC,cAAI,IAAE,EAAC,GAAE,GAAE;AAAE,aAAG;AAAE,cAAG,EAAE;AAAgB,gBAAG;AAAC,qBAAO,EAAE,gBAAgB,GAAE,CAAC;AAAA,YAAC,SAAO,GAAE;AAAC,gBAAE,wDAAsD,CAAC,GAAE,EAAE,CAAC;AAAA,YAAC;AAAC,aAAG,GAAE,SAAS,GAAE;AAAC,cAAE,EAAE,UAAS,EAAE,MAAM;AAAA,UAAC,CAAC,EAAE,MAAM,CAAC;AAAE,iBAAM,CAAC;AAAA,QAAC,GAAG;AAAE,UAAE,WAAS,CAAC,GAAE,OAAK,EAAE,WAAS,EAAE,GAAG,GAAE,CAAC;AAAE,UAAE,mBAAiB,CAAC,GAAE,OAAK,EAAE,mBAAiB,EAAE,GAAG,GAAE,CAAC;AAC7Z,UAAE,2BAAyB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,EAAE,2BAAyB,EAAE,GAAG,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAE,UAAE,8BAA4B,CAAC,GAAE,OAAK,EAAE,8BAA4B,EAAE,IAAI,GAAE,CAAC;AAAE,UAAE,+BAA6B,CAAC,GAAE,GAAE,OAAK,EAAE,+BAA6B,EAAE,IAAI,GAAE,GAAE,CAAC;AAAE,UAAE,4BAA0B,CAAC,GAAE,GAAE,OAAK,EAAE,4BAA0B,EAAE,IAAI,GAAE,GAAE,CAAC;AAAE,UAAE,4BAA0B,QAAI,EAAE,4BAA0B,EAAE,IAAI,CAAC;AAAE,UAAE,oBAAkB,CAAC,GAAE,GAAE,OAAK,EAAE,oBAAkB,EAAE,IAAI,GAAE,GAAE,CAAC;AAC7d,UAAE,qBAAmB,QAAI,EAAE,qBAAmB,EAAE,IAAI,CAAC;AAAE,UAAE,0BAAwB,CAAC,GAAE,GAAE,OAAK,EAAE,0BAAwB,EAAE,IAAI,GAAE,GAAE,CAAC;AAAE,UAAE,mBAAiB,CAAC,GAAE,OAAK,EAAE,mBAAiB,EAAE,IAAI,GAAE,CAAC;AAAE,UAAE,oBAAkB,CAAC,GAAE,OAAK,EAAE,oBAAkB,EAAE,IAAI,GAAE,CAAC;AAAE,UAAE,WAAS,QAAI,EAAE,WAAS,EAAE,IAAI,CAAC;AAAE,UAAE,mBAAiB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,EAAE,mBAAiB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAE,UAAE,oBAAkB,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,EAAE,oBAAkB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC;AAAE,UAAE,oBAAkB,QAAI,EAAE,oBAAkB,EAAE,IAAI,CAAC;AAC5d,UAAE,uBAAqB,CAAC,GAAE,GAAE,GAAE,OAAK,EAAE,uBAAqB,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC;AAAE,UAAE,wBAAsB,CAAC,GAAE,GAAE,OAAK,EAAE,wBAAsB,EAAE,IAAI,GAAE,GAAE,CAAC;AAAE,UAAE,wBAAsB,QAAI,EAAE,wBAAsB,EAAE,IAAI,CAAC;AAAE,UAAE,oBAAkB,QAAI,EAAE,oBAAkB,EAAE,IAAI,CAAC;AAAE,UAAE,gBAAc,CAAC,GAAE,GAAE,OAAK,EAAE,gBAAc,EAAE,IAAI,GAAE,GAAE,CAAC;AAAE,UAAE,iBAAe,CAAC,GAAE,GAAE,GAAE,OAAK,EAAE,iBAAe,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC;AAAE,UAAE,wBAAsB,QAAI,EAAE,wBAAsB,EAAE,IAAI,CAAC;AAAE,UAAE,qBAAmB,QAAI,EAAE,qBAAmB,EAAE,IAAI,CAAC;AACxe,UAAE,qBAAmB,CAAC,GAAE,GAAE,GAAE,GAAE,OAAK,EAAE,qBAAmB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,CAAC;AAAE,UAAE,UAAQ,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,EAAE,UAAQ,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAE,UAAE,mBAAiB,QAAI,EAAE,mBAAiB,EAAE,IAAI,CAAC;AAAE,UAAE,cAAY,CAAC,GAAE,GAAE,OAAK,EAAE,cAAY,EAAE,IAAI,GAAE,GAAE,CAAC;AAAE,UAAE,mBAAiB,QAAI,EAAE,mBAAiB,EAAE,IAAI,CAAC;AAAE,YAAI,KAAG,EAAE,gBAAc,OAAK,KAAG,EAAE,gBAAc,EAAE,IAAI,GAAE,KAAG,EAAE,UAAQ,QAAI,KAAG,EAAE,UAAQ,EAAE,IAAI,CAAC,GAAE,KAAG,EAAE,QAAM,QAAI,KAAG,EAAE,QAAM,EAAE,IAAI,CAAC;AAAE,UAAE,wBAAsB,OAAK,EAAE,wBAAsB,EAAE,IAAI;AAC7d,YAAI,KAAG,EAAE,2BAAyB,CAAC,GAAE,GAAE,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,2BAAyB,EAAE,IAAI,GAAE,GAAE,GAAE,GAAE,GAAE,CAAC;AAAE,UAAE,8BAA4B,OAAK,EAAE,8BAA4B,EAAE,IAAI;AAC1K,YAAI,KAAG,CAAC,GAAE,GAAE,GAAE,OAAK,KAAG,EAAE,IAAI,GAAE,GAAE,GAAE,CAAC,GAAE,KAAG,QAAI,KAAG,EAAE,IAAI,CAAC,GAAE,KAAG,EAAE,2BAAyB,QAAI,KAAG,EAAE,2BAAyB,EAAE,IAAI,CAAC,GAAE,KAAG,EAAE,6BAA2B,OAAK,KAAG,EAAE,6BAA2B,EAAE,IAAI,GAAE,KAAG,QAAI,KAAG,EAAE,IAAI,CAAC,GAAE,KAAG,CAAC,GAAE,OAAK,KAAG,EAAE,IAAI,GAAE,CAAC,GAAE,KAAG,OAAK,KAAG,EAAE,IAAI,GAAE,KAAG,QAAI,KAAG,EAAE,IAAI,CAAC,GAAE,KAAG,QAAI,KAAG,EAAE,IAAI,CAAC,GAAE,KAAG,EAAE,aAAW,CAAC,GAAE,OAAK,KAAG,EAAE,aAAW,EAAE,IAAI,GAAE,CAAC,GAAE,KAAG,QAAI,KAAG,EAAE,IAAI,CAAC,GAAE,KAAG,OAAK,KAAG,EAAE,IAAI,GAAE,KAAG,QAAI,KAAG,EAAE,IAAI,CAAC,GAAE,KAAG,OAAK,KAAG,EAAE,IAAI;AAAE,UAAE,iBAAe;AAAO,UAAE,gBAAc;AAC1d,iBAAS,GAAG,GAAE;AAAC,cAAE,OAAO,OAAO,CAAC,GAAE,CAAC;AAAE,cAAI,IAAE,OAAG,MAAI,EAAE,MAAI,GAAE,IAAE,OAAG,OAAG,EAAE,CAAC,MAAI;AAAE,YAAE,mBAAiB,EAAE,EAAE,gBAAgB;AAAE,YAAE,eAAa,EAAE,EAAE,YAAY;AAAE,YAAE,SAAO,EAAE,EAAE,MAAM;AAAE,YAAE,YAAU,EAAE,EAAE,SAAS;AAAE,YAAE,aAAW,EAAE,EAAE,UAAU;AAAE,iBAAO;AAAA,QAAC;AAAC,UAAE,mBAAiB;AAAG,UAAE,aAAW;AAAE,UAAE,aAAW;AAAG,UAAE,YAAU;AAAG,UAAE,eAAa;AAAG,UAAE,eAAa;AAAE,UAAE,eAAa;AAAG,UAAE,kBAAgB;AAAG,UAAE,aAAW;AAAG,UAAE,UAAQ;AAAE,YAAI;AAAG,YAAE,SAAS,KAAI;AAAC,gBAAI,GAAG;AAAE,iBAAK,IAAE;AAAA,QAAG;AAC/b,iBAAS,KAAI;AAAC,mBAAS,IAAG;AAAC,gBAAG,CAAC,OAAK,KAAG,MAAG,EAAE,YAAU,MAAG,CAAC,IAAG;AAAC,mBAAG,GAAG,EAAE;AAAE,iBAAG,CAAC;AAAE,kBAAG,EAAE;AAAqB,kBAAE,qBAAqB;AAAE,kBAAG,CAAC,GAAE;AAAC,oBAAG,EAAE;AAAQ,uBAAI,cAAY,OAAO,EAAE,YAAU,EAAE,UAAQ,CAAC,EAAE,OAAO,IAAG,EAAE,QAAQ,UAAQ;AAAC,wBAAI,IAAE,EAAE,QAAQ,MAAM;AAAE,uBAAG,QAAQ,CAAC;AAAA,kBAAC;AAAC,mBAAG,EAAE;AAAA,cAAC;AAAA,YAAC;AAAA,UAAC;AAAC,cAAG,EAAE,IAAE;AAAG,gBAAG;AAAE,iBAAG,CAAC,GAAE,KAAG,GAAG,EAAE,GAAE,YAAY,CAAC;AAAA,iBAAM;AAAC,kBAAG,EAAE;AAAO,qBAAI,cAAY,OAAO,EAAE,WAAS,EAAE,SAAO,CAAC,EAAE,MAAM,IAAG,EAAE,OAAO;AAAQ,qBAAG,QAAQ,EAAE,OAAO,MAAM,CAAC;AAAE,iBAAG,EAAE;AAAE,kBAAE,MAAI,EAAE,aAAW,EAAE,UAAU,YAAY,GAAE,WAAW,WAAU;AAAC;AAAA,kBAAW,WAAU;AAAC,sBAAE,UAAU,EAAE;AAAA,kBAAC;AAAA,kBACpiB;AAAA,gBAAC;AAAE,kBAAE;AAAA,cAAC,GAAE,CAAC,KAAG,EAAE;AAAA,YAAE;AAAA,QAAC;AAAC,YAAG,EAAE;AAAQ,eAAI,cAAY,OAAO,EAAE,YAAU,EAAE,UAAQ,CAAC,EAAE,OAAO,IAAG,IAAE,EAAE,QAAQ;AAAQ,cAAE,QAAQ,IAAI,EAAE;AAAE,WAAG;AAGhI,eAAO,UAAU;AAAA,MACnB;AAAA,IAGA,GAAG;AACH,QAAI,OAAO,YAAY,YAAY,OAAO,WAAW;AACnD,aAAO,UAAU;AAAA,aACV,OAAO,WAAW,cAAc,OAAO,KAAK;AACnD,aAAO,CAAC,GAAG,MAAM,eAAe;AAAA;AAAA;;;AC7FlC;AAAA;AAAA;AAAA;AAAA;;;ACAA,IAUI,gBASE,wBAMF,MACA,aACA,cACA,SAEE,wBA6CA,iBAyBA,iBAWO,uBA+GA;AA9Nb;AAAA;AAAA;AAGA;AASA,QAAI,OAA8B;AAChC,uBAAiB;AAAA,IACnB,OAAO;AACL,uBACI,QAA4B,OAAmC;AAAA,IACrE;AAEA,IAAM,yBAAiE,OAClE,QAA4B,OACA,wCAC7B;AAIJ,IAAI,cAAc;AAClB,IAAI,eAAe;AACnB,IAAI,UAAU;AAEd,IAAM,yBAAyB,CAAC,eAAgC;AAE9D,UAAI,eAAe,GAAG;AACpB,eAAO;AAAA,MACT;AAGA,UAAI,OAAO,sBAAsB,aAAa;AAC5C,YAAI,OAAO,SAAS,eAAe,CAAC,KAAK,qBAAqB;AAE5D,kBAAQ;AAAA,YACJ,mCAAmC,aACnC;AAAA,UACkE;AAAA,QACxE;AACA,eAAO;AAAA,MACT;AAGA,UAAI,OAAO,YAAY,eAAe,QAAQ,YAAY,QAAQ,SAAS,MAAM;AAE/E,gBAAQ;AAAA,UACJ,mCAAmC,aACnC;AAAA,QAC4E;AAAA,MAClF;AAEA,UAAI;AAGF,YAAI,OAAO,mBAAmB,aAAa;AACzC,cAAI,eAAe,EAAE,MAAM,YAAY,IAAI,kBAAkB,CAAC,CAAC;AAAA,QACjE;AAIA,eAAO,YAAY,SAAS,IAAI,WAAW;AAAA,UACzC;AAAA,UAAG;AAAA,UAAI;AAAA,UAAK;AAAA,UAAK;AAAA,UAAG;AAAA,UAAI;AAAA,UAAI;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAI;AAAA,UAAI;AAAA,UAAK;AAAA,UAAI;AAAA,UAAG;AAAA,UAAG;AAAA,UAAI;AAAA,UAAG;AAAA,UACnE;AAAA,UAAG;AAAA,UAAI;AAAA,UAAK;AAAA,UAAK;AAAA,UAAG;AAAA,UAAI;AAAA,UAAI;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAI;AAAA,UAAI;AAAA,UAAK;AAAA,UAAI;AAAA,UAAG;AAAA,UAAG;AAAA,UAAI;AAAA,QAClE,CAAC,CAAC;AAAA,MACJ,SAAS,GAAG;AACV,eAAO;AAAA,MACT;AAAA,IACF;AAEA,IAAM,kBAAkB,MAAe;AACrC,UAAI;AAeF,eAAO,YAAY,SAAS,IAAI,WAAW;AAAA,UACzC;AAAA,UAAK;AAAA,UAAI;AAAA,UAAK;AAAA,UAAK;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAI;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAI;AAAA,UAAI;AAAA,UAAK;AAAA,UAAK;AAAA,UAAG;AAAA,UAAI;AAAA,UACvF;AAAA,UAAK;AAAA,UAAI;AAAA,UAAK;AAAA,UAAK;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAI;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAG;AAAA,UAAI;AAAA,UAAI;AAAA,UAAK;AAAA,UAAK;AAAA,UAAG;AAAA,UAAI;AAAA,QACzF,CAAC,CAAC;AAAA,MACJ,SAAS,GAAG;AACV,eAAO;AAAA,MACT;AAAA,IACF;AAEA,IAAM,kBAAkB,CAAC,SAAkB,eAAwB;AACjE,UAAI,SAAS;AACX,YAAI,OAA8B;AAChC,iBAAO;AAAA,QACT;AACA,eAAO,aAAa,gCAAgC;AAAA,MACtD,OAAO;AACL,eAAO,aAAa,2BAA2B;AAAA,MACjD;AAAA,IACF;AAEO,IAAM,wBAAwB,OAAM,UAA+C;AACxF,UAAI,aAAa;AACf,eAAO,QAAQ,QAAQ;AAAA,MACzB;AACA,UAAI,cAAc;AAChB,cAAM,IAAI,MAAM,uDAAyD;AAAA,MAC3E;AACA,UAAI,SAAS;AACX,cAAM,IAAI,MAAM,oDAAsD;AAAA,MACxE;AAEA,qBAAe;AAGf,YAAM,UAAU,MAAM;AACtB,YAAM,aAAa,MAAM;AACzB,YAAM,OAAO,MAAM;AAEnB,YAAM,aAAa,uBAAuB,UAAU;AACpD,YAAM,UAAU,QAAQ,gBAAgB;AAExC,YAAM,YAAY,MAAM;AACxB,YAAM,qBAAqB,OAAO,cAAc,WAAW,YAAY;AACvE,YAAM,eAAe,gBAAgB,SAAS,UAAU;AACxD,YAAM,mBAAmB,OAAO,cAAc,WAAW,UAAU,YAAY,IAAI;AAEnF,UAAI,YAAY;AAEhB,YAAM,QAA8B,CAAC;AAGrC,UAAI,UAAU,GAAG;AACf,cAAM,KAAK,IAAI,QAAQ,CAAC,YAAY;AAClC,qBAAW,MAAM;AACf,wBAAY;AACZ,oBAAQ;AAAA,UACV,GAAG,OAAO;AAAA,QACZ,CAAC,CAAC;AAAA,MACJ;AAGA,YAAM,KAAK,IAAI,QAAQ,CAAC,SAAS,WAAW;AAC1C,cAAM,UAAU,aAAa,yBAAyB;AACtD,cAAM,SAAiC;AAAA,UACrC,YAAY,CAAC,UAAkB,oBAA4B;AACzD,gBAAuC,cAAc,SAAS,SAAS,YAAY,KAC/E,OAAO,SAAS,aAAa;AAC/B,qBAAO,IAAI,gBAAgB,IAAI;AAAA,gBAC3B;AAAA;AAAA;AAAA,kBAGE;AAAA,gBACF;AAAA,gBACA,EAAC,MAAM,kBAAiB;AAAA,cAAC,CAAC;AAAA,YAChC;AAEA,gBAAI,SAAS,SAAS,OAAO,GAAG;AAC9B,kBAAI,kBAAkB;AACpB,uBAAO;AAAA,cACT;AAEA,oBAAM,SAAS,sBAAsB;AAErC,kBAAI,MAA4B;AAC9B,oBAAI,iBAAiB,sBAAsB;AACzC,yBAAO,SAAS;AAAA,gBAClB,WAAW,iBAAiB,+BAA+B;AACzD,yBAAO,SAAS;AAAA,gBAClB;AAAA,cACF;AAEA,qBAAO,SAAS;AAAA,YAClB;AAEA,mBAAO,kBAAkB;AAAA,UAC3B;AAAA,QACF;AAEA,YAAuC,YAAY;AACjD,iBAAO,aAAa;AACpB,cAAI,OAAO,SAAS,aAAa;AAC/B,mBAAO,sBAA2B,KAAK,WAAW,sBAAsB;AAAA,UAC1E,OAAO;AACL,kBAAM,mBAAmB,uBAAuB,QAAQ,SAAS,CAAC;AAClE,mBAAO,sBAAsB,IAAI,KAAK,CAAC,gBAAgB,GAAG,EAAC,MAAM,kBAAiB,CAAC;AAAA,UACrF;AAAA,QACF;AAEA,gBAAQ,MAAM,EAAE;AAAA;AAAA,UAEZ,YAAU;AACR,2BAAe;AACf,0BAAc;AACd,mBAAO;AACP,oBAAQ;AAAA,UACV;AAAA;AAAA,UAEA,CAAC,SAAS;AACR,2BAAe;AACf,sBAAU;AACV,mBAAO,IAAI;AAAA,UACb;AAAA,QAAC;AAAA,MACP,CAAC,CAAC;AAEF,YAAM,QAAQ,KAAK,KAAK;AAExB,UAAI,WAAW;AACb,cAAM,IAAI,MAAM,2DAA2D,OAAO,IAAI;AAAA,MACxF;AAAA,IACF;AAEO,IAAM,cAAc,MAAqB;AAC9C,UAAI,eAAe,MAAM;AACvB,eAAO;AAAA,MACT;AAEA,YAAM,IAAI,MAAM,qCAAqC;AAAA,IACvD;AAAA;AAAA;;;ACpOA,IAKa,iBAeA,qBA6BA;AAjDb;AAAA;AAAA;AAGA;AAEO,IAAM,kBAAkB,CAAC,MAAc,WAA6B;AACzE,YAAMC,QAAO,YAAY;AAEzB,YAAM,aAAaA,MAAK,gBAAgB,IAAI,IAAI;AAChD,YAAM,aAAaA,MAAK,QAAQ,UAAU;AAC1C,MAAAA,MAAK,aAAa,MAAM,YAAY,UAAU;AAC9C,aAAO,KAAK,UAAU;AAEtB,aAAO;AAAA,IACT;AAMO,IAAM,sBACT,CAAC,SAAkC,QAAgB,MAClD,YAAuC;AACtC,UAAI,OAAO,WAAW,YAAY,YAAY,MAAM;AAClD,YAAI,KAAK,IAAI,OAAO,GAAG;AACrB,gBAAM,IAAI,MAAM,+BAA+B;AAAA,QACjD,OAAO;AACL,eAAK,IAAI,OAAO;AAAA,QAClB;AAAA,MACF;AAEA,aAAO,QAAQ,OAAO,EAAE,QAAQ,CAAC,CAAC,KAAK,KAAK,MAAM;AAChD,cAAM,OAAQ,SAAU,SAAS,MAAM;AACvC,YAAI,OAAO,UAAU,UAAU;AAC7B,8BAAoB,OAAkC,OAAO,KAAK,MAAM,OAAO;AAAA,QACjF,WAAW,OAAO,UAAU,YAAY,OAAO,UAAU,UAAU;AACjE,kBAAQ,MAAM,MAAM,SAAS,CAAC;AAAA,QAChC,WAAW,OAAO,UAAU,WAAW;AACrC,kBAAQ,MAAO,QAAS,MAAM,GAAG;AAAA,QACnC,OAAO;AACL,gBAAM,IAAI,MAAM,mCAAmC,OAAO,KAAK,EAAE;AAAA,QACnE;AAAA,MACF,CAAC;AAAA,IACH;AAMG,IAAM,iBAAiB,CAAC,YAA0B;AACvD,YAAMA,QAAO,YAAY;AAEzB,YAAM,QAAQA,MAAK,UAAU;AAC7B,UAAI;AACF,cAAM,eAAeA,MAAK,WAAW,CAAC;AACtC,QAAAA,MAAK,iBAAiB,cAAc,eAAe,CAAC;AACpD,cAAM,YAAYA,MAAK,OAAO,eAAe,CAAC;AAC9C,cAAM,sBAAsBA,MAAK,QAAQ,eAAe,IAAI,CAAC;AAC7D,cAAM,eAAe,sBAAsBA,MAAK,aAAa,mBAAmB,IAAI;AACpF,cAAM,IAAI,MAAM,GAAG,OAAO,gBAAgB,SAAS,oBAAoB,YAAY,EAAE;AAAA,MACvF,UAAE;AACA,QAAAA,MAAK,aAAa,KAAK;AAAA,MACzB;AAAA,IACF;AAAA;AAAA;;;AC/DA,IAQa;AARb;AAAA;AAAA;AAKA;AACA;AAEO,IAAM,gBAAgB,CAAC,YAA6D;AACzF,YAAMC,QAAO,YAAY;AACzB,UAAI,mBAAmB;AACvB,YAAM,SAAmB,CAAC;AAE1B,YAAM,aAA0C,WAAW,CAAC;AAE5D,UAAI;AACF,YAAI,SAAS,qBAAqB,QAAW;AAC3C,qBAAW,mBAAmB;AAAA,QAChC,WACI,OAAO,QAAQ,qBAAqB,YAAY,CAAC,OAAO,UAAU,QAAQ,gBAAgB,KAC1F,QAAQ,mBAAmB,KAAK,QAAQ,mBAAmB,GAAG;AAChE,gBAAM,IAAI,MAAM,qCAAqC,QAAQ,gBAAgB,EAAE;AAAA,QACjF;AAEA,YAAI,SAAS,sBAAsB,QAAW;AAC5C,qBAAW,oBAAoB;AAAA,QACjC,WAAW,OAAO,QAAQ,sBAAsB,YAAY,CAAC,OAAO,UAAU,QAAQ,iBAAiB,GAAG;AACxG,gBAAM,IAAI,MAAM,qCAAqC,QAAQ,iBAAiB,EAAE;AAAA,QAClF;AAEA,YAAI,SAAS,cAAc,QAAW;AACpC,qBAAW,YAAY;AAAA,QACzB;AAEA,YAAI,gBAAgB;AACpB,YAAI,SAAS,QAAQ,QAAW;AAC9B,0BAAgB,gBAAgB,QAAQ,KAAK,MAAM;AAAA,QACrD;AAEA,2BAAmBA,MAAK;AAAA,UACpB,WAAW;AAAA,UAAmB,WAAW;AAAA,UAAoB,CAAC,CAAC,WAAW;AAAA,UAAY;AAAA,QAAa;AACvG,YAAI,qBAAqB,GAAG;AAC1B,yBAAe,2BAA4B;AAAA,QAC7C;AAEA,YAAI,SAAS,UAAU,QAAW;AAChC,8BAAoB,QAAQ,OAAO,IAAI,oBAAI,QAAiC,GAAG,CAAC,KAAK,UAAU;AAC7F,kBAAM,gBAAgB,gBAAgB,KAAK,MAAM;AACjD,kBAAM,kBAAkB,gBAAgB,OAAO,MAAM;AAErD,gBAAIA,MAAK,sBAAsB,kBAAkB,eAAe,eAAe,MAAM,GAAG;AACtF,6BAAe,iCAAiC,GAAG,MAAM,KAAK,GAAG;AAAA,YACnE;AAAA,UACF,CAAC;AAAA,QACH;AAEA,eAAO,CAAC,kBAAkB,MAAM;AAAA,MAClC,SAAS,GAAG;AACV,YAAI,qBAAqB,GAAG;AAC1B,UAAAA,MAAK,sBAAsB,gBAAgB;AAAA,QAC7C;AACA,eAAO,QAAQ,WAASA,MAAK,MAAM,KAAK,CAAC;AACzC,cAAM;AAAA,MACR;AAAA,IACF;AAAA;AAAA;;;AChEA,IAQM,0BAeA,kBAWA,sBAoBA,uBA4EO;AAlIb;AAAA;AAAA;AAKA;AACA;AAEA,IAAM,2BAA2B,CAAC,2BAAmD;AACnF,cAAQ,wBAAwB;AAAA,QAC9B,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT;AACE,gBAAM,IAAI,MAAM,yCAAyC,sBAAsB,EAAE;AAAA,MACrF;AAAA,IACF;AAEA,IAAM,mBAAmB,CAAC,kBAAmD;AAC3E,cAAQ,eAAe;AAAA,QACrB,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT;AACE,gBAAM,IAAI,MAAM,+BAA+B,aAAa,EAAE;AAAA,MAClE;AAAA,IACF;AAEA,IAAM,uBAAuB,CAAC,YAAmD;AAC/E,UAAI,CAAC,QAAQ,OAAO;AAClB,gBAAQ,QAAQ,CAAC;AAAA,MACnB;AACA,UAAI,CAAC,QAAQ,MAAM,SAAS;AAC1B,gBAAQ,MAAM,UAAU,CAAC;AAAA,MAC3B;AACA,YAAM,UAAU,QAAQ,MAAM;AAC9B,UAAI,CAAC,QAAQ,8BAA8B;AAEzC,gBAAQ,+BAA+B;AAAA,MACzC;AAGA,UAAI,QAAQ,sBACR,QAAQ,mBAAmB,KAAK,SAAO,OAAO,OAAO,WAAW,KAAK,GAAG,UAAU,QAAQ,GAAG;AAC/F,gBAAQ,mBAAmB;AAAA,MAC7B;AAAA,IACF;AAEA,IAAM,wBACF,CAAC,sBAA8B,oBAC9B,WAA2B;AAC1B,iBAAW,MAAM,oBAAoB;AACnC,YAAI,SAAS,OAAO,OAAO,WAAW,KAAK,GAAG;AAG9C,gBAAQ,QAAQ;AAAA,UACd,KAAK;AACH,qBAAS;AACT,gBAAI,OAAO,OAAO,UAAU;AAC1B,oBAAM,eAAe;AACrB,kBAAI,cAAc,YAAY;AAC5B,sBAAM,gBAAgB,gBAAgB,cAAc,MAAM;AAC1D,sBAAM,kBAAkB,gBAAgB,aAAa,YAAY,MAAM;AACvE,oBAAI,YAAY,EAAE,0BAA0B,sBAAsB,eAAe,eAAe,MAC5F,GAAG;AACL,iCAAe,oDAAoD,aAAa,UAAU,GAAG;AAAA,gBAC/F;AAAA,cACF;AACA,kBAAI,cAAc,YAAY;AAC5B,oBAAI,aAAa,aAAa;AAE9B,oBAAI,OAAO,cAAc,YAAY,CAAC,OAAO,UAAU,UAAU,KAAK,aAAa,GAAG;AACpF,+BAAa;AAAA,gBACf;AACA,sBAAM,gBAAgB,gBAAgB,cAAc,MAAM;AAC1D,sBAAM,kBAAkB,gBAAgB,WAAW,SAAS,GAAG,MAAM;AACrE,oBAAI,YAAY,EAAE,0BAA0B,sBAAsB,eAAe,eAAe,MAC5F,GAAG;AACL,iCAAe,oDAAoD,aAAa,UAAU,GAAG;AAAA,gBAC/F;AAAA,cACF;AACA,kBAAI,cAAc,iBAAiB;AACjC,sBAAM,gBAAgB,gBAAgB,mBAAmB,MAAM;AAC/D,sBAAM,kBAAkB,gBAAgB,aAAa,iBAAiB,MAAM;AAC5E,oBAAI,YAAY,EAAE,0BAA0B,sBAAsB,eAAe,eAAe,MAC5F,GAAG;AACL;AAAA,oBACI,yDAAyD,aAAa,eAAe;AAAA,kBAAG;AAAA,gBAC9F;AAAA,cACF;AAAA,YACF;AACA;AAAA,UACF,KAAK;AACH,qBAAS;AACT,gBAAI,OAAO,OAAO,UAAU;AAC1B,oBAAM,gBAAgB;AACtB,kBAAI,eAAe,iBAAiB;AAClC,oBAAI,cAAc,oBAAoB,UAAU,cAAc,oBAAoB,QAAQ;AACxF,wBAAM,IAAI,MAAM,oDAAoD,cAAc,eAAe,EAAE;AAAA,gBACrG;AACA,sBAAM,gBAAgB,gBAAgB,mBAAmB,MAAM;AAC/D,sBAAM,kBAAkB,gBAAgB,cAAc,iBAAiB,MAAM;AAC7E,oBAAI,YAAY,EAAE,0BAA0B,sBAAsB,eAAe,eAAe,MAC5F,GAAG;AACL;AAAA,oBACI,yDAAyD,cAAc,eAAe;AAAA,kBAAG;AAAA,gBAC/F;AAAA,cACF;AAAA,YACF;AACA;AAAA,UACF,KAAK;AAAA,UACL,KAAK;AACH;AAAA,UACF;AACE,kBAAM,IAAI,MAAM,qCAAqC,MAAM,EAAE;AAAA,QACjE;AAEA,cAAM,mBAAmB,gBAAgB,QAAQ,MAAM;AACvD,YAAI,YAAY,EAAE,4BAA4B,sBAAsB,gBAAgB,MAAM,GAAG;AAC3F,yBAAe,oCAAoC,MAAM,GAAG;AAAA,QAC9D;AAAA,MACF;AAAA,IACF;AAEG,IAAM,oBAAoB,CAAC,YAAkE;AAClG,YAAMC,QAAO,YAAY;AACzB,UAAI,uBAAuB;AAC3B,YAAM,SAAmB,CAAC;AAE1B,YAAM,iBAAkD,WAAW,CAAC;AACpE,2BAAqB,cAAc;AAEnC,UAAI;AACF,cAAM,yBAAyB,yBAAyB,eAAe,0BAA0B,KAAK;AACtG,cAAM,gBAAgB,iBAAiB,eAAe,iBAAiB,YAAY;AACnF,cAAM,kBACF,OAAO,eAAe,UAAU,WAAW,gBAAgB,eAAe,OAAO,MAAM,IAAI;AAE/F,cAAM,mBAAmB,eAAe,oBAAoB;AAC5D,YAAI,CAAC,OAAO,UAAU,gBAAgB,KAAK,mBAAmB,KAAK,mBAAmB,GAAG;AACvF,gBAAM,IAAI,MAAM,qCAAqC,gBAAgB,EAAE;AAAA,QACzE;AAEA,cAAM,oBAAoB,eAAe,qBAAqB;AAC9D,YAAI,CAAC,OAAO,UAAU,iBAAiB,KAAK,oBAAoB,KAAK,oBAAoB,GAAG;AAC1F,gBAAM,IAAI,MAAM,qCAAqC,iBAAiB,EAAE;AAAA,QAC1E;AAEA,cAAM,+BAA+B,OAAO,eAAe,2BAA2B,WAClF,gBAAgB,eAAe,wBAAwB,MAAM,IAC7D;AAEJ,+BAAuBA,MAAK;AAAA,UACxB;AAAA,UAAwB,CAAC,CAAC,eAAe;AAAA,UAAmB,CAAC,CAAC,eAAe;AAAA,UAAkB;AAAA,UAC/F,CAAC,CAAC,eAAe;AAAA,UAAiB;AAAA,UAAG;AAAA,UAAiB;AAAA,UAAkB;AAAA,UACxE;AAAA,QAA4B;AAChC,YAAI,yBAAyB,GAAG;AAC9B,yBAAe,+BAAgC;AAAA,QACjD;AAEA,YAAI,eAAe,oBAAoB;AACrC,gCAAsB,sBAAsB,eAAe,oBAAoB,MAAM;AAAA,QACvF;AAEA,YAAI,eAAe,uBAAuB,QAAW;AACnD,cAAI,OAAO,eAAe,uBAAuB,WAAW;AAC1D,kBAAM,IAAI,MAAM,+CAA+C,eAAe,kBAAkB,EAAE;AAAA,UACpG;AACA,gBAAM,gBAAgB,gBAAgB,sBAAsB,MAAM;AAClE,gBAAM,kBAAkB,gBAAgB,eAAe,mBAAmB,SAAS,GAAG,MAAM;AAC5F,cAAIA,MAAK,0BAA0B,sBAAsB,eAAe,eAAe,MAAM,GAAG;AAC9F;AAAA,cACI,4DAA4D,eAAe,kBAAkB;AAAA,YAAG;AAAA,UACtG;AAAA,QACF;AAEA,YAAI,eAAe,wBAAwB;AACzC,qBAAW,CAAC,MAAM,KAAK,KAAK,OAAO,QAAQ,eAAe,sBAAsB,GAAG;AACjF,gBAAI,OAAO,SAAS,UAAU;AAC5B,oBAAM,IAAI,MAAM,kDAAkD,IAAI,EAAE;AAAA,YAC1E;AACA,gBAAI,OAAO,UAAU,YAAY,CAAC,OAAO,UAAU,KAAK,KAAK,QAAQ,GAAG;AACtE,oBAAM,IAAI,MAAM,iEAAiE,KAAK,EAAE;AAAA,YAC1F;AACA,kBAAM,aAAa,gBAAgB,MAAM,MAAM;AAC/C,gBAAIA,MAAK,6BAA6B,sBAAsB,YAAY,KAAK,MAAM,GAAG;AACpF,6BAAe,wCAAwC,IAAI,MAAM,KAAK,GAAG;AAAA,YAC3E;AAAA,UACF;AAAA,QACF;AAEA,YAAI,eAAe,UAAU,QAAW;AACtC,8BAAoB,eAAe,OAAO,IAAI,oBAAI,QAAiC,GAAG,CAAC,KAAK,UAAU;AACpG,kBAAM,gBAAgB,gBAAgB,KAAK,MAAM;AACjD,kBAAM,kBAAkB,gBAAgB,OAAO,MAAM;AAErD,gBAAIA,MAAK,0BAA0B,sBAAsB,eAAe,eAAe,MAAM,GAAG;AAC9F,6BAAe,qCAAqC,GAAG,MAAM,KAAK,GAAG;AAAA,YACvE;AAAA,UACF,CAAC;AAAA,QACH;AAEA,eAAO,CAAC,sBAAsB,MAAM;AAAA,MACtC,SAAS,GAAG;AACV,YAAI,yBAAyB,GAAG;AAC9B,UAAAA,MAAK,0BAA0B,oBAAoB;AAAA,QACrD;AACA,eAAO,QAAQ,WAASA,MAAK,MAAM,KAAK,CAAC;AACzC,cAAM;AAAA,MACR;AAAA,IACF;AAAA;AAAA;;;ACxNA,IAuCa,4BAqCA,4BAsCA,sBAMA,mCAqCA,sBAoBA,0BAOA;AAxLb;AAAA;AAAA;AAuCO,IAAM,6BAA6B,CAAC,SAA2B;AACpE,cAAQ,MAAM;AAAA,QACZ,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QAET;AACE,gBAAM,IAAI,MAAM,0BAA0B,IAAI,EAAE;AAAA,MACpD;AAAA,IACF;AAKO,IAAM,6BAA6B,CAAC,cAAqC;AAC9E,cAAQ,WAAW;AAAA,QACjB,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QAET;AACE,gBAAM,IAAI,MAAM,0BAA0B,SAAS,EAAE;AAAA,MACzD;AAAA,IACF;AAMO,IAAM,uBAAuB,CAAC,aACpB,CAAC,QAAW,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,QAAW,GAAG,GAAG,GAAG,GAAG,GAAG,QAAW,QAAW,MAAS,EAAE,QAAQ;AAK9G,IAAM,oCAAoC,CAAC,SAEoD;AAChG,cAAQ,MAAM;AAAA,QACZ,KAAK;AAEH,iBAAO,OAAO,iBAAiB,eAAe,aAAa,OAAO,eAAe;AAAA,QACnF,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT;AACE,gBAAM,IAAI,MAAM,qBAAqB,IAAI,EAAE;AAAA,MAC/C;AAAA,IACF;AAKG,IAAM,uBAAuB,CAAC,aAAkE;AACrG,cAAQ,UAAU;AAAA,QAChB,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT;AACE,gBAAM,IAAI,MAAM,8BAA8B,QAAQ,EAAE;AAAA,MAC5D;AAAA,IACF;AAKO,IAAM,2BAA2B,CAAC,SAAyD,SAAS,aACvG,SAAS,aAAa,SAAS,WAAW,SAAS,WAAW,SAAS,YAAY,SAAS,WAC5F,SAAS;AAKN,IAAM,2BAA2B,CAAC,aAA0C;AACjF,cAAQ,UAAU;AAAA,QAChB,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT;AACE,gBAAM,IAAI,MAAM,8BAA8B,QAAQ,EAAE;AAAA,MAC5D;AAAA,IACF;AAAA;AAAA;;;ACvMA,IAAaC;AAAb;AAAA;AAAO,IAAMA,YAAW;AAAA;AAAA;;;ACAxB,IAYa;AAZb;AAAA;AAAA;AAGA;AACA;AAQO,IAAM,WAAW,OAAM,SAAsE;AAClG,UAAI,OAAO,SAAS,UAAU;AAC5B,YAAI,OAAO,YAAY,eAAe,QAAQ,YAAY,QAAQ,SAAS,MAAM;AAE/E,cAAI;AACF,mBAAO,IAAI,WAAW,MAAMC,UAAS,IAAI,CAAC;AAAA,UAC5C,SAAS,GAAG;AACV,gBAAI,EAAE,SAAS,yBAAyB;AAEtC,oBAAM,SAAY,iBAAiB,IAAI;AACvC,oBAAM,SAAuB,CAAC;AAC9B,+BAAiB,SAAS,QAAQ;AAChC,uBAAO,KAAK,KAAK;AAAA,cACnB;AACA,qBAAO,IAAI,WAAW,OAAO,OAAO,MAAM,CAAC;AAAA,YAC7C;AACA,kBAAM;AAAA,UACR;AAAA,QACF,OAAO;AAEL,gBAAM,WAAW,MAAM,MAAM,IAAI;AACjC,cAAI,CAAC,SAAS,IAAI;AAChB,kBAAM,IAAI,MAAM,sCAAsC,IAAI,EAAE;AAAA,UAC9D;AACA,gBAAM,sBAAsB,SAAS,QAAQ,IAAI,gBAAgB;AACjE,gBAAM,WAAW,sBAAsB,SAAS,qBAAqB,EAAE,IAAI;AAC3E,cAAI,WAAW,YAAsB;AAGnC,mBAAO,IAAI,WAAW,MAAM,SAAS,YAAY,CAAC;AAAA,UACpD,OAAO;AAEL,gBAAI,CAAC,SAAS,MAAM;AAClB,oBAAM,IAAI,MAAM,sCAAsC,IAAI,qBAAqB;AAAA,YACjF;AACA,kBAAM,SAAS,SAAS,KAAK,UAAU;AAEvC,gBAAI;AACJ,gBAAI;AAEF,uBAAS,IAAI,YAAY,QAAQ;AAAA,YACnC,SAAS,GAAG;AACV,kBAAI,aAAa,YAAY;AAE3B,sBAAM,QAAQ,KAAK,KAAK,WAAW,KAAK;AACxC,yBAAS,IAAI,YAAY,OAAO,EAAC,SAAS,OAAO,SAAS,MAAK,CAAC,EAAE;AAAA,cACpE,OAAO;AACL,sBAAM;AAAA,cACR;AAAA,YACF;AAEA,gBAAI,SAAS;AAEb,mBAAO,MAAM;AACX,oBAAM,EAAC,MAAM,MAAK,IAAI,MAAM,OAAO,KAAK;AACxC,kBAAI,MAAM;AACR;AAAA,cACF;AACA,oBAAM,YAAY,MAAM;AACxB,oBAAM,QAAQ,IAAI,WAAW,QAAQ,QAAQ,SAAS;AACtD,oBAAM,IAAI,KAAK;AACf,wBAAU;AAAA,YACZ;AACA,mBAAO,IAAI,WAAW,QAAQ,GAAG,QAAQ;AAAA,UAC3C;AAAA,QACF;AAAA,MAEF,WAAW,gBAAgB,MAAM;AAC/B,eAAO,IAAI,WAAW,MAAM,KAAK,YAAY,CAAC;AAAA,MAChD,WAAW,gBAAgB,YAAY;AACrC,eAAO;AAAA,MACT,OAAO;AACL,eAAO,IAAI,WAAW,IAAI;AAAA,MAC5B;AAAA,IACF;AAAA;AAAA;;;ACtFA,IAYM,gBAEA,OAKF,gBACA,OAES,iBAQA,KAWA;AAzCb;AAAA;AAAA;AAKA;AAOA,IAAM,iBAAiB,CAAC,KAAK,KAAK,KAAK,KAAK,GAAG;AAE/C,IAAM,QAAQ,CAAC,OAAe,YAA0B;AAEtD,cAAQ,IAAI,IAAI,eAAe,KAAK,CAAC,KAAI,oBAAI,KAAK,GAAE,YAAY,CAAC,IAAI,OAAO,EAAE;AAAA,IAChF;AAKO,IAAM,kBAAkB,CAAC,iBAA2B,WAA0B;AACnF,uBAAiB;AACjB,cAAQ;AAAA,IACV;AAKO,IAAM,MAAM,CAAC,UAAoB,QAAuB;AAC7D,YAAM,eAAe,qBAAqB,QAAQ;AAClD,YAAM,cAAc,qBAAqB,cAAc;AACvD,UAAI,gBAAgB,aAAa;AAC/B,cAAM,cAAc,OAAO,QAAQ,aAAa,IAAI,IAAI,GAAG;AAAA,MAC7D;AAAA,IACF;AAKO,IAAM,YAAwB,IAAI,SAAiC;AACxE,UAAI,OAAO;AACT,YAAI,GAAG,IAAI;AAAA,MACb;AAAA,IACF;AAAA;AAAA;;;AC7CA,IAOa;AAPb;AAAA;AAAA;AAKA;AAEO,IAAM,aAAa,CAAC,YAAyB,SAE5C,KAAK,kCAAkC,IAAI,GAAG,UAAU;AAAA;AAAA;;;ACThE;AAAA;AAAA;AAAA;AAAA;;;ACAA,IA8EM,gBA+BA,WAKA,0BAKA,sBAWF,MACE,oBAYO,iBAkCP,oBAoSO;AArdb;AAAA;AAAA;AAIA;AAEA;AAwEA,IAAM,iBAAsC,oBAAI,IAAI;AAAA,MAClD,CAAC,IAAI,GAAG;AAAA,MACR,CAAC,KAAK,GAAG;AAAA,MACT,CAAC,KAAK,GAAG;AAAA,MACT,CAAC,KAAK,GAAG;AAAA,MACT,CAAC,MAAM,GAAG;AAAA,MACV,CAAC,MAAM,GAAG;AAAA,MACV,CAAC,MAAM,EAAE;AAAA,MACT,CAAC,OAAO,EAAE;AAAA,MACV,CAAC,OAAO,EAAE;AAAA,MACV,CAAC,OAAO,EAAE;AAAA,MACV,CAAC,QAAQ,EAAE;AAAA,MACX,CAAC,QAAQ,EAAE;AAAA,MACX,CAAC,QAAQ,EAAE;AAAA,MACX,CAAC,SAAS,EAAE;AAAA,MACZ,CAAC,SAAS,EAAE;AAAA,MACZ,CAAC,SAAS,EAAE;AAAA,MACZ,CAAC,SAAS,EAAE;AAAA,MACZ,CAAC,UAAU,EAAE;AAAA,MACb,CAAC,UAAU,EAAE;AAAA,MACb,CAAC,UAAU,EAAE;AAAA,MACb,CAAC,UAAU,EAAE;AAAA,MACb,CAAC,UAAU,CAAC;AAAA,MACZ,CAAC,UAAU,CAAC;AAAA;AAAA;AAAA,MAGZ,CAAC,UAAU,CAAC;AAAA,MACZ,CAAC,WAAW,CAAC;AAAA,MACb,CAAC,WAAW,CAAC;AAAA,IACf,CAAC;AAED,IAAM,YAAsB,CAAC;AAK7B,IAAM,2BAA2B,CAAC,SAAiB,KAAK,KAAK,OAAO,EAAE,IAAI;AAK1E,IAAM,uBAAuB,CAAC,SAAiB;AAC7C,eAAS,MAAM,GAAG,MAAM,UAAU,QAAQ,OAAO;AAC/C,cAAM,gBAAgB,UAAU,GAAG;AACnC,YAAI,QAAQ,eAAe;AACzB,iBAAO;AAAA,QACT;AAAA,MACF;AAEA,aAAO,KAAK,KAAK,OAAO,EAAE,IAAI;AAAA,IAChC;AAEA,IAAI,OAAO;AACX,IAAM,qBAAqB,MAAM;AAY1B,IAAM,kBACT,OAAM,SAAwB,WAAsB,cAAsB,oBAC/C;AACrB,YAAM,aAAa,yBAAyB,YAAY;AACxD,YAAM,gBAAgB,QAAQ,OAAO;AAAA;AAAA,QAEjC,EAAC,MAAM,YAAY,OAAO,eAAe,WAAW,eAAe,SAAQ;AAAA,MAAC;AAChF,UAAI;AACF,cAAM,iBAAiB,QAAQ,kBAAkB;AACjD,gBAAQ,eAAe;AACvB,uBAAe;AAAA,UACX;AAAA,UAA+B;AAAA,UAAuB;AAAA,UACtD;AAAA,UAA4B;AAAA;AAAA,QAChC;AACA,gBAAQ,MAAM;AAEd,cAAM,cAAc,SAAS,WAAW,IAAI;AAE5C,cAAM,cAAc,cAAc,eAAe;AACjD,YAAI,iBAAiB;AAEnB,gBAAM,eAAe,gBAAgB;AACrC,uBAAa,IAAI,IAAI,WAAW,aAAa,GAAG,YAAY,CAAC;AAC7D,iBAAO;AAAA,QACT,OAAO;AAGL,iBAAO,IAAI,WAAW,YAAY,MAAM,GAAG,YAAY,CAAC;AAAA,QAC1D;AAAA,MACF,UAAE;AACA,sBAAc,QAAQ;AAAA,MACxB;AAAA,IACF;AAER,IAAM,qBAAN,MAAmD;AAAA,MAqBjD,YAAoB,SAAwB;AAAxB;AAClB,aAAK,eAAe,oBAAI,IAAI;AAC5B,aAAK,cAAc,oBAAI,IAAI;AAC3B,aAAK,qBAAqB,oBAAI,IAAI;AAClC,aAAK,6BAA6B,CAAC;AACnC,aAAK,iBAAiB,CAAC;AACvB,aAAK,kBAAkB,oBAAI,IAAI;AAC/B,aAAK,yBAAyB,oBAAI,IAAI;AAEtC,mBAAW,CAAC,GAAK,KAAK,gBAAgB;AACpC,oBAAU,KAAK,GAAG;AAClB,eAAK,YAAY,IAAI,KAAK,CAAC,CAAC;AAC5B,eAAK,mBAAmB,IAAI,KAAK,CAAC,CAAC;AAAA,QACrC;AAAA,MACF;AAAA,MAEA,OAAO,IAAe,MAAwB;AAC5C,cAAM,iBAAiB,KAAK;AAC5B,cAAM,YAAY,KAAK;AACvB,cAAM,YAAY,KAAK;AACvB,cAAM,OAAO,yBAAyB,SAAS;AAG/C,cAAM,eAAe,KAAK,aAAa,IAAI,EAAE;AAC7C,YAAI,CAAC,cAAc;AACjB,gBAAM,IAAI,MAAM,uCAAuC;AAAA,QACzD;AACA,YAAI,aAAa,iBAAiB,WAAW;AAC3C,gBAAM,IAAI,MAAM,yCAAyC,aAAa,YAAY,eAAe,SAAS,EAAE;AAAA,QAC9G;AAGA,cAAM,wBAAwB,KAAK,QAAQ,OAAO;AAAA;AAAA,UAE9C,EAAC,kBAAkB,MAAM,MAAM,OAAO,eAAe,YAAY,eAAe,SAAQ;AAAA,QAAC;AAG7F,cAAM,cAAc,sBAAsB,eAAe;AACzD,YAAI,WAAW,WAAW,EAAE,IAAI,IAAI,WAAW,gBAAgB,WAAW,SAAS,CAAC;AACpF,8BAAsB,MAAM;AAI5B,cAAM,iBAAiB,KAAK,QAAQ,kBAAkB;AACtD,aAAK,QAAQ,eAAe;AAC5B,uBAAe,mBAAmB,uBAAuB,GAAG,aAAa,QAAQ,QAAQ,GAAG,IAAI;AAEhG,kBAAU,WAAW,MAAM,qCAAqC,EAAE,GAAG;AAErE,aAAK,2BAA2B,KAAK,qBAAqB;AAAA,MAC5D;AAAA,MAEA,OAAO,UAAqB,eAAgC;AAE1D,cAAM,qBAAqB,KAAK,aAAa,IAAI,QAAQ;AACzD,YAAI,CAAC,oBAAoB;AACvB,gBAAM,IAAI,MAAM,2CAA2C;AAAA,QAC7D;AAEA,cAAM,0BAA0B,KAAK,aAAa,IAAI,aAAa;AACnE,YAAI,CAAC,yBAAyB;AAC5B,gBAAM,IAAI,MAAM,gDAAgD;AAAA,QAClE;AACA,YAAI,mBAAmB,iBAAiB,wBAAwB,cAAc;AAC5E,gBAAM,IAAI,MAAM,mDAAmD;AAAA,QACrE;AAEA,cAAM,OAAO,yBAAyB,mBAAmB,YAAY;AAGrE,cAAM,iBAAiB,KAAK,QAAQ,kBAAkB;AACtD,aAAK,QAAQ,eAAe;AAC5B,uBAAe;AAAA,UACX,mBAAmB,QAAQ;AAAA,UAAQ;AAAA,UAAG,wBAAwB,QAAQ;AAAA,UAAQ;AAAA,UAAG;AAAA,QAAI;AAAA,MAC3F;AAAA,MAEA,uBAAuB,QAAmB,cAAsB,gBAAoC;AAClG,YAAI;AACJ,YAAI,gBAAgB;AAClB,eAAK,KAAK,gBAAgB,IAAI,cAAc;AAC5C,cAAI,OAAO,QAAW;AACpB,kBAAM,IAAI,MAAM,mCAAmC;AAAA,UACrD;AACA,cAAI,WAAW,gBAAgB;AAC7B;AAAA,cACI;AAAA,cACA,MAAM,uDAAuD,YAAY,WACrE,EAAE;AAAA,YAA6B;AACvC,mBAAO;AAAA,UACT,WAAW,KAAK,QAAQ,oBAAoB,IAAI,KAAK,QAAQ,gBAAiB,GAAG;AAC/E,kBAAM,IAAI,MAAM;AAAA,sDAC8B;AAAA,UAChD;AACA,eAAK,gBAAgB,OAAO,cAAc;AAAA,QAC5C,OAAO;AACL,eAAK,mBAAmB;AAAA,QAC1B;AAEA,aAAK,aAAa,IAAI,IAAI,EAAC,SAAS,EAAC,IAAI,uBAA2B,OAAM,GAAG,aAAY,CAAC;AAC1F,aAAK,gBAAgB,IAAI,QAAQ,EAAE;AACnC;AAAA,UACI;AAAA,UACA,MAAM,uDAAuD,YAAY,WAAW,EAAE;AAAA,QAAe;AACzG,eAAO;AAAA,MACT;AAAA,MAEA,yBAAyB,QAAyB;AAChD,cAAM,KAAK,KAAK,gBAAgB,IAAI,MAAM;AAC1C,YAAI,OAAO,QAAW;AACpB,eAAK,aAAa,OAAO,EAAE;AAC3B,eAAK,gBAAgB,OAAO,MAAM;AAClC,oBAAU,WAAW,MAAM,4DAA4D,EAAE,EAAE;AAAA,QAC7F;AAAA,MACF;AAAA;AAAA,MAGA,OAAO,MAAc,QAAQ,eAAe,UAAU,eAAe,WAAW,eAAe,UAAmB;AAChH,cAAM,aAAa,qBAAqB,IAAI;AAE5C,YAAI;AAGJ,cAAM,aAAa,QAAQ,eAAe,aAAa,eAAe;AAEtE,cAAM,aAAa,QAAQ,eAAe,aAAa,eAAe;AACtE,YAAI,aAAa,WAAW;AAC1B,gBAAM,cAAc,YAAY,KAAK,cAAc,KAAK;AACxD,gBAAM,UAAU,YAAY,IAAI,UAAU;AAC1C,cAAI,CAAC,SAAS;AAEZ,wBAAY,KAAK,QAAQ,OAAO,aAAa,EAAC,MAAM,YAAY,MAAK,CAAC;AAAA,UACxE,OAAO;AACL,gBAAI,QAAQ,SAAS,GAAG;AAEtB,0BAAY,QAAQ,IAAI;AAAA,YAC1B,OAAO;AAEL,0BAAY,KAAK,QAAQ,OAAO,aAAa,EAAC,MAAM,YAAY,MAAK,CAAC;AAAA,YACxE;AAAA,UACF;AAAA,QACF,OAAO;AAEL,sBAAY,KAAK,QAAQ,OAAO,aAAa,EAAC,MAAM,YAAY,MAAK,CAAC;AAAA,QACxE;AAEA,cAAM,UAAU,EAAC,IAAI,mBAAmB,GAAG,uBAA2B,QAAQ,UAAS;AACvF,aAAK,aAAa,IAAI,QAAQ,IAAI,EAAC,SAAS,cAAc,KAAI,CAAC;AAE/D,kBAAU,WAAW,MAAM,uCAAuC,IAAI,WAAW,QAAQ,EAAE,EAAE;AAC7F,eAAO;AAAA,MACT;AAAA,MAEA,IAAI,IAAkC;AACpC,eAAO,KAAK,aAAa,IAAI,EAAE,GAAG;AAAA,MACpC;AAAA,MAEA,QAAQ,IAAuB;AAC7B,cAAM,aAAa,KAAK,aAAa,IAAI,EAAE;AAC3C,YAAI,CAAC,YAAY;AACf,gBAAM,IAAI,MAAM,+BAA+B;AAAA,QACjD;AAEA,kBAAU,WAAW,MAAM,sCAAsC,EAAE,gBAAgB,WAAW,QAAQ,EAAE,EAAE;AAE1G,aAAK,aAAa,OAAO,EAAE;AAC3B,aAAK,eAAe,KAAK,WAAW,QAAQ,MAAM;AAGlD,eAAO,WAAW;AAAA,MACpB;AAAA,MAEA,MAAM,SAAS,IAAe,iBAAkD;AAC9E,cAAM,aAAa,KAAK,aAAa,IAAI,EAAE;AAC3C,YAAI,CAAC,YAAY;AACf,gBAAM,IAAI,MAAM,qBAAqB;AAAA,QACvC;AACA,cAAM,gBAAgB,KAAK,SAAS,WAAW,QAAQ,QAAQ,WAAW,cAAc,eAAe;AAAA,MACzG;AAAA,MAEA,wBAA8B;AAC5B,mBAAW,UAAU,KAAK,4BAA4B;AAEpD,iBAAO,QAAQ;AAAA,QACjB;AACA,aAAK,6BAA6B,CAAC;AAEnC,YAAI,KAAK,eAAe,WAAW,GAAG;AACpC;AAAA,QACF;AAEA,YAAI,KAAK,QAAQ,kBAAkB,WAAW;AAC5C,qBAAW,UAAU,KAAK,gBAAgB;AACxC,kBAAM,gBAAgB,eAAe,IAAI,OAAO,IAAI;AAGpD,iBAAK,OAAO,QAAQ,eAAe,aAAa,eAAe,SAAS;AAEtE,oBAAM,WAAW,KAAK,YAAY,IAAI,OAAO,IAAI,KAAK,CAAC;AACvD,kBAAI,kBAAkB,UAAa,SAAS,UAAU,eAAe;AACnE,uBAAO,QAAQ;AAAA,cACjB,OAAO;AACL,yBAAS,KAAK,MAAM;AAAA,cACtB;AAAA,YAEF,YAAY,OAAO,QAAQ,eAAe,aAAa,eAAe,SAAS;AAE7E,oBAAM,WAAW,KAAK,mBAAmB,IAAI,OAAO,IAAI,KAAK,CAAC;AAC9D,kBAAI,kBAAkB,UAAa,SAAS,UAAU,eAAe;AACnE,uBAAO,QAAQ;AAAA,cACjB,OAAO;AACL,yBAAS,KAAK,MAAM;AAAA,cACtB;AAAA,YACF,OAAO;AACL,qBAAO,QAAQ;AAAA,YACjB;AAAA,UACF;AACA,eAAK,iBAAiB,CAAC;AAAA,QACzB,OAAO;AAGL,cAAI,kBAAkB,KAAK,uBAAuB,IAAI,KAAK,QAAQ,gBAAiB;AACpF,cAAI,CAAC,iBAAiB;AACpB,8BAAkB,CAAC;AACnB,iBAAK,uBAAuB,IAAI,KAAK,QAAQ,kBAAmB,eAAe;AAAA,UACjF;AACA,qBAAW,UAAU,KAAK,gBAAgB;AACxC,4BAAgB,KAAK,MAAM;AAAA,UAC7B;AACA,eAAK,iBAAiB,CAAC;AAAA,QACzB;AAAA,MACF;AAAA,MAEA,UAAU;AACR,aAAK,YAAY,QAAQ,CAAC,YAAY;AACpC,kBAAQ,QAAQ,YAAU;AACxB,mBAAO,QAAQ;AAAA,UACjB,CAAC;AAAA,QACH,CAAC;AACD,aAAK,mBAAmB,QAAQ,CAAC,YAAY;AAC3C,kBAAQ,QAAQ,YAAU;AACxB,mBAAO,QAAQ;AAAA,UACjB,CAAC;AAAA,QACH,CAAC;AAED,aAAK,aAAa,QAAQ,CAAC,YAAY;AACrC,kBAAQ,QAAQ,OAAO,QAAQ;AAAA,QACjC,CAAC;AAED,aAAK,uBAAuB,QAAQ,CAAC,YAAY;AAC/C,kBAAQ,QAAQ,YAAU;AACxB,mBAAO,QAAQ;AAAA,UACjB,CAAC;AAAA,QACH,CAAC;AACD,aAAK,eAAe,oBAAI,IAAI;AAC5B,aAAK,cAAc,oBAAI,IAAI;AAC3B,aAAK,qBAAqB,oBAAI,IAAI;AAClC,aAAK,yBAAyB,oBAAI,IAAI;AAAA,MACxC;AAAA,MAEA,iBAAiB,WAAmB;AAElC,cAAM,iBAAiB,KAAK,uBAAuB,IAAI,SAAS;AAChE,YAAI,gBAAgB;AAClB,yBAAe,QAAQ,YAAU;AAC/B,mBAAO,QAAQ;AAAA,UACjB,CAAC;AACD,eAAK,uBAAuB,OAAO,SAAS;AAAA,QAC9C;AAAA,MACF;AAAA,IACF;AAEO,IAAM,uBAAuB,IAAI,SACpC,IAAI,mBAAmB,GAAG,IAAI;AAAA;AAAA;;;ACtdlC,IAGM,2BAsBO;AAzBb;AAAA;AAAA;AAGA,IAAM,4BAAN,MAAgC;AAAA,MAC9B,YAAY,WAAoC;AAC9C,eAAO,OAAO,MAAM,SAAS;AAAA,MAC/B;AAAA,MAGA,IAAW,WAAmB;AAC5B,YAAI,CAAC,KAAK,KAAK;AACb,eAAK,MACD,OAAO,oBAAoB,IAAI,EAAE,KAAK,EAAE,IAAI,UAAQ,GAAI,KAAiC,IAAI,CAAC,EAAE,EAAE,KAAK,GAAG;AAAA,QAChH;AACA,eAAO,KAAK;AAAA,MACd;AAAA,IACF;AASO,IAAM,8BAA8B,CAAoC,cAC3E,IAAI,0BAA0B,SAAS;AAAA;AAAA;;;AC1B3C,IAKa,YAaA,eA6EA,WA6IA,cA0MA,UAkDA,UACA;AAzeb;AAAA;AAAA;AAKO,IAAM,aAAN,MAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAOtB,OAAO,gBAAgB,GAAqB,GAAiD;AAC3F,eAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,IAAK,SAAY,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;AAAA,MAClD;AAAA,IACF;AAGO,IAAM,gBAAN,MAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAQzB,OAAO,UAAU,OAA0B,OAA0B,WAAW,OAAoC;AAClH,cAAM,QAAQ,MAAM;AACpB,cAAM,QAAQ,MAAM;AACpB,YAAI,UAAU,GAAG;AACf,iBAAO;AAAA,QACT;AACA,YAAI,UAAU,GAAG;AACf,iBAAO;AAAA,QACT;AACA,cAAM,QAAQ,KAAK,IAAI,MAAM,QAAQ,MAAM,MAAM;AACjD,cAAM,QAAQ,IAAI,MAAc,KAAK;AAGrC,YAAI,UAAU;AACZ,cAAI,QAAQ,KAAK,QAAQ,GAAG;AAC1B,mBAAO;AAAA,UACT;AACA,gBAAM,eACF,WAAW,gBAAgB,CAAC,MAAM,QAAQ,CAAC,GAAG,MAAM,QAAQ,CAAC,CAAC,GAAG,CAAC,MAAM,QAAQ,CAAC,GAAG,MAAM,QAAQ,CAAC,CAAC,CAAC;AACzG,cAAI,iBAAiB,QAAW;AAC9B,mBAAO;AAAA,UACT;AACA,WAAC,MAAM,QAAQ,CAAC,GAAG,MAAM,QAAQ,CAAC,CAAC,IAAI;AAAA,QACzC;AAEA,iBAAS,IAAI,WAAW,IAAI,GAAG,KAAK,OAAO,KAAK;AAC9C,gBAAM,OAAO,QAAQ,IAAI,IAAI,IAAI,MAAM,QAAQ,CAAC;AAChD,gBAAM,OAAO,QAAQ,IAAI,IAAI,IAAI,MAAM,QAAQ,CAAC;AAEhD,cAAI,SAAS,QAAQ,OAAO,KAAK,OAAO,GAAG;AACzC,mBAAO;AAAA,UACT;AACA,gBAAM,MAAM,KAAK,IAAI,MAAM,IAAI;AAC/B,cAAI,QAAQ,MAAM;AAChB,kBAAM,QAAQ,CAAC,IAAI,KAAK,IAAI,MAAM,IAAI;AAAA,UACxC,OAAO;AAEL,gBAAI,MAAM,GAAG;AACX,qBAAO;AAAA,YACT;AACA,kBAAM,QAAQ,CAAC,IAAI;AAAA,UACrB;AAAA,QACF;AAEA,eAAO;AAAA,MACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAOA,OAAO,iBAAiB,OAA0B,YAAwC;AAExF,cAAM,YAAY,MAAM;AACxB,cAAM,YAAY,WAAW;AAC7B,YAAI,YAAY,WAAW;AACzB,iBAAO;AAAA,QACT;AACA,iBAAS,IAAI,GAAG,KAAK,WAAW,KAAK;AACnC,cAAI,MAAM,YAAY,CAAC,MAAM,KAAK,MAAM,YAAY,CAAC,MAAM,WAAW,YAAY,CAAC,GAAG;AACpF,mBAAO;AAAA,UACT;AAAA,QACF;AACA,eAAO;AAAA,MACT;AAAA,IACF;AAGO,IAAM,YAAN,MAAM,WAAU;AAAA;AAAA;AAAA;AAAA,MAIrB,OAAO,KAAK,MAAiC;AAC3C,eAAO,WAAU,0BAA0B,MAAM,GAAG,KAAK,MAAM;AAAA,MACjE;AAAA;AAAA;AAAA;AAAA,MAKA,OAAO,aAAa,MAAyB,OAAO,GAAsB;AACxE,cAAM,OAAO,KAAK;AAClB,YAAI,SAAS,GAAG;AACd,iBAAO,CAAC;AAAA,QACV;AACA,cAAM,UAAU,IAAI,MAAM,IAAI;AAC9B,YAAI,IAAI,OAAO;AACf,eAAO,KAAK,GAAG;AACb,cAAI,KAAK,CAAC,IAAI,SAAS,GAAG;AACxB,oBAAQ,CAAC,IAAI,KAAK,CAAC,IAAI;AACvB;AAAA,UACF;AACA,cAAI,OAAO,KAAK,CAAC,MAAM,GAAG;AACxB,kBAAM,IAAI,MAAM,sBAAsB;AAAA,UACxC;AACA,kBAAQ,CAAC,IAAI;AACb,kBAAQ,KAAK,CAAC;AACd;AAAA,QACF;AACA,aAAK,KAAK,KAAK,GAAG,KAAK;AACrB,kBAAQ,CAAC,IAAI,KAAK,CAAC;AAAA,QACrB;AACA,eAAO;AAAA,MACT;AAAA;AAAA;AAAA;AAAA,MAKA,OAAO,kBAAkB,MAAyB,MAAsB;AACtE,YAAI,OAAO,KAAK,OAAO,KAAK,QAAQ;AAClC,gBAAM,IAAI,MAAM,wBAAwB,IAAI,wCAAwC,KAAK,MAAM,cAAc;AAAA,QAC/G;AACA,eAAO,WAAU,0BAA0B,MAAM,MAAM,KAAK,MAAM;AAAA,MACpE;AAAA;AAAA;AAAA;AAAA,MAKA,OAAO,gBAAgB,MAAyB,MAAsB;AACpE,YAAI,OAAO,KAAK,OAAO,KAAK,QAAQ;AAClC,gBAAM,IAAI,MAAM,wBAAwB,IAAI,sCAAsC,KAAK,MAAM,cAAc;AAAA,QAC7G;AACA,eAAO,WAAU,0BAA0B,MAAM,GAAG,IAAI;AAAA,MAC1D;AAAA;AAAA;AAAA;AAAA,MAKA,OAAO,0BAA0B,MAAyB,OAAe,KAAqB;AAC5F,YAAI,OAAO;AACX,iBAAS,IAAI,OAAO,IAAI,KAAK,KAAK;AAGhC,cAAI,KAAK,CAAC,IAAI,GAAG;AACf,kBAAM,IAAI;AAAA;AAAA,cAEN;AAAA,YAA+G;AAAA,UACrH;AACA,kBAAQ,KAAK,CAAC;AAAA,QAChB;AACA,eAAO;AAAA,MACT;AAAA,MAEA,OAAO,eAAe,MAA4C;AAChE,cAAM,OAAO,KAAK;AAClB,YAAI,SAAS,GAAG;AACd,iBAAO,CAAC;AAAA,QACV,WAAW,SAAS,GAAG;AACrB,iBAAO,CAAC,CAAC;AAAA,QACX;AACA,cAAM,UAAU,IAAI,MAAM,IAAI;AAC9B,gBAAQ,OAAO,CAAC,IAAI;AACpB,gBAAQ,OAAO,CAAC,IAAI,KAAK,OAAO,CAAC;AACjC,iBAAS,IAAI,OAAO,GAAG,KAAK,GAAG,EAAE,GAAG;AAClC,kBAAQ,CAAC,IAAI,QAAQ,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC;AAAA,QAC1C;AACA,eAAO;AAAA,MACT;AAAA;AAAA;AAAA;AAAA,MAKA,OAAO,cAAc,MAAc,YAA4B;AAC7D,YAAI,OAAO,CAAC,cAAc,QAAQ,YAAY;AAC5C,gBAAM,IAAI,MAAM,sCAAsC;AAAA,QACxD;AACA,eAAO,OAAO,IAAI,OAAO,aAAa;AAAA,MACxC;AAAA,MAEA,OAAO,cAAc,MAAyB,YAA+B;AAC3E,eAAO,KAAK,IAAI,OAAK,KAAK,cAAc,GAAG,cAAc,KAAK,MAAM,CAAC;AAAA,MACvE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAQA,OAAO,gBAAgB,GAAsB,MAA6C;AACxF,YAAI,MAAM;AACR,iBAAO,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;AAAA,QAC7B,OAAO;AACL,iBAAO,EAAE,MAAM,EAAE,QAAQ;AAAA,QAC3B;AAAA,MACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAOA,OAAO,SAAS,MAAyBC,MAA2C;AAClF,cAAM,OAAO,KAAK;AAClB,eAAO,KAAK,IAAI,CAAC,GAAG,MAAM,IAAIA,KAAI,CAAC,IAAIA,KAAI,IAAI,IAAI,CAAC;AAAA,MACtD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAOA,OAAO,SAAS,QAA2B,QAAoC;AAC7E,YAAI,OAAO,WAAW,OAAO,QAAQ;AACnC,iBAAO;AAAA,QACT;AACA,eAAO,OAAO,MAAM,CAAC,GAAG,MAAM,MAAM,OAAO,CAAC,CAAC;AAAA,MAC/C;AAAA,IACF;AAEO,IAAM,eAAN,MAAM,cAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAUxB,OAAO,qBACH,kBAA2B,WAA8B,aAAuB,SAChF,WAAqB,MAAsB;AAC7C,YAAI,CAAC,oBAAoB,YAAY,WAAW,UAAU,SAAS,GAAG;AACpE,gBAAM,IAAI,MAAM,oFAAoF;AAAA,QACtG;AAEA,YAAI,kBAAkB;AAEpB,mBAAS,MAAM,GAAG,MAAM,UAAU,SAAS,GAAG,OAAO;AACnD,gBAAI,OAAO,YAAY,QAAQ;AAC7B,0BAAY,KAAK,UAAU,MAAM,CAAC,CAAC;AAAA,YACrC,OAAO;AACL,0BAAY,GAAG,IAAI,UAAU,MAAM,CAAC;AAAA,YACtC;AAAA,UACF;AAAA,QACF;AAGA,iBAAS,MAAM,GAAG,MAAM,YAAY,QAAQ,OAAO;AACjD,cAAI,MAAM,QAAQ,QAAQ;AACxB,gBAAI,QAAQ,GAAG,IAAI,GAAG;AACpB,oBAAM,IAAI,MAAM,8CAA8C;AAAA,YAChE;AAAA,UACF,OAAO;AACL,oBAAQ,KAAK,CAAC;AAAA,UAChB;AAAA,QACF;AAGA,iBAAS,MAAM,GAAG,MAAM,YAAY,QAAQ,OAAO;AACjD,cAAI,MAAM,UAAU,QAAQ;AAC1B,gBAAI,UAAU,GAAG,IAAI,GAAG;AACtB,oBAAM,IAAI,MAAM,gDAAgD;AAAA,YAClE;AAAA,UACF,OAAO;AACL,sBAAU,KAAK,CAAC;AAAA,UAClB;AAAA,QACF;AAGA,iBAAS,MAAM,GAAG,MAAM,YAAY,SAAS,GAAG,OAAO;AACrD,cAAI,MAAM,KAAK,QAAQ;AACrB,gBAAI,KAAK,GAAG,IAAI,GAAG;AACjB,oBAAM,IAAI,MAAM,0CAA0C;AAAA,YAC5D;AAAA,UACF,OAAO;AACL,iBAAK,KAAK,CAAC;AAAA,UACb;AAAA,QACF;AAGA,iBAAS,MAAM,GAAG,MAAM,YAAY,QAAQ,OAAO;AACjD,cAAI,YAAY,GAAG,KAAK,GAAG;AACzB,kBAAM,IAAI,MAAM,yCAAyC;AAAA,UAC3D;AAEA,cAAI,KAAK,GAAG,KAAK,YAAY,GAAG,KAAK,KAAK,MAAM,YAAY,MAAM,KAAK,YAAY,GAAG,GAAG;AACvF,kBAAM,IAAI,MAAM,oCAAoC;AAAA,UACtD;AAAA,QACF;AAAA,MACF;AAAA;AAAA,MAGA,OAAO,yBACH,WAA8B,SAA4B,WAC1D,aAAgC,MAAgB,eAAwB,SAAwB;AAClG,YAAI,CAAC,SAAS;AACZ;AAAA,QACF;AAEA,YAAI,KAAK,WAAW,KAAK,UAAU,SAAS,IAAI;AAC9C,gBAAM,IAAI,MAAM,8DAA8D;AAAA,QAChF;AAEA,YAAI,QAAQ,WAAY,UAAU,SAAS,GAAI;AAC7C,gBAAM,IAAI,MAAM,2DAA2D;AAAA,QAC7E;AAEA,YAAI,YAAY,WAAY,UAAU,SAAS,GAAI;AACjD,gBAAM,IAAI,MAAM,iEAAiE;AAAA,QACnF;AAEA,iBAAS,MAAM,GAAG,MAAM,UAAU,SAAS,GAAG,OAAO;AACnD,wBAAa;AAAA,YACT,UAAU,OAAO,gBAAgB,IAAI,EAAE;AAAA,YAAG,QAAQ,GAAG;AAAA,YAAG,UAAU,GAAG;AAAA,YAAG,YAAY,GAAG;AAAA,YAAG;AAAA,YAAM;AAAA,YAChG,MAAM,UAAU,SAAS;AAAA,YAAG;AAAA,UAAO;AAAA,QACzC;AAAA,MACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAaA,OAAO,uBACH,kBAA2B,WAA8B,SAAmB,WAC5E,aAAuB,MAAgB,SAA4B;AACrE,YAAI,UAAU,UAAU,GAAG;AACzB,gBAAM,IAAI,MAAM,4CAA4C;AAAA,QAC9D;AAGA,cAAM,aAAa,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC,CAAC;AAE9C,sBAAa;AAAA,UACT;AAAA,UAAkB;AAAA,UAAW;AAAA,UAAY;AAAA,UAAS;AAAA,UAAW;AAAA,UAAa;AAAA,UAAM;AAAA,QAAO;AAC3F,eAAO;AAAA,MACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAYA,OAAO,uBACH,WAA8B,YAA+B,SAAmB,WAChF,aAAuB,MAAgB,SAA4B;AACrE,YAAI,UAAU,UAAU,KAAK,WAAW,UAAU,GAAG;AACnD,gBAAM,IAAI,MAAM,yDAAyD;AAAA,QAC3E;AAGA,cAAM,aAAa,CAAC,UAAU,CAAC,GAAG,WAAW,CAAC,CAAC;AAE/C,sBAAa,mBAAmB,OAAO,WAAW,YAAY,SAAS,WAAW,aAAa,MAAM,OAAO;AAC5G,eAAO;AAAA,MACT;AAAA;AAAA;AAAA;AAAA,MAKA,OAAe,mBACX,kBAA2B,WAA8B,YAAsB,SAC/E,WAA8B,aAAgC,MAAgB,SAAkB;AAClG,YAAI,kBAAkB;AACpB,mBAAS,MAAM,GAAG,MAAM,UAAU,SAAS,GAAG,OAAO;AACnD,uBAAW,KAAK,CAAC;AAAA,UACnB;AAAA,QACF,OAAO;AACL,mBAAS,MAAM,GAAG,MAAM,UAAU,SAAS,GAAG,OAAO;AACnD,uBAAW,KAAK,cAAa;AAAA,cACzB,UAAU,MAAM,CAAC;AAAA,cAAG,QAAQ,GAAG;AAAA,cAAG,UAAU,GAAG;AAAA,cAAG,YAAY,GAAG;AAAA,cAAG;AAAA,cAAM;AAAA,cAAK,MAAM,UAAU,SAAS;AAAA,cACxG;AAAA,YAAO,CAAC;AAAA,UACd;AAAA,QACF;AAAA,MACF;AAAA;AAAA;AAAA,MAIA,OAAe,wBACX,QAAgB,QAAgB,UAAkB,QAAgB,MAAgB,cAClF,cAAsB,SAA0B;AAClD,cAAM,UAAU,YAAY,SAAS,KAAK;AAC1C,YAAI,WAAW,YAAY,UAAU;AACnC,kBAAQ,SAAS;AAAA,YACf,KAAK;AACH,mBAAK,YAAY,IAAI;AACrB,mBAAK,YAAY,IAAI;AACrB,qBAAO,KAAK,OAAQ,SAAS,WAAW,SAAU,CAAC;AAAA,YACrD,KAAK;AAAA,YACL,KAAK;AACH,kBAAI,aAAa,GAAG;AAClB,sBAAM,IAAI,MAAM,qDAAqD;AAAA,cACvE,OAAO;AACL,sBAAM,oBAAoB,SAAS,SAAS,KAAK;AACjD,sBAAM,aAAa,mBAAmB,KAAK,SAAS,SAAS;AAC7D,qBAAK,YAAY,IACZ,YAAY,eAAgB,KAAK,OAAO,YAAY,KAAK,CAAC,IAAI,KAAK,MAAM,YAAY,CAAC;AAC3F,qBAAK,YAAY,IAAI,YAAY,KAAK,YAAY;AAClD,uBAAO,KAAK,OAAQ,SAAS,YAAY,UAAU,SAAU,CAAC;AAAA,cAChE;AAAA,YACF;AACE,oBAAM,IAAI,MAAM,0BAA0B;AAAA,UAC9C;AAAA,QACF,OAAO;AACL,iBAAO,KAAK,OAAQ,SAAS,KAAK,YAAY,IAAI,KAAK,YAAY,IAAI,WAAW,SAAU,CAAC;AAAA,QAC/F;AAAA,MACF;AAAA,IACF;AAEO,IAAM,WAAN,MAAe;AAAA;AAAA;AAAA;AAAA,MAIpB,OAAO,qBACH,WAA8B,WAAoB,YAA+B,YACjF,WAAkD;AACpD,YAAI,UAAU,WAAW,KAAK,WAAW,WAAW,GAAG;AACrD,gBAAM,IAAI,MAAM,4BAA4B;AAAA,QAC9C;AAEA,YAAI;AACJ,YAAI;AACJ,YAAI;AAEJ,YAAI,WAAW;AACb,cAAI,UAAU,CAAC;AACf,cAAI,UAAU,CAAC;AAAA,QACjB,OAAO;AACL,cAAI,UAAU,CAAC;AACf,cAAI,UAAU,CAAC;AAAA,QACjB;AAEA,YAAI,OAAO;AAEX,YAAI,YAAY;AACd,cAAI,WAAW,CAAC;AAChB,iBAAO;AAAA,QACT,OAAO;AACL,cAAI,WAAW,CAAC;AAChB,iBAAO;AAAA,QACT;AAEA,YAAI,WAAW,IAAI,MAAM,GAAG;AAC1B,gBAAM,IAAI,MAAM,oBAAoB;AAAA,QACtC;AAEA,YAAI,KAAK,KAAK,KAAK,KAAK,KAAK,GAAG;AAC9B,gBAAM,IAAI,MAAM,yBAAyB;AAAA,QAC3C;AAEA,YAAI,aAAa,CAAC,cAAc,iBAAiB,WAAW,CAAC,GAAG,CAAC,CAAC,GAAG;AACnE,gBAAM,IAAI,MAAM,wCAAwC;AAAA,QAC1D;AAEA,eAAO,CAAC,GAAG,GAAG,CAAC;AAAA,MACjB;AAAA,IACF;AAGO,IAAM,WAAW;AACjB,IAAM,WAAW;AAAA;AAAA;;;ACzexB,IAiBa,gBAsMP,mBAoCO,6BAKA,2BAKA,4BAeA,kBAiBA,YAcA,WAgBA,WAmBA,cA+BP,qBAiTO,eAaA,gBAaA,kBAgFP,kBAwJO,oBAaA;AAr7Bb;AAAA;AAAA;AAGA;AACA;AAaO,IAAM,iBAAiB;AAsM9B,IAAM,oBAAoB,CAAC,MAAc,eAAiD;AACxF,UAAI,eAAe,GAAG;AACpB,cAAM,IAAI,MAAM,mDAAmD;AAAA,MACrE;AAGA,cAAQ,MAAM;AAAA,QACZ;AACE,iBAAO,aAAa,IAAI,MAAM,UAAU,UAAU;AAAA,QACpD;AACE,iBAAO,aAAa,IAAI,MAAM,UAAU,UAAU;AAAA,QACpD;AACE,iBAAO,aAAa,IAAI,MAAM,UAAU,UAAU;AAAA,QACpD;AACE,iBAAO,aAAa,IAAI,MAAM,UAAU,UAAU;AAAA,QACpD;AACE,cAAI,aAAa,GAAG;AAClB,kBAAM,IAAI,MAAM,4CAA4C;AAAA,UAC9D;AACA,iBAAO,CAAC,aAAa,KAAK;AAAA,QAC5B;AACE,cAAI,aAAa,GAAG;AAClB,kBAAM,IAAI,MAAM,4CAA4C;AAAA,UAC9D;AACA,iBAAO,CAAC,aAAa,KAAK;AAAA,QAC5B;AACE,cAAI,eAAe,GAAG;AACpB,kBAAM,IAAI,MAAM,mBAAmB;AAAA,UACrC;AACA,iBAAO,CAAC,OAAO,YAAY;AAAA,QAE7B;AACE,gBAAM,IAAI,MAAM,sBAAsB,IAAI,EAAE;AAAA,MAChD;AAAA,IACF;AAEO,IAAM,8BAA8B,CAAC,MAAgB,aAAsB,MAAM;AACtF,YAAM,aAAa,kBAAkB,MAAM,UAAU;AACrD,aAAO,OAAO,eAAe,WAAW,aAAa,WAAW,CAAC;AAAA,IACnE;AAEO,IAAM,4BAA4B,CAAC,MAAgB,aAAsB,MAAM;AACpF,YAAM,aAAa,kBAAkB,MAAM,UAAU;AACrD,aAAO,OAAO,eAAe,WAAW,aAAa,WAAW,CAAC;AAAA,IACnE;AAEO,IAAM,6BAA6B,IAAI,SAA6D;AACzG,YAAM,kBAAoC,CAAC;AAC3C,WAAK,QAAQ,SAAO;AAClB,YAAI,IAAI,WAAW,GAAG;AACpB,0BAAgB;AAAA,YACZ,EAAC,uBAAuB,MAAM,IAAG;AAAA,YAAG,EAAC,uBAAuB,MAAM,UAAU,eAAe,GAAG,EAAC;AAAA,UAAC;AAAA,QACtG;AAAA,MACF,CAAC;AACD,aAAO;AAAA,IACT;AAMO,IAAM,mBAAmB,CAAC,SAAiB;AAEhD,UAAI,OAAO,MAAM,GAAG;AAClB,eAAO;AAAA,MACT,WAAW,OAAO,MAAM,GAAG;AACzB,eAAO;AAAA,MACT;AAEA,aAAO;AAAA,IACT;AAQO,IAAM,aAAa,CAAC,WAAW,OAAO,YAAqB,QAAQ,QAAQ;AAChF,UAAI,CAAC,cAAc,eAAe,GAAG;AACnC,eAAO,GAAG,QAAQ,IAAI,KAAK;AAAA,MAC7B;AAEA,aAAO,MAAM,UAAU,IAAI,QAAQ,KAAK,KAAK;AAAA,IAC/C;AAQO,IAAM,YAAY,CAAC,UAAkB,YAAoB,UAAkB;AAChF,UAAI,aAAa,OAAO;AACtB,eAAO;AAAA,MACT;AACA,UAAI,eAAe,GAAG;AACpB,eAAO,OAAO,KAAK;AAAA,MACrB;AAEA,aAAO,MAAM,UAAU,SAAS,KAAK;AAAA,IACvC;AAOO,IAAM,YAAY,CAAC,MAAc,eAAuB;AAC7D,UAAI,eAAe,GAAG;AACpB,eAAO,IAAI,IAAI,QAAQ,IAAI,QAAQ,IAAI,QAAQ,IAAI;AAAA,MACrD,WAAW,eAAe,GAAG;AAC3B,eAAO,IAAI,IAAI,QAAQ,IAAI;AAAA,MAC7B,WAAW,eAAe,GAAG;AAC3B,eAAO,IAAI,IAAI,QAAQ,IAAI,QAAQ,IAAI;AAAA,MACzC;AAEA,aAAO;AAAA,IACT;AASO,IAAM,eACT,CAAC,MAAc,OAAsB,QAAgB,SAA0C;AAC7F,UAAI,KAAK,WAAW,WAAW,KAAK,SAAS,GAAG;AAC9C,YAAI,OAAQ,UAAW,UAAU;AAC/B,cAAI,SAAS,OAAO;AAClB,mBAAO,GAAG,IAAI,KAAK,KAAK,WAAW,KAAK,eAAe,KAAK;AAAA,UAC9D,OAAO;AACL,mBAAO,GAAG,IAAI,KAAK,KAAK,WAAW,KAAK;AAAA,UAC1C;AAAA,QACF,OAAO;AACL,cAAI,SAAS,OAAO;AAClB,mBAAO,GAAG,IAAI,IAAI,KAAK,MAAM,QAAQ,CAAC,CAAC,KAAK,KAAK,MAAM,QAAQ,IAAI,CAAC,CAAC,KAAK,QAAQ,IAAI,CAAC;AAAA,UACzF,OAAO;AACL,mBAAO,GAAG,IAAI,IAAI,KAAK,MAAM,QAAQ,CAAC,CAAC,KAAK,QAAQ,CAAC;AAAA,UACvD;AAAA,QACF;AAAA,MACF,OAAO;AACL,eAAO,SAAS,IAAI,GAAG,IAAI,IAAI,KAAK,MAAM;AAAA,MAC5C;AAAA,IACF;AAYJ,IAAM,sBACF,CAAC,MAAc,YAAoB,aAAuC,OACzE,eAAuC;AACtC,YAAM,aAAa,OAAO,gBAAgB;AAC1C,YAAM,OAAO,aAAa,cAAc,YAAY;AACpD,YAAM,eAAe,CAAC,GAAG,IAAI,MAAM,IAAI,EAAE,KAAK,CAAC;AAC/C,YAAM,cAAc,OAAO,IAAI,QAAQ,QAAQ,IAAI,MAAM,IAAI,UAAU,cAAc,IAAI;AACzF,YAAM,aAAa,kBAAkB,YAAY,UAAU;AAC3D,YAAM,YAAY,OAAO,eAAe,WAAW,aAAa,WAAW,CAAC;AAC5E,YAAM,cAAc,OAAO,eAAe,WAAW,aAAa,WAAW,CAAC;AAC9E,YAAM,OAAO,EAAC,SAAS,aAAa,OAAO,WAAW,SAAS,aAAa,QAAQ,WAAU;AAE9F,YAAM,eAAe,CAAC,QAA+B,OAAO,QAAQ,WAAW,MAAM,GAAG,GAAG;AAE3F,YAAM,qBAAqB;AAAA,QACzB,iBAAiB;AAAA,QACjB,iBAAiB;AAAA,QACjB,4BAA4B;AAAA,QAC5B,KAAK;AAAA,QACL,cAAc;AAAA,QACd,KAAK;AAAA,QACL,cAAc;AAAA,MAChB;AAEA,YAAM,gBAAgB,aAAa,cAAc;AACjD,YAAM,QAAQ,GAAG,aAAa,GAAG,IAAI;AACrC,YAAM,UAAU,GAAG,aAAa,GAAG,IAAI;AAEvC,UAAI,aAAa;AACjB,eAAS,IAAI,GAAG,IAAI,OAAO,GAAG,KAAK;AACjC,sBAAc;AAAA,aACT,CAAC,gBAAgB,aAAa,SAAS,GAAG,IAAI,CAAC;AAAA,cAC9C,CAAC,gBAAgB,aAAa,SAAS,GAAG,IAAI,CAAC;AAAA,cAC/C,CAAC,UAAU,CAAC;AAAA,oBACN,CAAC;AAAA;AAAA,MAEf;AACA,oBAAc,WAAW,OAAO,CAAC;AAEjC,YAAM,gCAAgC,OAAO,IAAI,KAAK;AAAA,WACjD,IAAI,oBAAoB,KAAK,OAAO;AAAA,mBAC5B,KAAK,OAAO;AAAA;AAAA,MAEzB,UAAU;AAAA;AAAA;AAIV,YAAM,kBAAkB,CAAC,cAAsB;AAC7C,2BAAmB,kBAAkB;AACrC,eAAO,OAAO,IAAI,YAAY,OAAO,IAAI,IAAI,SAAS;AAAA,MACxD;AAEA,YAAM,UAAoB,CAAC;AAC3B,UAAI,QAAQ,GAAG;AACb,iBAAS,IAAI,OAAO,GAAG,KAAK,GAAG,KAAK;AAClC,kBAAQ,KAAK,GAAG,aAAa,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI;AAAA,QACpE;AAAA,MACF;AAEA,YAAM,gCAAgC,OAAO,IAAI,KAAK;AAAA,WACjD,IAAI,aAAa,KAAK,OAAO;AAAA,aAC3B,QAAQ,KAAK,GAAG,CAAC;AAAA;AAGxB,YAAM,kBAAkB,CAAC,eAAuB;AAC9C,2BAAmB,kBAAkB;AACrC,eAAO,OAAO,IAAI,aAAa,OAAO,IAAI,IAAI,UAAU;AAAA,MAC1D;AAEA,YAAM,UAAU,IAAIC,UAChB,SAAS,IAAI,OAAO,GAAG,KAAK,OAAO,IAAIA,MAAK,IAAI,YAAY,EAAE,KAAK,GAAG,CAAC;AAE3E,YAAM,aAAa,CAAC,YAAoB,QAAuB;AAC7D,YAAI,OAAO,GAAG;AACZ,iBAAO,GAAG,UAAU;AAAA,QACtB,OAAO;AACL,iBAAO,GAAG,aAAa,YAAY,KAAK,IAAI,CAAC;AAAA,QAC/C;AAAA,MACF;AAEA,YAAM,aAAa,CAAC,YAAoB,KAAoB,UAAkB;AAC5E,YAAI,OAAO,GAAG;AACZ,iBAAO,GAAG,UAAU,IAAI,KAAK;AAAA,QAC/B,OAAO;AACL,iBAAO,GAAG,aAAa,YAAY,KAAK,IAAI,CAAC,IAAI,KAAK;AAAA,QACxD;AAAA,MACF;AAEA,YAAM,2CAAoE,CAAC;AAC3E,YAAM,6BAA6B,CAAC,YAAoB,WAA0B;AAChF,2BAAmB,6BAA6B;AAChD,cAAM,UAAU,GAAG,OAAO,IAAI,uBAAuB,IAAI;AACzD,YAAI,WAAW,0CAA0C;AACvD,iBAAO,GAAG,OAAO,IAAI,UAAU;AAAA,QACjC;AACA,cAAMC,WAAU,CAAC;AACjB,iBAAS,IAAI,OAAO,GAAG,KAAK,GAAG,KAAK;AAClC,gBAAM,MAAM,OAAO,WAAW,iBAAiB,IAAI,OAAO,OAAO,IAAI;AACrE,UAAAA,SAAQ,KAAK,GAAG,WAAW,SAAS,CAAC,CAAC,OAAO,GAAG,MAAM,WAAW,OAAO,CAAC,CAAC,GAAG;AAAA,QAC/E;AACA,iDAAyC,OAAO,IAC5C,MAAM,OAAO,mBAAmB,OAAO,KAAK,OAAO;AAAA,sBACzCA,SAAQ,SAAS,IAAIA,SAAQ,KAAK,GAAG,IAAI,IAAI;AAAA;AAG3D,eAAO,GAAG,OAAO,IAAI,UAAU;AAAA,MACjC;AAEA,YAAM,cAAc,CAAC,QAAuB,WAAmB,MAAM;AACnE,YAAI,KAAK,YAAY,KAAK,OAAO;AAC/B,iBAAO,GAAG,IAAI,IAAI,MAAM,KAAK,KAAK;AAAA,QACpC,WAAW,KAAK,YAAY,eAAe,KAAK,UAAU,OAAO;AAE/D,iBAAO,GAAG,IAAI,IAAI,MAAM,mBAAmB,KAAK,8BAA8B,KAAK;AAAA,QACrF,WAAW,KAAK,YAAY,eAAe,KAAK,UAAU,OAAO;AAE/D,iBAAO,GAAG,IAAI,IAAI,MAAM,mBAAmB,KAAK;AAAA,QAClD,WAAW,KAAK,YAAY,SAAS,KAAK,UAAU,cAAc;AAEhE,iBAAO,GAAG,IAAI,IAAI,MAAM,8DAA8D,KAAK;AAAA,QAC7F,OAAO;AACL,gBAAM,IAAI,MAAM,6CAA6C,KAAK,OAAO,mBAAmB,KAAK,KAAK,MAAM;AAAA,QAC9G;AAAA,MACF,GAAG;AAEH,YAAM,cAAc,CAAC,YAA2B,MAAM;AACpD,YAAI,KAAK,YAAY,KAAK,OAAO;AAC/B,iBAAO,GAAG,IAAI,IAAI,MAAM;AAAA,QAC1B,WAAW,KAAK,YAAY,eAAe,KAAK,UAAU,OAAO;AAE/D,iBAAO,OAAO,IAAI,IAAI,MAAM;AAAA,QAC9B,WAAW,KAAK,YAAY,eAAe,KAAK,UAAU,OAAO;AAE/D,iBAAO,OAAO,IAAI,IAAI,MAAM;AAAA,QAC9B,WAAW,KAAK,YAAY,SAAS,KAAK,UAAU,cAAc;AAEhE,iBAAO,mBAAmB,IAAI,IAAI,MAAM,oBAAoB,IAAI,IAAI,MAAM,sBAAsB,IAAI,IAChG,MAAM,wBAAwB,IAAI,IAAI,MAAM;AAAA,QAClD,OAAO;AACL,gBAAM,IAAI,MAAM,6CAA6C,KAAK,OAAO,mBAAmB,KAAK,KAAK,MAAM;AAAA,QAC9G;AAAA,MACF,GAAG;AAEH,YAAM,6BAA6B,OAAO,IAAI,KAAK;AAAA,WAC9C,IAAI,sBAAsB,KAAK,OAAO,QAAQ,SAAS;AAAA,aACrD,YAAY,OAAO,IAAI,WAAW,CAAC;AAAA;AAG1C,YAAM,oBAAoB,OAAO,IAAI,MAAM,MAAM;AAC/C,cAAM,iBAAiB,aAAa,IAAI,OAAK,IAAI,CAAC,OAAO,EAAE,KAAK,IAAI;AACpE,cAAM,aAAa,aAAa,IAAI,OAAK,IAAI,CAAC,EAAE,EAAE,KAAK,IAAI;AAC3D,eAAO;AAAA,WACJ,IAAI,IAAI,cAAc,QAAQ,SAAS;AAAA,iBACjC,IAAI,aAAa,QAAQ,UAAU,CAAC;AAAA;AAAA,MAE/C,GAAG;AAEH,YAAM,MAAM,IAAIC,aAA0C;AACxD,YAAIA,SAAQ,WAAW,MAAM;AAC3B,gBAAM,IAAI,MAAM,0BAA0B,IAAI,EAAE;AAAA,QAClD;AAEA,cAAM,oBAAoBA,SAAQ,IAAI,YAAY,EAAE,KAAK,GAAG;AAE5D,YAAI,SAAS,GAAG;AACd,iBAAO,YAAY,IAAI;AAAA,QACzB,WAAW,SAAS,GAAG;AACrB,iBAAO,YAAY,kBAAkB,CAAC,CAAC;AAAA,QACzC,OAAO;AACL,6BAAmB,MAAM;AACzB,6BAAmB,eAAe;AAClC,6BAAmB,kBAAkB;AACrC,iBAAO,OAAO,IAAI,IAAI,iBAAiB;AAAA,QACzC;AAAA,MACF;AAEA,YAAM,eAAe,CAAC,eAAuB;AAC3C,YAAI,OAAO,GAAG;AACZ,iBAAO,YAAY,UAAU;AAAA,QAC/B,OAAO;AACL,6BAAmB,eAAe;AAClC,6BAAmB,kBAAkB;AACrC,iBAAO,OAAO,IAAI,aAAa,UAAU;AAAA,QAC3C;AAAA,MACF;AAEA,YAAM,6BAA6B,OAAO,IAAI,KAAK;AAAA,WAC9C,IAAI,sBAAsB,KAAK,OAAO,YAAY,SAAS;AAAA,MAChE,YAAY,OAAO,IAAI,aAAa,OAAO,CAAC;AAAA;AAG5C,YAAM,oBAAoB,OAAO,IAAI,MAAM,MAAM;AAC/C,cAAM,iBAAiB,aAAa,IAAI,OAAK,IAAI,CAAC,OAAO,EAAE,KAAK,IAAI;AACpE,cAAM,aAAa,aAAa,IAAI,OAAK,IAAI,CAAC,EAAE,EAAE,KAAK,IAAI;AAC3D,eAAO;AAAA,WACJ,IAAI,IAAI,cAAc,YAAY,SAAS;AAAA,UAC5C,IAAI,aAAa,QAAQ,UAAU,CAAC;AAAA;AAAA,MAExC,GAAG;AAEH,YAAM,MAAM,IAAI,oBAAkD;AAChE,YAAI,gBAAgB,WAAW,OAAO,GAAG;AACvC,gBAAM,IAAI,MAAM,0BAA0B,IAAI,EAAE;AAAA,QAClD;AACA,cAAM,QAAQ,gBAAgB,IAAI;AAClC,YAAI,OAAO,UAAU,UAAU;AAC7B,gBAAM,IAAI,MAAM,sBAAsB;AAAA,QACxC;AAEA,cAAM,oBAAoB,gBAAgB,MAAM,GAAG,IAAI,EAAE,IAAI,YAAY,EAAE,KAAK,GAAG;AAEnF,YAAI,SAAS,GAAG;AACd,iBAAO,YAAY,MAAM,KAAK;AAAA,QAChC,WAAW,SAAS,GAAG;AACrB,iBAAO,YAAY,kBAAkB,CAAC,GAAG,KAAK;AAAA,QAChD,OAAO;AACL,6BAAmB,MAAM;AACzB,6BAAmB,eAAe;AAClC,6BAAmB,kBAAkB;AACrC,iBAAO,OAAO,IAAI,IAAI,iBAAiB,KAAK,KAAK;AAAA,QACnD;AAAA,MACF;AAEA,YAAM,eAAe,CAAC,YAAoB,UAAkB;AAC1D,YAAI,OAAO,GAAG;AACZ,iBAAO,YAAY,YAAY,KAAK;AAAA,QACtC,OAAO;AACL,6BAAmB,eAAe;AAClC,6BAAmB,kBAAkB;AACrC,iBAAO,OAAO,IAAI,aAAa,UAAU,KAAK,KAAK;AAAA,QACrD;AAAA,MACF;AAEA,YAAM,OAAO,MAAM;AACjB,cAAM,QAAQ,CAAC;AACf,YAAI,mBAAmB;AACvB,YAAI,mBAAmB,iBAAiB;AACtC,gBAAM,KAAK,6BAA6B;AACxC,6BAAmB;AAAA,QACrB;AACA,YAAI,mBAAmB,iBAAiB;AACtC,gBAAM,KAAK,6BAA6B;AACxC,6BAAmB;AAAA,QACrB;AACA,YAAI,mBAAmB,4BAA4B;AACjD,iBAAO,OAAO,wCAAwC,EAAE,QAAQ,CAAAC,UAAQ,MAAM,KAAKA,KAAI,CAAC;AACxF,6BAAmB;AAAA,QACrB;AACA,YAAI,mBAAmB,KAAK;AAC1B,gBAAM,KAAK,iBAAiB;AAC5B,6BAAmB;AAAA,QACrB;AACA,YAAI,mBAAmB,cAAc;AACnC,gBAAM,KAAK,0BAA0B;AACrC,6BAAmB;AAAA,QACrB;AACA,YAAI,mBAAmB,KAAK;AAC1B,gBAAM,KAAK,iBAAiB;AAC5B,6BAAmB;AAAA,QACrB;AACA,YAAI,mBAAmB,cAAc;AACnC,gBAAM,KAAK,0BAA0B;AACrC,6BAAmB;AAAA,QACrB;AACA,YAAI,CAAC,cAAc,kBAAkB;AACnC,gBAAM;AAAA,YACF,SAAS,KAAK,MAAM,KAAK,OAAO,IAAI,YAAY,KAAK,GAAG,CAAC;AAAA,YACzD,SAAS,OAAO,MAAM,KAAK,OAAO,IAAI,UAAU,eAAe,WAAW,EAAE,KAAK,GAAG,CAAC;AAAA,UAAI;AAAA,QAC/F;AACA,eAAO,MAAM,KAAK,IAAI;AAAA,MACxB;AAEA,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA;AAAA,QAEA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAWG,IAAM,gBACT,CAAC,MAAc,MAAc,aAAuC,aAAsB,MACtF,oBAAoB,MAAM,MAAM,aAAa,SAAS,UAAU;AAWjE,IAAM,iBACT,CAAC,MAAc,MAAc,aAAuC,aAAsB,MACtF,oBAAoB,MAAM,MAAM,aAAa,UAAU,UAAU;AAWlE,IAAM,mBACT,CAAC,MAAc,MAAc,aAAuC,aAAsB,MACtF,oBAAoB,MAAM,MAAM,aAAa,YAAY,UAAU;AA8E3E,IAAM,mBAAN,MAA+C;AAAA,MAC7C,YAAoB,yBAA2D,QAA4B;AAAvF;AAA2D;AAoG/E,aAAQ,oBAAqC,CAAC;AAC9C,aAAQ,YAA6B,CAAC;AACtC,aAAQ,WAA8B,CAAC;AAwBvC,aAAQ,gBAAgB;AAAA,MA9HoF;AAAA,MAE5G,sCAAsC,MAA6B;AAEjE,cAAM,aAAa,OAAO,SAAS,WAAW,GAAG,IAAI,MAAM;AAC3D,eAAO,qBAAqB,UAAU;AAAA,MACxC;AAAA,MAEA,UAAU,gBAAiD,gBAAgB;AACzE,cAAM,iBAAiB,OAAO,kBAAkB,WAAW,gBAAgB,cAAc,CAAC;AAC1F,cAAM,iBAAiB,OAAO,kBAAkB,WAAW,IAAI,cAAc,CAAC;AAC9E,cAAM,iBAAiB,OAAO,kBAAkB,WAAW,IAAI,cAAc,CAAC;AAE9E,YAAI,iBAAiB,KAAK,OAAO,4BAC7B,iBAAiB,KAAK,OAAO,4BAC7B,iBAAiB,KAAK,OAAO,0BAA0B;AACzD,gBAAM,IAAI,MAAM,mBAAmB,cAAc,KAAK,cAAc,KAChE,cAAc,yCAAyC,KAAK,OAAO,wBAAwB,KAC3F,KAAK,OAAO,wBAAwB,KAAK,KAAK,OAAO,wBAAwB,IAAI;AAAA,QACvF;AAEA,YAAI,iBAAiB,iBAAiB,iBAAiB,KAAK,OAAO,mCAAmC;AACpG,gBAAM,IAAI,MAAM,mBAAmB,cAAc,KAAK,cAAc,KAChE,cAAc,+CACd,KAAK,OAAO,iCAAiC,GAAG;AAAA,QACtD;AAEA,cAAM,uBAAuB,KAAK,wBAAwB,CAAC,MAAM,KAAK,KAAK,wBAAwB,CAAC,MAAM;AAC1G,cAAM,YAAY,uBAAuB;AAAA;AAAA,0DAGA;AAAA;AAAA;AAAA;AAAA;AAKzC,cAAM,sBAAsB,uBACxB,8DACA;AAAA,mEAEI,iBAAiB,iBAAiB,cAAc;AAExD,eAAO,4BAA4B,cAAc,KAAK,cAAc,KAAK,cAAc;AAAA,YAC/E,SAAS;AAAA,MACf,mBAAmB;AAAA;AAAA,MAEvB;AAAA,MAEQ,uBAAuB,UAA+B;AAC5D,YAAI,SAAS,SAAS,GAAG;AACvB,cAAI,SAAS,MAAM,WAAW,WAAW,GAAG;AAC1C,iBAAK,SAAS,KAAK,EAAC,MAAM,SAAS,MAAM,QAAQ,aAAa,EAAE,GAAG,MAAM,OAAO,QAAQ,SAAS,KAAI,CAAC;AAAA,UACxG;AACA,cAAI,SAAS,QAAQ,WAAW,WAAW,GAAG;AAC5C,iBAAK,SAAS,KAAK,EAAC,MAAM,SAAS,QAAQ,QAAQ,aAAa,EAAE,GAAG,MAAM,OAAO,QAAQ,SAAS,KAAI,CAAC;AAAA,UAC1G;AAAA,QACF;AAAA,MACF;AAAA,MAEQ,gBAAgB,UAAyB,cAA8B;AAC7E,YAAI,SAAS,UAAU,YAAY;AACjC,gBAAM,IAAI,MAAM,+FAA+F;AAAA,QACjH;AACA,aAAK,UAAU,KAAK,QAAQ;AAC5B,aAAK,uBAAuB,QAAQ;AAEpC,cAAM,SAAS,SAAS,UAAU,UAAU,SAAS;AACrD,cAAM,cAAc,SAAS,KAAK;AAClC,eAAO,sBAAsB,YAAY,kBAAkB,MAAM,KAAK,SAAS,IAAI,WAAW,WAAW;AAAA,MAC3G;AAAA,MAEA,oBAAoB,WAAoC;AACtD,eAAO,UAAU,IAAI,OAAK,KAAK,gBAAgB,GAAG,KAAK,eAAe,CAAC,EAAE,KAAK,IAAI;AAAA,MACpF;AAAA,MAEQ,yBAAyB,UAA+B;AAC9D,YAAI,SAAS,UAAU,YAAY;AACjC,gBAAM,IAAI;AAAA,YACN;AAAA,UAAsG;AAAA,QAC5G;AAEA,aAAK,kBAAkB,KAAK,QAAQ;AACpC,aAAK,uBAAuB,QAAQ;AAAA,MACtC;AAAA,MAEA,6BAA6B,WAA0C;AACrE,kBAAU,QAAQ,OAAK,KAAK,yBAAyB,CAAC,CAAC;AACvD,eAAO;AAAA,MACT;AAAA,MAEA,gBAAgB,MAAc,MAA8B,SAAS,GAAiB;AACpF,aAAK,SAAS,KAAK,EAAC,MAAM,MAAM,OAAM,CAAC;AACvC,eAAO;AAAA,MACT;AAAA,MAEA,iBAAiB,oBAAqD;AACpE,aAAK,WAAW,KAAK,SAAS,OAAO,kBAAkB;AACvD,eAAO;AAAA,MACT;AAAA,MAKQ,qBAA6B;AACnC,YAAI,KAAK,SAAS,WAAW,GAAG;AAC9B,iBAAO;AAAA,QACT;AAEA,cAAM,kBAA4B,CAAC;AACnC,mBAAW,EAAC,MAAM,MAAM,OAAM,KAAK,KAAK,UAAU;AAChD,cAAI,UAAU,SAAS,GAAG;AACxB,gBAAI,SAAS,OAAO;AAClB,8BAAgB,KAAK,cAAc,IAAI,iBAAiB,IAAI,MAAM,KAAK,KAAK,SAAS,CAAC,CAAC,GAAG;AAAA,YAC5F,OAAO;AACL,8BAAgB,KAAK,GAAG,IAAI,eAAe,IAAI,MAAM,KAAK,KAAK,SAAS,CAAC,CAAC,GAAG;AAAA,YAC/E;AAAA,UACF,OAAO;AACL,kBAAM,WAAW,UAAU,QAAQ,WAAW,IAAI,OAAO,MAAM,MAAM,IAAI,IAAI;AAC7E,4BAAgB,KAAK,GAAG,IAAI,IAAI,QAAQ,EAAE;AAAA,UAC5C;AAAA,QACF;AAEA,eAAO;AAAA,0BACe,gBAAgB,KAAK,IAAI,CAAC;AAAA,2BACzB,KAAK,aAAa;AAAA,MAC3C;AAAA;AAAA;AAAA;AAAA,MAMA,IAAI,4BAAoC;AACtC,eAAO,KAAK,mBAAmB,IAAI,KAAK,UAAU,IAAI,OAAK,EAAE,KAAK,CAAC,EAAE,KAAK,IAAI,IAC1E,KAAK,kBAAkB,IAAI,OAAK,EAAE,KAAK,CAAC,EAAE,KAAK,IAAI;AAAA,MACzD;AAAA;AAAA;AAAA;AAAA,MAKA,IAAI,gBAAwD;AAC1D,YAAI,KAAK,SAAS,WAAW,GAAG;AAC9B,iBAAO;AAAA,QACT;AAEA,cAAM,4BAA4B,CAAC,SAC9B;AAAA;AAAA;AAAA;AAAA;AAAA,QACe,EAAE,CAAC,OAAO,OAAO,OAAO,KAAK,EAAE,QAAQ,IAAI,CAAC;AAChE,eAAO,KAAK,SAAS,IAAI,OAAM,CAAC,0BAA0B,EAAE,IAAI,GAAG,EAAE,UAAU,CAAC,CAAE;AAAA,MACpF;AAAA,IACF;AAEO,IAAM,qBAAqB,CAAC,eAAyC,WACxE,IAAI,iBAAiB,eAAe,MAAM;AAYvC,IAAM,mBAAmB,CAAC,SAA4B,aAA0C;AACrG,YAAM,SAAS,QAAQ;AACvB,YAAM,OAAiB,CAAC;AACxB,eAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC/B,cAAM,MAAM,SAAS,IAAI;AACzB,cAAM,IAAI,QAAQ,GAAG,KAAK;AAC1B,cAAM,IAAI,SAAS,SAAS,SAAS,IAAI,CAAC,KAAK;AAC/C,YAAI,IAAI,KAAK,MAAM,GAAG;AACpB,eAAK,QAAQ,GAAG;AAAA,QAClB;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAAA;AAAA;;;ACj8BA,IAeM,gBAMA,iBAGA,gBAGA,kBAWO,4BAqCA,WAKA;AAhFb;AAAA;AAAA;AAGA;AAEA;AACA;AAGA;AAMA,IAAM,iBAAiB,CAAC,WAAwC;AAC9D,UAAI,CAAC,UAAU,OAAO,WAAW,GAAG;AAClC,cAAM,IAAI,MAAM,6BAA6B;AAAA,MAC/C;AAAA,IACF;AAEA,IAAM,kBAAkB,CAAC,WAAmB,SACvC,QAAQ,KAAK,WAAW,YAAa,CAAC,GAAI,IAAI,MAAM,SAAS,EAAE,KAAK,CAAE,EAAE,QAAQ,IAAI;AAEzF,IAAM,iBAAiB,CAAC,YAA+B,SACnD,UAAU,gBAAgB,YAAY,gBAAgB,WAAW,QAAQ,IAAI,CAAC;AAElF,IAAM,mBAAmB,CAAC,MAAgB,MAAc,OAAsB,WAAkC;AAC9G,YAAM,cAAc,CAAC;AACrB,kBAAY,KAAK,cAAc,OAAO,KAAK,OAAO,QAAQ,MAAM,KAAK,OAAO;AAAA,aACjE,MAAM,KAAK,OAAO,GAAG;AAChC,eAAS,IAAI,GAAG,IAAI,MAAM,EAAE,GAAG;AAC7B,oBAAY,KAAK,MAAM,WAAW,KAAK,KAAK,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC;AAAA,MAC5D;AACA,kBAAY,KAAK,YAAY;AAC7B,aAAO,YAAY,KAAK,IAAI;AAAA,IAC9B;AAEO,IAAM,6BAA6B,CAAC,aAAyB,aAAoC;AACtG,YAAM,gBAAgB,YAAY;AAClC,YAAM,YAAY,YAAY,KAAK;AACnC,YAAM,OAAO,gBAAgB,WAAW,QAAQ;AAChD,YAAM,cAAc,eAAe,YAAY,MAAM,IAAI;AACzD,YAAM,SAAS,eAAe,UAAU,eAAe,YAAY,MAAM;AACzE,YAAM,QAAQ,cAAc,KAAK,eAAe,SAAS;AAEzD,YAAM,kBAAkB,CAAC,iBAA+B;AAAA,IACtD,aAAa,gBAAgB,eAAe,KAAK,EAAE,iBAAiB,OAAO,MAAM,CAAC;AAAA;AAAA,IAElF,iBAAiB,MAAM,WAAW,OAAO,MAAM,CAAC;AAAA;AAAA,IAEhD,aAAa,UAAU,CAAC;AAAA,MACtB,aAAa,sCAAsC,sBAAsB,CAAC;AAAA;AAAA,oBAE5D,OAAO,gBAAgB,YAAY,CAAC;AAAA;AAAA;AAAA,MAGlD,OAAO,YAAY,cAAc,MAAM,aAAa,UAAU,CAAC,CAAC;AAAA;AAEpE,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,GAAG,QAAQ,IAAI,mBAAmB,CAAC,MAAM,EAAC;AAAA,QAC9D,YAAY,CAAC,WAAW;AACtB,gBAAM,aAAa,UAAU,KAAK,WAAW;AAC7C,iBAAO;AAAA,YACL,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,YAC3D,eAAe,EAAC,GAAG,KAAK;AAAA,cAAK,aAAa;AAAA;AAAA,YAAuB,EAAC;AAAA,YAClE,iBACI,CAAC,EAAC,uBAAuB,MAAM,WAAU,GAAG,GAAG,2BAA2B,OAAO,CAAC,EAAE,MAAM,WAAW,CAAC;AAAA,UAC5G;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEO,IAAM,YAAY,CAAC,SAAyB,eAA0C;AAC3F,qBAAe,QAAQ,MAAM;AAC7B,cAAQ,QAAQ,2BAA2B,QAAQ,OAAO,CAAC,GAAG,WAAW,IAAI,CAAC;AAAA,IAChF;AAEO,IAAM,2BAA2B,CAAC,eACrC,4BAA4B,EAAC,MAAM,WAAW,KAAgB,CAAC;AAAA;AAAA;;;ACjFnE,IAYM,WAaA,iBAaA,kBAaA,oBAYA,kBAQA,2BAYA,sBAcA,sBASA,oBAaO,+BAyEP,cAkCO,kBAIA,gBAIA,gBAIA,uBAIA,iBAIA,iBAIA,kBAIA,iBAIA,uBAIA;AAtQb;AAAA;AAAA;AAGA;AAEA;AAGA;AACA;AACA;AAEA,IAAM,YAAqC;AAAA,MACzC,KAAK;AAAA,MACL,KAAK;AAAA,MACL,MAAM;AAAA,MACN,KAAK;AAAA,MACL,MAAM;AAAA,MACN,WAAW;AAAA,MACX,WAAW;AAAA,MACX,IAAI;AAAA,MACJ,IAAI;AAAA,MACJ,QAAQ;AAAA,IACV;AAEA,IAAM,kBAA2C;AAAA,MAC/C,KAAK;AAAA,MACL,KAAK;AAAA,MACL,MAAM;AAAA,MACN,KAAK;AAAA,MACL,MAAM;AAAA,MACN,WAAW;AAAA,MACX,WAAW;AAAA,MACX,IAAI;AAAA,MACJ,IAAI;AAAA,MACJ,QAAQ;AAAA,IACV;AAEA,IAAM,mBAA4C;AAAA,MAChD,KAAK;AAAA,MACL,KAAK;AAAA,MACL,MAAM;AAAA,MACN,KAAK;AAAA,MACL,MAAM;AAAA,MACN,WAAW;AAAA,MACX,WAAW;AAAA,MACX,IAAI;AAAA,MACJ,IAAI;AAAA,MACJ,QAAQ;AAAA,IACV;AAEA,IAAM,qBAA8C;AAAA,MAClD,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,MAAM;AAAA,MACN,WAAW;AAAA,MACX,WAAW;AAAA,MACX,IAAI;AAAA,MACJ,IAAI;AAAA,MACJ,QAAQ;AAAA,IACV;AAEA,IAAM,mBAAmB,CAAC,cAAsB,SAA2B;AACzE,YAAM,MAAM,CAAC;AACb,eAAS,IAAI,OAAO,cAAc,IAAI,MAAM,EAAE,GAAG;AAC/C,YAAI,KAAK,CAAC;AAAA,MACZ;AACA,aAAO;AAAA,IACT;AAEA,IAAM,4BAA4B,CAAC,OAA0B,SAAkD;AAC7G,YAAM,cAAc,CAAC;AACrB,YAAM,OAAO,MAAM;AACnB,eAAS,MAAM,GAAG,MAAM,MAAM,OAAO;AACnC,YAAI,KAAK,QAAQ,GAAG,MAAM,IAAI;AAC5B,sBAAY,KAAK,MAAM,GAAG,CAAC;AAAA,QAC7B;AAAA,MACF;AACA,YAAM,cAAc,KAAK,IAAI,SAAO,MAAM,GAAG,CAAC;AAC9C,aAAO,CAAC,aAAa,WAAW;AAAA,IAClC;AAEA,IAAM,uBAAuB,CAAC,OAAiB,SAA6B;AAC1E,YAAM,OAAO,MAAM,SAAS,KAAK;AACjC,YAAM,cAAc,CAAC;AACrB,UAAI,WAAW;AACf,eAAS,MAAM,GAAG,MAAM,MAAM,OAAO;AACnC,YAAI,KAAK,QAAQ,GAAG,MAAM,IAAI;AAC5B,sBAAY,KAAK,MAAM,UAAU,CAAC;AAAA,QACpC,OAAO;AACL,sBAAY,KAAK,CAAC;AAAA,QACpB;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAEA,IAAM,uBAAuB,CAAC,MAAgB,SAA0B;AACtE,eAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,EAAE,GAAG;AACpC,YAAI,KAAK,KAAK,SAAS,IAAI,CAAC,MAAM,OAAO,IAAI,GAAG;AAC9C,iBAAO;AAAA,QACT;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAEA,IAAM,qBAAqB,CAAC,MAAgB,SAA2B;AACrE,YAAM,MAAM,CAAC;AACb,UAAI,CAAC,qBAAqB,MAAM,IAAI,GAAG;AACrC,iBAAS,IAAI,GAAG,IAAI,MAAM,EAAE,GAAG;AAC7B,cAAI,KAAK,QAAQ,CAAC,MAAM,IAAI;AAC1B,gBAAI,KAAK,CAAC;AAAA,UACZ;AAAA,QACF;AACA,aAAK,QAAQ,UAAQ,IAAI,KAAK,IAAI,CAAC;AAAA,MACrC;AACA,aAAO;AAAA,IACT;AAEO,IAAM,gCACT,CAAC,MAAc,aAAqC,QAA+B,YAClF,gBAA0B,aAAuB,gBAAuC;AACvF,YAAM,aAAa,OAAO,CAAC,EAAE;AAE7B,YAAM,aAAa,UAAU,KAAK,WAAW;AAC7C,YAAM,aAAa,UAAU,KAAK,WAAW;AAE7C,YAAM,QAAQ,cAAc,MAAM,OAAO,CAAC,EAAE,UAAU,UAAU;AAChE,YAAM,SAAS,eAAe,UAAU,gBAAgB,WAAW;AAEnE,YAAM,gBAAgB;AAEtB,YAAM,sBAAsB;AAAA,oDACkB,aAAa;AAAA;AAG3D,YAAM,kBAAkB,CAAC,iBAA+B;AAAA,UACpD,aAAa,gBAAgB,cAAc,KAAK,EAAE,iBAAiB,OAAO,MAAM,CAAC;AAAA,UACjF,mBAAmB;AAAA;AAAA;AAAA;AAAA,WAIlB,aAAa,UAAU,aAAa,CAAC;AAAA;AAAA,2CAEL,aAAa;AAAA;AAAA;AAAA,gCAGxB,iBAAiB,UAAU,CAAC;AAAA;AAAA,wDAEJ,aAAa;AAAA,iCACpC,MAAM,YAAY,YAAY,CAAC;AAAA,yBACvC,UAAU,UAAU,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,wCAKN,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0BAM3B,gBAAgB,UAAU,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAS3C,OAAO;AAAA,QACH;AAAA,QACA,GACI,eAAe,SAAS,GAAG,OAAO,KAAK,OAAO,2CACtB,GAAG,OAAO,KAAK,OAAO,IAAI,mBAAmB,UAAU,CAAC,GAAG;AAAA,MAAE,CAAC;AAAA;AAAA;AAKlG,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,QACA,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,eAAc,CAAC;AAAA,UACvD,eAAe,EAAC,GAAG,WAAU;AAAA,UAC7B,iBAAiB,CAAC,EAAC,uBAAuB,MAAM,WAAU,CAAC;AAAA,QAC7D;AAAA,MACF;AAAA,IACF;AAEJ,IAAM,eACF,CAAC,SAAyB,MAAc,YACvC,eAAiG;AAChG,YAAM,oBACF,QAAQ,OAAO,WAAW,IAAI,aAAa,iCAAiC,QAAQ,QAAQ,UAAU;AAE1G,UAAI,cAAc,kBAAkB;AACpC,UAAI,YAAY,WAAW,KAAK,CAAC,kBAAkB,mBAAmB;AACpE,sBAAc,QAAQ,OAAO,CAAC,EAAE,KAAK,IAAI,CAAC,MAAM,MAAM,CAAC;AAAA,MACzD;AACA,YAAM,gBAAgB,UAAU,cAAc,aAAa,QAAQ,OAAO,CAAC,EAAE,KAAK,MAAM;AAExF,UAAI,OAAO;AACX,UAAI,QAAQ,QAAQ,OAAO,CAAC;AAC5B,YAAM,eAAe,mBAAmB,MAAM,QAAQ,OAAO,CAAC,EAAE,KAAK,MAAM;AAC3E,UAAI,aAAa,SAAS,GAAG;AAC3B,gBAAQ,QAAQ;AAAA,UACZ,2BAA2B,QAAQ,OAAO,CAAC,GAAG,YAAY;AAAA,UAAG,EAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,CAAC,EAAE,EAAC;AAAA,QAAC,EAAE,CAAC;AAChG,eAAO,iBAAiB,KAAK,QAAQ,MAAM,KAAK,MAAM;AAAA,MACxD;AAEA,YAAM,CAAC,aAAa,WAAW,IAAI,0BAA0B,MAAM,MAAM,IAAI;AAC7E,UAAI,mBAAmB;AACvB,UAAI,kBAAkB,UAAU;AAC9B,2BAAmB,qBAAqB,aAAa,aAAa;AAAA,MACpE;AAEA,cAAQ;AAAA,QACJ;AAAA,UACI;AAAA,UAAM,EAAC,MAAM,kBAAkB,UAAU,mBAAmB,CAAC,MAAM,EAAC;AAAA,UAAG,CAAC,KAAK;AAAA,UAAG;AAAA,UAChF,QAAQ,OAAO,CAAC,EAAE;AAAA,UAAU;AAAA,UAAkB;AAAA,QAAW;AAAA,QAC7D,EAAC,QAAQ,CAAC,KAAK,EAAC;AAAA,MAAC;AAAA,IACvB;AAEG,IAAM,mBAAmB,CAAC,SAAyB,eAAuC;AAC/F,mBAAa,SAAS,oBAAoB,YAAY,MAAM;AAAA,IAC9D;AAEO,IAAM,iBAAiB,CAAC,SAAyB,eAAuC;AAC7F,mBAAa,SAAS,kBAAkB,YAAY,IAAI;AAAA,IAC1D;AAEO,IAAM,iBAAiB,CAAC,SAAyB,eAAuC;AAC7F,mBAAa,SAAS,kBAAkB,YAAY,IAAI;AAAA,IAC1D;AAEO,IAAM,wBAAwB,CAAC,SAAyB,eAAuC;AACpG,mBAAa,SAAS,yBAAyB,YAAY,WAAW;AAAA,IACxE;AAEO,IAAM,kBAAkB,CAAC,SAAyB,eAAuC;AAC9F,mBAAa,SAAS,mBAAmB,YAAY,KAAK;AAAA,IAC5D;AAEO,IAAM,kBAAkB,CAAC,SAAyB,eAAuC;AAC9F,mBAAa,SAAS,mBAAmB,YAAY,KAAK;AAAA,IAC5D;AAEO,IAAM,mBAAmB,CAAC,SAAyB,eAAuC;AAC/F,mBAAa,SAAS,oBAAoB,YAAY,MAAM;AAAA,IAC9D;AAEO,IAAM,kBAAkB,CAAC,SAAyB,eAAuC;AAC9F,mBAAa,SAAS,mBAAmB,YAAY,KAAK;AAAA,IAC5D;AAEO,IAAM,wBAAwB,CAAC,SAAyB,eAAuC;AACpG,mBAAa,SAAS,yBAAyB,YAAY,WAAW;AAAA,IACxE;AAEO,IAAM,qBAAqB,CAAC,SAAyB,eAAuC;AACjG,mBAAa,SAAS,sBAAsB,YAAY,QAAQ;AAAA,IAClE;AAAA;AAAA;;;ACxQA,IAYMC,iBAoBA,MACO,yBA2EA,kCAUP,kBAeA,mBAWA,eAWA,eAWA,sBAWA,gBAoBA,iBAqBA,gBAoBA,iBAWA,gBAWA,sBAWA,sBAsBO,YAQA,UAQA,UAQA,iBAQA,WAQA,WAQA,YAQA,WAQA,iBAQA;AA7Wb;AAAA;AAAA;AAGA;AAEA;AACA;AAGA;AACA;AAEA,IAAMA,kBAAiB,CAAC,WAAwC;AAC9D,UAAI,CAAC,UAAU,OAAO,WAAW,KAAK,OAAO,SAAS,GAAG;AACvD,cAAM,IAAI,MAAM,mCAAmC;AAAA,MACrD;AAEA,UAAI,OAAO,WAAW,KAAK,OAAO,CAAC,EAAE,KAAK,WAAW,GAAG;AACtD,cAAM,IAAI,MAAM,0BAA0B;AAAA,MAC5C;AAAA,IACF;AAYA,IAAM,OAAiB,CAAC,UAAU,CAAC,IAAI,IAAI,eAAe,MAAM,aAAa,eAAe,CAAC,KAAK,EAAE;AAC7F,IAAM,0BACT,CAAC,MAAc,aAAqC,QAA+B,UAClF,WAAqB,gBAA0B,WAAW,OAAO,oBAAoB,UAAuB;AAC3G,YAAM,cAAwB,CAAC;AAC/B,YAAM,aAAa,OAAO,CAAC,EAAE;AAC7B,YAAM,YAAY,WAAW;AAC7B,YAAM,OAAO,UAAU,cAAc,WAAW,SAAS;AACzD,YAAM,kBAAkB,CAAC,qBAAqB,KAAK,WAAW;AAC9D,iBAAW,QAAQ,CAAC,GAAG,MAAM;AAC3B,YAAI,mBAAmB,KAAK,QAAQ,CAAC,KAAK,GAAG;AAC3C,cAAI,UAAU;AACZ,wBAAY,KAAK,CAAC;AAAA,UACpB;AAAA,QACF,OAAO;AACL,sBAAY,KAAK,CAAC;AAAA,QACpB;AAAA,MACF,CAAC;AACD,YAAM,aAAa,YAAY;AAC/B,YAAM,aAAa,UAAU,KAAK,WAAW;AAC7C,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,UAAoB,CAAC;AAE3B,cAAM,QAAQ,cAAc,MAAM,OAAO,CAAC,EAAE,UAAU,SAAS;AAC/D,cAAM,SAAS,eAAe,UAAU,gBAAgB,UAAU;AAClE,cAAM,MAAM,SAAS,OAAO,QAAQ,IAAI;AACxC,YAAIC,aAAY,IAAI,CAAC;AAErB,iBAAS,IAAI,GAAG,IAAI,GAAG,IAAI,WAAW,KAAK;AAEzC,cAAI,mBAAmB,KAAK,QAAQ,CAAC,KAAK,GAAG;AAC3C,gBAAI,UAAU;AACZ;AAAA,YACF;AAEA,YAAAA,aAAY,YAAY,CAAC,eAAe,CAAC,MAAM,WAAW,CAAC,CAAC,MAAM,CAAC;AAAA,oBAC3D,IAAI,CAAC,EAAE,SAAS,YAAY,IAAI,qBAAqB,CAAC,MAAM,EAAE;AAAA,oBAC9D,MAAM,WAAW,iBAAiB,GAAG,IAAI,CAAC,EAAE,CAAC;AAAA,oBAC7CA,UAAS;AAAA;AAAA,UAEnB,OAAO;AACL,oBAAQ,KAAK,GAAG,MAAM,WAAW,iBAAiB,GAAG,OAAO,WAAW,kBAAkB,CAAC,CAAC,CAAC,GAAG;AAC/F;AAAA,UACF;AAAA,QACF;AACA,eAAO;AAAA;AAAA,UAEL,aAAa,gBAAgB,eAAe,KAAK,EAAE,iBAAiB,OAAO,MAAM,CAAC;AAAA;AAAA,UAElF,aAAa,UAAU,CAAC;AAAA,YACtB,aAAa,sCAAsC,sBAAsB,CAAC;AAAA,+BACvD,MAAM,KAAK,OAAO;AAAA,iCAChB,OAAO,gBAAgB,YAAY,CAAC;AAAA;AAAA,YAEzD,QAAQ,KAAK,IAAI,CAAC;AAAA,YAClB,IAAI,CAAC,CAAC;AAAA,YACN,IAAI,CAAC,CAAC;AAAA,YACNA,UAAS;AAAA,YACT,IAAI,CAAC,CAAC;AAAA,YACN,IAAI,WAAW,IAAI,OAAO,YAAY,cAAc,OAAO,IAAI,IAAI,MAAM,CAAC,EAAE,KAAK,IAAI,CAAC;AAAA;AAAA,MAE5F;AAEA,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,QACA,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,eAAc,CAAC;AAAA,UACvD,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa;AAAA;AAAA,UAAuB,EAAC;AAAA,UAClE,iBACI,CAAC,EAAC,uBAAuB,MAAM,WAAU,GAAG,GAAG,2BAA2B,YAAY,WAAW,CAAC;AAAA,QACxG;AAAA,MACF;AAAA,IACF;AAEG,IAAM,mCACT,CAAC,QAA+B,eAAmD;AACjF,YAAM,OAAiB,CAAC;AACxB,UAAI,OAAO,CAAC,EAAE,KAAK,CAAC,IAAI,GAAG;AACzB,eAAO,CAAC,EAAE,iBAAiB,EAAE,QAAQ,OAAK,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC;AAAA,MAChE;AACA,aAAO;AAAA,QACH,EAAC,MAAM,UAAU,WAAW,UAAU,mBAAmB,WAAW,kBAAiB;AAAA,MAAC;AAAA,IAC5F;AAEJ,IAAM,mBACF,CAAC,SAAyB,MAAc,YAA8B,aAA6B;AACjG,YAAM,SAAS,QAAQ;AACvB,YAAM,oBACF,OAAO,WAAW,IAAI,aAAa,iCAAiC,QAAQ,UAAU;AAE1F,cAAQ;AAAA,QACJ;AAAA,UACI;AAAA,UAAM,EAAC,MAAM,kBAAkB,UAAU,mBAAmB,CAAC,MAAM,EAAC;AAAA,UAAG,CAAC,OAAO,CAAC,CAAC;AAAA,UACjF,kBAAkB,qBAAqB,kBAAkB,KAAK,WAAW,IAAI,OAAO;AAAA,UACpF,kBAAkB;AAAA,UAAM,OAAO,CAAC,EAAE;AAAA,UAAU,kBAAkB;AAAA,UAC9D,kBAAkB;AAAA,QAAiB;AAAA,QACvC,EAAC,QAAQ,CAAC,CAAC,EAAC;AAAA,MAAC;AAAA,IACnB;AAEJ,IAAM,oBAAoB,CAAC,SAAyB,eAAuC;AACzF,MAAAD,gBAAe,QAAQ,MAAM;AAC7B,YAAM,WAAqB,CAAC,OAAO,WAC/B;AAAA,QAAC,eAAe,OAAO,KAAK,OAAO;AAAA,QAClC;AAAA,QACA,YAAY,MAAM,aAAa,eAAe,CAAC;AAAA,QAC/C;AAAA,MACL;AACA,uBAAiB,SAAS,gBAAgB,YAAY,QAAQ;AAAA,IAChE;AAEA,IAAM,gBAAgB,CAAC,SAAyB,eAAuC;AACrF,MAAAA,gBAAe,QAAQ,MAAM;AAC7B,YAAM,WAAqB,CAAC,OAAO,WAC/B;AAAA,QAAC,eAAe,OAAO,KAAK,OAAO;AAAA,QAClC;AAAA,QACA,gBAAgB,MAAM,aAAa,eAAe,CAAC;AAAA,QACnD;AAAA,MACL;AACA,uBAAiB,SAAS,YAAY,YAAY,QAAQ;AAAA,IAC5D;AAEA,IAAM,gBAAgB,CAAC,SAAyB,eAAuC;AACrF,MAAAA,gBAAe,QAAQ,MAAM;AAC7B,YAAM,WAAqB,CAAC,OAAO,WAC/B;AAAA,QAAC,WAAW,OAAO,KAAK,KAAK,oBAAoB,OAAO,KAAK,KAAK;AAAA,QACjE;AAAA,QACA,OAAO,MAAM,aAAa,eAAe,CAAC;AAAA,QAC1C;AAAA,MACL;AACA,uBAAiB,SAAS,YAAY,YAAY,QAAQ;AAAA,IAC5D;AAEA,IAAM,uBAAuB,CAAC,SAAyB,eAAuC;AAC5F,MAAAA,gBAAe,QAAQ,MAAM;AAC7B,YAAM,WAAqB,CAAC,OAAO,WAC/B;AAAA,QAAC,eAAe,OAAO,KAAK,OAAO;AAAA,QAClC;AAAA,QACA,gBAAgB,MAAM,aAAa,eAAe,CAAC;AAAA,QACnD;AAAA,MACL;AACA,uBAAiB,SAAS,mBAAmB,YAAY,QAAQ;AAAA,IACnE;AAEA,IAAM,iBAAiB,CAAC,SAAyB,eAAuC;AACtF,MAAAA,gBAAe,QAAQ,MAAM;AAC7B,YAAM,WAAqB,CAAC,OAAO,SAAS,SAAS;AACnD,cAAM,UAAU,CAAC;AACjB,iBAAS,IAAI,GAAG,IAAI,MAAM,MAAM,KAAK;AACnC,cAAI,KAAK,QAAQ,CAAC,KAAK,KAAK,KAAK,WAAW,GAAG;AAC7C,oBAAQ,KAAK,MAAM,WAAW,iBAAiB,GAAG,CAAC,CAAC;AAAA,UACtD;AAAA,QACF;AAEA,eAAO;AAAA,UACL,GAAG,QAAQ,KAAK,IAAI,CAAC;AAAA,UACrB,eAAe,MAAM,aAAa,eAAe,CAAC;AAAA,UAClD,sBAAsB,MAAM,aAAa,eAAe,CAAC;AAAA,UACzD;AAAA,QACF;AAAA,MACF;AACA,uBAAiB,SAAS,aAAa,YAAY,QAAQ;AAAA,IAC7D;AAEA,IAAM,kBAAkB,CAAC,SAAyB,eAAuC;AACvF,MAAAA,gBAAe,QAAQ,MAAM;AAC7B,YAAM,WAAqB,CAAC,OAAO,QAAQ,SAAS;AAClD,YAAI,OAAO;AACX,iBAAS,IAAI,GAAG,IAAI,MAAM,MAAM,KAAK;AACnC,cAAI,KAAK,QAAQ,CAAC,KAAK,KAAK,KAAK,WAAW,GAAG;AAE7C,oBAAQ,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC;AAAA,UAClC;AAAA,QACF;AAEA,eAAO;AAAA,UACL;AAAA,UACA;AAAA,UACA,cAAc,MAAM,aAAa,eAAe,CAAC;AAAA,UACjD,eAAe,OAAO,KAAK,KAAK,UAAU,IAAI;AAAA,QAChD;AAAA,MACF;AACA,uBAAiB,SAAS,cAAc,YAAY,QAAQ;AAAA,IAC9D;AAEA,IAAM,iBAAiB,CAAC,SAAyB,eAAuC;AACtF,MAAAA,gBAAe,QAAQ,MAAM;AAC7B,YAAM,WAAqB,CAAC,OAAO,SAAS,SAAS;AACnD,cAAM,UAAU,CAAC;AACjB,iBAAS,IAAI,GAAG,IAAI,MAAM,MAAM,KAAK;AACnC,cAAI,KAAK,QAAQ,CAAC,KAAK,KAAK,KAAK,WAAW,GAAG;AAC7C,oBAAQ,KAAK,iBAAiB,CAAC,QAAQ;AAAA,UACzC;AAAA,QACF;AAEA,eAAO;AAAA,UACL,GAAG,QAAQ,KAAK,IAAI,CAAC;AAAA,UACrB,eAAe,MAAM,aAAa,eAAe,CAAC;AAAA,UAClD,sBAAsB,MAAM,aAAa,eAAe,CAAC;AAAA,UACzD;AAAA,QACF;AAAA,MACF;AACA,uBAAiB,SAAS,aAAa,YAAY,QAAQ;AAAA,IAC7D;AAEA,IAAM,kBAAkB,CAAC,SAAyB,eAAuC;AACvF,MAAAA,gBAAe,QAAQ,MAAM;AAC7B,YAAM,WAAqB,CAAC,OAAO,WAC/B;AAAA,QAAC,eAAe,OAAO,KAAK,OAAO;AAAA,QAClC;AAAA,QACA,YAAY,MAAM,aAAa,eAAe,CAAC;AAAA,QAC/C;AAAA,MACL;AACA,uBAAiB,SAAS,cAAc,YAAY,QAAQ;AAAA,IAC9D;AAEA,IAAM,iBAAiB,CAAC,SAAyB,eAAuC;AACtF,MAAAA,gBAAe,QAAQ,MAAM;AAC7B,YAAM,WAAqB,CAAC,OAAO,WAC/B;AAAA,QAAC,eAAe,OAAO,KAAK,OAAO;AAAA,QAClC;AAAA,QACA,YAAY,MAAM,aAAa,eAAe,CAAC;AAAA,QAC/C;AAAA,MACL;AACA,uBAAiB,SAAS,aAAa,YAAY,QAAQ;AAAA,IAC7D;AAEA,IAAM,uBAAuB,CAAC,SAAyB,eAAuC;AAC5F,MAAAA,gBAAe,QAAQ,MAAM;AAC7B,YAAM,WAAqB,CAAC,OAAO,WAC/B;AAAA,QAAC,WAAW,OAAO,KAAK,KAAK,oBAAoB,OAAO,KAAK,KAAK;AAAA,QACjE;AAAA,QACA,OAAO,MAAM,aAAa,eAAe,CAAC;AAAA,QAC1C;AAAA,MACL;AACA,uBAAiB,SAAS,mBAAmB,YAAY,QAAQ;AAAA,IACnE;AAEA,IAAM,uBACF,CAAC,OAA0B,MAAyB,sBAAwC;AAC1F,UAAI,KAAK,WAAW,GAAG;AACrB,eAAO;AAAA,MACT;AAEA,UAAI,aAAa;AACjB,UAAI,aAAa;AACjB,eAAS,MAAM,GAAG,MAAM,KAAK,QAAQ,OAAO;AAC1C,YAAI,KAAK,QAAQ,GAAG,MAAM,IAAI;AAC5B,wBAAc,MAAM,GAAG;AAAA,QACzB,OAAO;AACL,wBAAc,MAAM,GAAG;AAAA,QACzB;AAAA,MACF;AAKA,aAAO,aAAa,MAAM,aAAa;AAAA,IACzC;AAEG,IAAM,aAAa,CAAC,SAAyB,eAAuC;AACzF,UAAI,qBAAqB,QAAQ,OAAO,CAAC,EAAE,MAAM,WAAW,MAAM,WAAW,iBAAiB,GAAG;AAC/F,wBAAgB,SAAS,UAAU;AAAA,MACrC,OAAO;AACL,yBAAiB,SAAS,UAAU;AAAA,MACtC;AAAA,IACF;AAEO,IAAM,WAAW,CAAC,SAAyB,eAAuC;AACvF,UAAI,qBAAqB,QAAQ,OAAO,CAAC,EAAE,MAAM,WAAW,MAAM,WAAW,iBAAiB,GAAG;AAC/F,sBAAc,SAAS,UAAU;AAAA,MACnC,OAAO;AACL,uBAAe,SAAS,UAAU;AAAA,MACpC;AAAA,IACF;AAEO,IAAM,WAAW,CAAC,SAAyB,eAAuC;AACvF,UAAI,qBAAqB,QAAQ,OAAO,CAAC,EAAE,MAAM,WAAW,MAAM,WAAW,iBAAiB,GAAG;AAC/F,sBAAc,SAAS,UAAU;AAAA,MACnC,OAAO;AACL,uBAAe,SAAS,UAAU;AAAA,MACpC;AAAA,IACF;AAEO,IAAM,kBAAkB,CAAC,SAAyB,eAAuC;AAC9F,UAAI,qBAAqB,QAAQ,OAAO,CAAC,EAAE,MAAM,WAAW,MAAM,WAAW,iBAAiB,GAAG;AAC/F,6BAAqB,SAAS,UAAU;AAAA,MAC1C,OAAO;AACL,8BAAsB,SAAS,UAAU;AAAA,MAC3C;AAAA,IACF;AAEO,IAAM,YAAY,CAAC,SAAyB,eAAuC;AACxF,UAAI,qBAAqB,QAAQ,OAAO,CAAC,EAAE,MAAM,WAAW,MAAM,WAAW,iBAAiB,GAAG;AAC/F,uBAAe,SAAS,UAAU;AAAA,MACpC,OAAO;AACL,wBAAgB,SAAS,UAAU;AAAA,MACrC;AAAA,IACF;AAEO,IAAM,YAAY,CAAC,SAAyB,eAAuC;AACxF,UAAI,qBAAqB,QAAQ,OAAO,CAAC,EAAE,MAAM,WAAW,MAAM,WAAW,iBAAiB,GAAG;AAC/F,uBAAe,SAAS,UAAU;AAAA,MACpC,OAAO;AACL,wBAAgB,SAAS,UAAU;AAAA,MACrC;AAAA,IACF;AAEO,IAAM,aAAa,CAAC,SAAyB,eAAuC;AACzF,UAAI,qBAAqB,QAAQ,OAAO,CAAC,EAAE,MAAM,WAAW,MAAM,WAAW,iBAAiB,GAAG;AAC/F,wBAAgB,SAAS,UAAU;AAAA,MACrC,OAAO;AACL,yBAAiB,SAAS,UAAU;AAAA,MACtC;AAAA,IACF;AAEO,IAAM,YAAY,CAAC,SAAyB,eAAuC;AACxF,UAAI,qBAAqB,QAAQ,OAAO,CAAC,EAAE,MAAM,WAAW,MAAM,WAAW,iBAAiB,GAAG;AAC/F,uBAAe,SAAS,UAAU;AAAA,MACpC,OAAO;AACL,wBAAgB,SAAS,UAAU;AAAA,MACrC;AAAA,IACF;AAEO,IAAM,kBAAkB,CAAC,SAAyB,eAAuC;AAC9F,UAAI,qBAAqB,QAAQ,OAAO,CAAC,EAAE,MAAM,WAAW,MAAM,WAAW,iBAAiB,GAAG;AAC/F,6BAAqB,SAAS,UAAU;AAAA,MAC1C,OAAO;AACL,8BAAsB,SAAS,UAAU;AAAA,MAC3C;AAAA,IACF;AAEO,IAAM,eAAe,CAAC,SAAyB,eAAuC;AAC3F,UAAI,qBAAqB,QAAQ,OAAO,CAAC,EAAE,MAAM,WAAW,MAAM,WAAW,iBAAiB,GAAG;AAC/F,0BAAkB,SAAS,UAAU;AAAA,MACvC,OAAO;AACL,2BAAmB,SAAS,UAAU;AAAA,MACxC;AAAA,IACF;AAAA;AAAA;;;ACnXA,IAcME,iBAeO,QA0BA,QA0BA;AAjFb;AAAA;AAAA;AAOA;AAEA;AAGA;AAEA,IAAMA,kBAAiB,CAAC,WAAwC;AAC9D,UAAI,CAAC,UAAU,OAAO,WAAW,KAAK,OAAO,SAAS,GAAG;AACvD,cAAM,IAAI,MAAM,wCAAwC;AAAA,MAC1D;AACA,UAAI,OAAO,CAAC,EAAE,4BAA6B;AACzC,cAAM,IAAI,MAAM,qBAAqB;AAAA,MACvC;AAAA,IACF;AAQO,IAAM,SAAS,CAAC,SAAyB,eAA0C;AACxF,MAAAA,gBAAe,QAAQ,MAAM;AAC7B,YAAM,cAAwB,CAAC,OAAO,QAAQ,SAAS;AACrD,cAAM,UAAU,CAAC;AACjB,iBAAS,IAAI,GAAG,IAAI,MAAM,MAAM,KAAK;AACnC,cAAI,KAAK,QAAQ,CAAC,KAAK,KAAK,KAAK,WAAW,GAAG;AAC7C,oBAAQ,KAAK,iBAAiB,CAAC,QAAQ;AAAA,UACzC;AAAA,QACF;AACA,eAAO;AAAA,UACL,GAAG,QAAQ,KAAK,IAAI,CAAC;AAAA,UAAI,eAAe,MAAM,aAAa,eAAe,CAAC;AAAA;AAAA,UAC3E,OAAO,MAAM,aAAa,eAAe,CAAC,IAAI,WAAW,kBAAkB,IAAI,OAAO,GAAG;AAAA,mBAC5E,MAAM,aAAa,eAAe,CAAC;AAAA;AAAA;AAAA,UAGhD;AAAA,UAAI,OAAO,YAAY,cAAc,YAAY;AAAA,QACnD;AAAA,MACF;AAEA,cAAQ;AAAA,QACJ;AAAA,UACI;AAAA,UAAU,EAAC,MAAM,WAAW,UAAU,mBAAmB,CAAC,MAAM,EAAC;AAAA,UAAG,CAAC,QAAQ,OAAO,CAAC,CAAC;AAAA,UAAG;AAAA,UACzF,CAAC,WAAW,IAAI;AAAA;AAAA,UAAmB,WAAW;AAAA,QAAQ;AAAA,QAC1D,EAAC,QAAQ,CAAC,CAAC,EAAC;AAAA,MAAC;AAAA,IACnB;AAEO,IAAM,SAAS,CAAC,SAAyB,eAA0C;AACxF,MAAAA,gBAAe,QAAQ,MAAM;AAC7B,YAAM,cAAwB,CAAC,OAAO,QAAQ,SAAS;AACrD,cAAM,UAAU,CAAC;AACjB,iBAAS,IAAI,GAAG,IAAI,MAAM,MAAM,KAAK;AACnC,cAAI,KAAK,QAAQ,CAAC,KAAK,KAAK,KAAK,WAAW,GAAG;AAC7C,oBAAQ,KAAK,iBAAiB,CAAC,QAAQ;AAAA,UACzC;AAAA,QACF;AACA,eAAO;AAAA,UACL,GAAG,QAAQ,KAAK,IAAI,CAAC;AAAA,UAAI,eAAe,MAAM,aAAa,eAAe,CAAC;AAAA;AAAA,UAC3E,OAAO,MAAM,aAAa,eAAe,CAAC,IAAI,WAAW,kBAAkB,IAAI,OAAO,GAAG;AAAA,mBAC5E,MAAM,aAAa,eAAe,CAAC;AAAA;AAAA;AAAA,UAGhD;AAAA,UAAI,OAAO,YAAY,cAAc,YAAY;AAAA,QACnD;AAAA,MACF;AAEA,cAAQ;AAAA,QACJ;AAAA,UACI;AAAA,UAAU,EAAC,MAAM,WAAW,UAAU,mBAAmB,CAAC,MAAM,EAAC;AAAA,UAAG,CAAC,QAAQ,OAAO,CAAC,CAAC;AAAA,UAAG;AAAA,UACzF,CAAC,WAAW,IAAI;AAAA;AAAA,UAAmB,WAAW;AAAA,QAAQ;AAAA,QAC1D,EAAC,QAAQ,CAAC,CAAC,EAAC;AAAA,MAAC;AAAA,IACnB;AAEO,IAAM,2BAA2B,CAAC,eACrC,4BAA4B,UAAoE;AAAA;AAAA;;;AClFpG,IAeMC,iBA4BA,yBAWA,kBAmBO,yBAkEA,QAcA;AAzJb;AAAA;AAAA;AAGA;AAEA;AACA;AAGA;AAMA,IAAMA,kBAAiB,CAAC,QAA+B,SAAuB;AAC5E,UAAI,CAAC,UAAU,OAAO,SAAS,GAAG;AAChC,cAAM,IAAI,MAAM,gBAAgB;AAAA,MAClC;AACA,YAAM,iBAAiB;AACvB,YAAM,iBAAiB,OAAO,cAAc;AAC5C,YAAM,YAAY,eAAe;AACjC,YAAM,YAAY,eAAe,KAAK;AACtC,aAAO,QAAQ,CAAC,OAAO,MAAM;AAC3B,YAAI,MAAM,gBAAgB;AACxB;AAAA,QACF;AAEA,YAAI,MAAM,aAAa,WAAW;AAChC,gBAAM,IAAI,MAAM,kCAAkC;AAAA,QACpD;AAEA,YAAI,MAAM,KAAK,WAAW,WAAW;AACnC,gBAAM,IAAI,MAAM,0CAA0C;AAAA,QAC5D;AACA,cAAM,KAAK,QAAQ,CAAC,KAAKC,OAAM;AAC7B,cAAIA,OAAM,QAAQ,QAAQ,eAAe,KAAKA,EAAC,GAAG;AAChD,kBAAM,IAAI,MAAM,kCAAkC;AAAA,UACpD;AAAA,QACF,CAAC;AAAA,MACH,CAAC;AAAA,IACH;AAEA,IAAM,0BAA0B,CAAC,iBAAyB,wBAAwC;AAAA;AAAA,wCAE1D,eAAe,MAAM,mBAAmB;AAAA,gCAChD,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA,aAKlC,eAAe;AAAA;AAG5B,IAAM,mBAAmB,CAAC,QAAkC,WAA0B;AACpF,YAAM,kBAAkB,OAAO;AAE/B,YAAM,YAAsB,CAAC;AAC7B,eAAS,IAAI,GAAG,IAAI,iBAAiB,EAAE,GAAG;AACxC,cAAM,gBAAgB,OAAO,YAAY,cAAc,OAAO,CAAC,EAAE,aAAa,SAAS,CAAC;AACxF,YAAI,oBAAoB,GAAG;AACzB,oBAAU,KAAK,aAAa;AAAA,QAC9B,WAAW,MAAM,GAAG;AAClB,oBAAU,KAAK,qBAAqB,CAAC,QAAQ,aAAa,IAAI;AAAA,QAChE,WAAW,MAAM,kBAAkB,GAAG;AACpC,oBAAU,KAAK,UAAU,aAAa,IAAI;AAAA,QAC5C,OAAO;AACL,oBAAU,KAAK,0BAA0B,CAAC,OAAO,aAAa,IAAI;AAAA,QACpE;AAAA,MACF;AACA,aAAO,UAAU,KAAK,IAAI;AAAA,IAC5B;AAEO,IAAM,0BACT,CAAC,QAA+B,cAAsB,aAAuB,aAAoC;AAC/G,YAAM,aAAa,UAAU,KAAK,WAAW;AAE7C,YAAM,mBAAmB,IAAI,MAAc,OAAO,MAAM;AACxD,YAAM,YAAY,IAAI,MAAqB,OAAO,MAAM;AAExD,UAAI,cAAc;AAClB,YAAM,oBAAwD,CAAC;AAC/D,YAAM,aAAa,CAAC;AACpB,YAAM,kBAAoC,CAAC,EAAC,uBAAuB,MAAM,WAAU,CAAC;AACpF,eAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,EAAE,GAAG;AACtC,uBAAe,OAAO,CAAC,EAAE,KAAK,YAAY;AAC1C,yBAAiB,CAAC,IAAI;AACtB,mBAAW,KAAK,OAAO,CAAC,EAAE,KAAK,MAAM;AACrC,kBAAU,CAAC,IAAI,cAAc,QAAQ,CAAC,IAAI,UAAU,WAAW,CAAC,CAAC;AACjE,0BAAkB,KAAK,MAAM;AAC7B,wBAAgB,KAAK,EAAC,uBAAuB,MAAM,iBAAiB,CAAC,EAAC,CAAC;AAAA,MACzE;AACA,eAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,EAAE,GAAG;AACtC,wBAAgB,KAAK,GAAG,2BAA2B,OAAO,CAAC,EAAE,IAAI,CAAC;AAAA,MACpE;AACA,sBAAgB,KAAK,GAAG,2BAA2B,WAAW,CAAC;AAE/D,YAAM,SAAS,eAAe,UAAU,UAAU,YAAY,MAAM;AACpE,YAAM,cAAc,OAAO,WAAW,WAAW,YAAY;AAC7D,YAAM,sBACF,MAAM,KAAK,MAAM,iBAAiB,MAAM,EAAE,KAAK,CAAC,EAAE,IAAI,OAAK,4BAA4B,CAAC,EAAE,EAAE,KAAK,GAAG;AACxG,YAAM,kBAAkB,CAAC,iBAA+B;AAAA;AAAA,KAEzD,MAAM;AACH,qBAAa,gBAAgB,cAAc,KAAK;AAChD,iBAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,uBAAa,gBAAgB,mBAAmB,CAAC,IAAI,KAAK;AAAA,QAC5D;AACA,eAAO,aAAa,iBAAiB,GAAG,WAAW,MAAM;AAAA,MAC3D,GAAG,CAAC;AAAA;AAAA,IAEN,wBAAwB,iBAAiB,QAAQ,mBAAmB,CAAC;AAAA;AAAA,IAErE,aAAa,UAAU,CAAC;AAAA,MACtB,aAAa,sCAAsC,qBAAqB,CAAC;AAAA;AAAA,oBAE3D,OAAO,gBAAgB,YAAY,CAAC;AAAA;AAAA,2CAEb,WAAW;AAAA;AAAA,0CAEZ,iBAAiB,MAAM,MAAM,mBAAmB;AAAA,QAClF,WAAW;AAAA;AAAA;AAAA,MAGb,iBAAiB,WAAW,MAAM,CAAC;AAAA;AAGnC,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,GAAG,YAAY,IAAI,kBAAiB;AAAA,QACxD,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,SAAQ,CAAC;AAAA,UACvC,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa;AAAA;AAAA,UAAuB,EAAC;AAAA,UAClE;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEG,IAAM,SAAS,CAAC,SAAyB,eAAuC;AACrF,YAAM,SAAS,QAAQ;AACvB,YAAM,aAAa,OAAO,CAAC,EAAE;AAC7B,YAAM,eAAe,UAAU,cAAc,WAAW,MAAM,WAAW,MAAM;AAC/E,MAAAD,gBAAe,QAAQ,YAAY;AACnC,YAAM,cAAc,WAAW,MAAM;AACrC,kBAAY,YAAY,IACpB,OAAO,OAAO,CAAC,KAAK,UAAU,OAAO,MAAM,KAAK,SAAS,eAAe,MAAM,KAAK,YAAY,IAAI,IAAI,CAAC;AAE5G,YAAM,iBAAiB,OAAO,OAAO,WAAS,UAAU,KAAK,MAAM,IAAI,IAAI,CAAC;AAC5E,cAAQ;AAAA,QACJ,wBAAwB,gBAAgB,cAAc,aAAa,OAAO,CAAC,EAAE,QAAQ;AAAA,QAAG,EAAC,QAAQ,eAAc;AAAA,MAAC;AAAA,IACtH;AAEO,IAAM,wBAAwB,CAAC,eAClC,4BAA4B,EAAC,MAAM,WAAW,KAAc,CAAC;AAAA;AAAA;;;AC1JjE,IAoEM,yBAmKA,iCAsGA,iCA2HA,mCA+EO,gBAiDP,SAmHO;AA3rBb;AAAA;AAAA;AAGA;AAEA;AAEA;AACA;AA4DA,IAAM,0BAA0B,CAAC,QAA+B,eAAoD;AAmClH,YAAM,QAAQ,OAAO,CAAC;AACtB,YAAM,UAAU,OAAO,CAAC;AACxB,YAAM,OAAO,OAAO,CAAC;AACrB,YAAM,YAAY,OAAO,CAAC;AAC1B,YAAM,OAAO,OAAO,CAAC;AACrB,YAAM,uBAAuB,OAAO,CAAC;AAErC,UAAI,QAAQ,sBAAsB;AAChC,cAAM,IAAI,MAAM,4DAA4D;AAAA,MAC9E;AAEA,UAAI,MAAM,KAAK,WAAW,GAAG;AAC3B,cAAM,IAAI,MAAM,sCAAsC;AAAA,MACxD;AAEA,YAAM,YAAY,MAAM,KAAK,CAAC;AAC9B,YAAM,iBAAiB,MAAM,KAAK,CAAC;AACnC,YAAM,kBAAkB,MAAM,KAAK,CAAC;AAEpC,UAAI,KAAK,KAAK,WAAW,GAAG;AAC1B,cAAM,IAAI,MAAM,+CAA+C;AAAA,MACjE;AAEA,UAAI,QAAQ,KAAK,WAAW,GAAG;AAC7B,cAAM,IAAI,MAAM,kDAAkD;AAAA,MACpE;AAEA,UAAI,QAAQ,KAAK,CAAC,MAAM,iBAAiB;AACvC,cAAM,IAAI,MAAM,uEAAuE;AAAA,MACzF;AAEA,UAAI,KAAK,KAAK,CAAC,MAAM,QAAQ,KAAK,CAAC,GAAG;AACpC,cAAM,IAAI,MAAM,oFAAoF;AAAA,MACtG;AAEA,UAAI,cAAc,KAAK,KAAK,CAAC,IAAI;AACjC,UAAI,cAAc;AAClB,UAAI,cAAc;AAClB,UAAI,WAAW,eAAe,SAAS,GAAG;AACxC,YAAI,WAAW,eAAe,WAAW,GAAG;AAC1C,gBAAM,IAAI,MAAM,mDAAmD;AAAA,QACrE;AACA,mBAAW,MAAM,WAAW,gBAAgB;AAC1C,cAAI,KAAK,WAAW,aAAa,GAAG;AAClC,kBAAM,IAAI,MAAM,mDAAmD;AAAA,UACrE;AAAA,QACF;AAEA,sBAAc,WAAW,eAAe,CAAC;AACzC,sBAAc,WAAW,eAAe,CAAC;AACzC,sBAAc,WAAW,eAAe,CAAC;AAAA,MAC3C;AAEA,YAAM,mBAAmB;AAEzB,UAAI,gBAAgB,aAAa;AAC/B,cAAM,IAAI,MAAM,6DAA6D;AAAA,MAC/E;AAEA,UAAI,KAAK,KAAK,CAAC,MAAM,cAAc,cAAc,aAAa;AAC5D,cAAM,IAAI,MAAM,+EAA+E;AAAA,MACjG;AAEA,UAAI,qBAAqB;AACzB,UAAI,MAAM;AACR,YAAI,gBAAgB,aAAa;AAC/B,gBAAM,IAAI,MAAM,oDAAoD;AAAA,QACtE;AACA,YAAI,KAAK,KAAK,WAAW,GAAG;AAC1B,gBAAM,IAAI,MAAM,qCAAqC;AAAA,QACvD;AACA,YAAI,KAAK,KAAK,CAAC,MAAM,GAAG;AACtB,gBAAM,IAAI,MAAM,wCAAwC;AAAA,QAC1D;AACA,YAAI,KAAK,KAAK,CAAC,MAAM,WAAW;AAC9B,gBAAM,IAAI,MAAM,kDAAkD;AAAA,QACpE;AACA,YAAI,KAAK,KAAK,CAAC,MAAM,WAAW,UAAU;AACxC,gBAAM,IAAI,MAAM,gDAAgD;AAAA,QAClE;AACA,YAAI,KAAK,KAAK,CAAC,MAAM,cAAc,WAAW,UAAU;AACtD,gBAAM,IAAI,MAAM,gEAAgE;AAAA,QAClF;AAEA,YAAI,CAAC,WAAW,wBAAwB;AACtC,+BAAqB,KAAK,KAAK,CAAC;AAAA,QAClC;AAAA,MAEF;AAEA,YAAM,sBAAsB,mBAAmB;AAC/C,YAAM,oBAAoB;AAE1B,YAAM,WAAW;AACjB,UAAI,WAAW;AAGb,cAAM,IAAI,MAAM,oBAAoB;AAAA,MACtC;AAEA,UAAI,MAAM;AACR,cAAM,IAAI,MAAM,uBAAuB;AAAA,MACzC;AAEA,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,YAAY;AAAA,QACZ;AAAA,QACA,UAAU,KAAK,MAAM,cAAc,WAAW,QAAQ;AAAA,QACtD,WAAW,KAAK,MAAM,cAAc,WAAW,QAAQ;AAAA,QACvD,UAAU,WAAW;AAAA,QACrB,kBAAkB;AAAA,QAClB,wBAAwB;AAAA,QACxB,iBAAiB,WAAW;AAAA,QAC5B;AAAA,QACA,OAAO,WAAW;AAAA,QAClB,qBAAqB;AAAA,QACrB,cAAc;AAAA,QACd,WAAW;AAAA,MACb;AAAA,IACF;AAEA,IAAM,kCAAkC,CAAC,UAA0B,OAAmB,GAAW,MAAc;AAC7G,YAAM,aAAa,iBAAiB,CAAC;AACrC,UAAI,KAAK;AACT,YAAM,QAAQ,IAAI;AAClB,UAAI,QAAQ,IAAI;AACd,aAAK;AAAA,MACP,WAAW,QAAQ,IAAI,IAAI;AACzB,aAAK,KAAK,KAAK,QAAQ,CAAC;AAAA,MAC1B;AACA,YAAM,oBAAoB,KAAK,KAAK,IAAI,aAAa,EAAE;AACvD,YAAM,kBAAoC;AAAA,QACxC,EAAC,MAAM,MAAM,UAAU,MAAM,IAAI,EAAC;AAAA,QAAG,EAAC,uBAAuB,MAAM,MAAK;AAAA,QACxE,EAAC,uBAAuB,MAAM,kBAAiB;AAAA,MACjD;AACA,YAAM,WAAW,4BAA4B,MAAM,UAAU,UAAU;AACvE,YAAM,UAAU,yCAA0C,UAAU;AAEpE,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,cAAc,eAAe,KAAK,MAAM,UAAU,MAAM,MAAM,UAAU;AAC9E,cAAM,gBAAgB,0BAA0B,MAAM,QAAQ;AAC9D,cAAM,WAA8B;AAAA,UAClC,EAAC,MAAM,SAAS,MAAM,cAAuC;AAAA,UAAG,EAAC,MAAM,UAAU,MAAM,MAAK;AAAA,UAC5F,EAAC,MAAM,uBAAuB,MAAM,MAAK;AAAA,QAC3C;AAEA,eAAO;AAAA,0CAC+B,EAAE;AAAA,0CACF,EAAE;AAAA,IACxC,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,WAAW,CAAC;AAAA,IACrE,aAAa,UAAU;AAAA,UACrB;AAAA,UAAI;AAAA,UAAG;AAAA,QACT,CAAC,CAAC;AAAA;AAAA;AAAA;AAAA,8BAIwB,OAAO;AAAA;AAAA,gCAEL,OAAO;AAAA;AAAA,+BAER,MAAM;AAC/B,kBAAQ,YAAY;AAAA,YAClB,KAAK;AACH,qBAAO;AAAA,YACT,KAAK;AACH,qBAAO;AAAA,YACT,KAAK;AACH,qBAAO;AAAA,YACT;AACE,oBAAM,IAAI,MAAM,2BAA2B,UAAU,EAAE;AAAA,UAC3D;AAAA,QACF,GAAG,CAAC;AAAA;AAAA;AAAA;AAAA,2BAImB,EAAE;AAAA;AAAA;AAAA;AAAA,uBAIN,OAAO;AAAA;AAAA,0BAEJ,OAAO;AAAA;AAAA,+BAEF,MAAM;AAC/B,kBAAQ,YAAY;AAAA,YAClB,KAAK;AACH,qBAAO;AAAA,YACT,KAAK;AACH,qBAAO;AAAA,YACT,KAAK;AACH,qBAAO;AAAA,YACT;AACE,oBAAM,IAAI,MAAM,2BAA2B,UAAU,EAAE;AAAA,UAC3D;AAAA,QACF,GAAG,CAAC;AAAA;AAAA;AAAA;AAAA,2BAImB,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0BAMH,YAAY,KAAK,KAAK;AAAA;AAAA;AAAA;AAAA,yBAIvB,OAAO;AAAA,0BACN,YAAY,KAAK,KAAK;AAAA;AAAA;AAAA;AAAA,MAI9C;AAEA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,GAAG,EAAE,IAAI,QAAQ,IAAI,UAAU,GAAE;AAAA,QACrD;AAAA,QACA,YAAY,OAAO,EAAC,SAAS,CAAC,GAAG,eAAe,EAAC,GAAG,EAAC,GAAG,gBAAe;AAAA,MACzE;AAAA,IACF;AAEA,IAAM,kCACF,CAAC,UAA0B,GAAe,KAAiB,sBAC1D,YAAiC,YAA4B,uBAA+B;AAC3F,YAAM,sBAAsB,qBAAqB,WAAW;AAC5D,YAAM,aAAa,CAAC,WAAW,WAAW,WAAW,UAAU,WAAW,gBAAgB,mBAAmB;AAI7G,YAAM,QAAQ,WAAW,UAAU,IAAI,IAAM,KAAK,KAAK,WAAW,QAAQ,IAAI,WAAW;AACzF,YAAM,aAAa,iBAAiB,WAAW,QAAQ;AACvD,YAAM,qBAAqB,WAAW,WAAW;AACjD,YAAM,YAAY;AAClB,YAAM,WAAW;AAAA,QACf,GAAG,KAAK,KAAK,sBAAsB,SAAS;AAAA,QAC5C,GAAG,KAAK,KAAK,WAAW,iBAAiB,SAAS;AAAA,QAClD,GAAG,WAAW,YAAY,WAAW;AAAA,MACvC;AACA,YAAM,kBAAoC;AAAA,QACxC,EAAC,uBAAuB,MAAM,WAAW,eAAc;AAAA,QAAG,EAAC,uBAAuB,MAAM,mBAAkB;AAAA,QAC1G,EAAC,uBAAuB,MAAM,oBAAmB;AAAA,QAAG,EAAC,uBAAuB,MAAM,WAAW,SAAQ;AAAA,QACrG,EAAC,qBAAsB,MAAM,MAAK;AAAA,MACpC;AAEA,YAAM,oBAAwD,CAAC,QAAQ,MAAM;AAC7E,UAAI,sBAAsB;AACxB,0BAAkB,KAAK,MAAM;AAC7B,wBAAgB,KAAK,GAAG,2BAA2B,qBAAqB,IAAI,CAAC;AAAA,MAC/E;AAEA,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,SAAS,cAAc,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU;AAChE,cAAM,SAAS,cAAc,OAAO,IAAI,UAAU,IAAI,MAAM,UAAU;AACtE,cAAM,YAAY,CAAC,QAAQ,MAAM;AACjC,cAAM,4BAA4B,uBAC9B,cAAc,0BAA0B,qBAAqB,UAAU,qBAAqB,KAAK,MAAM,IACvG;AACJ,YAAI,2BAA2B;AAC7B,oBAAU,KAAK,yBAAyB;AAAA,QAC1C;AACA,cAAM,SAAS,eAAe,UAAU,EAAE,UAAU,UAAU;AAE9D,cAAM,UAAU,yCAA0C,UAAU;AAEpE,cAAM,WAA8B;AAAA,UAClC,EAAC,MAAM,KAAK,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,KAAK,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,KAAK,MAAM,MAAK;AAAA,UAC3E,EAAC,MAAM,aAAa,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,SAAS,MAAM,MAA+B;AAAA,QACzF;AACA,eAAO;AAAA,sBACO,SAAS;AAAA;AAAA,gCAEC,OAAO,KAAK,OAAO,KAAK,YAAY,SAAS;AAAA,gCAC7C,OAAO,KAAK,OAAO,KAAK,YAAY,SAAS;AAAA,IACzE,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,GAAG,WAAW,MAAM,CAAC;AAAA,IAC9E,aAAa,UAAU;AAAA,UACjB;AAAA,UAAW;AAAA,UAAW;AAAA,QACxB,CAAC,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAQQ,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAWN,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBASF,MAAM;AACpB,kBAAQ,YAAY;AAAA,YAClB,KAAK;AACH,qBAAO;AAAA,YACT,KAAK;AACH,qBAAO;AAAA,YACT,KAAK;AACH,qBAAO;AAAA,YACT;AACE,oBAAM,IAAI,MAAM,2BAA2B,UAAU,EAAE;AAAA,UAC3D;AAAA,QACF,GAAG,CAAC;AAAA;AAAA,KAEP,MAAM;AACD,cAAI,2BAA2B;AAC7B,mBAAO;AAAA;AAAA;AAAA,sBAGG,0BAA0B,KAAK,OAAO;AAAA,4BAChC,OAAO,KAAK,KAAK,4BAC7B,0BAA0B,aAAa,SAAS,CAAC;AAAA,UACvD;AACA,iBAAO,uBAAuB,OAAO,KAAK,KAAK;AAAA,QACjD,GAAG,CAAC;AAAA;AAAA;AAAA,MAGN;AACA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,GAAG,UAAU,IAAI,kBAAiB;AAAA,QACtD,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,YAAY,UAAU,EAAE,UAAU,6BAAgC,CAAC;AAAA,UACpF,eAAe;AAAA,UACf;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAGJ,IAAM,oCACF,CAAC,UAA0B,OAAmB,GAAe,QAC5D,uBAA+B;AAC9B,YAAM,sBAAsB,qBAAqB,OAAO;AACxD,YAAM,cAAc,CAAC,OAAO,WAAW,OAAO,gBAAgB,OAAO,WAAW;AAChF,YAAM,YAAY;AAClB,YAAM,WAAW;AAAA,QACf,GAAG,KAAK,KAAK,OAAO,YAAY,SAAS;AAAA,QACzC,GAAG,KAAK,KAAK,OAAO,iBAAiB,SAAS;AAAA,QAC9C,GAAG,OAAO,YAAY,OAAO;AAAA,MAC/B;AACA,YAAM,kBAAoC;AAAA,QACxC,EAAC,uBAAuB,MAAM,OAAO,eAAc;AAAA,QAAG,EAAC,uBAAuB,MAAM,oBAAmB;AAAA,QACvG,EAAC,uBAAuB,MAAM,OAAO,UAAS;AAAA,QAAG,EAAC,uBAAuB,MAAM,OAAO,SAAQ;AAAA,QAC9F,EAAC,uBAAuB,MAAM,OAAO,YAAW;AAAA,MAClD;AAEA,YAAM,oBAAwD,CAAC,QAAQ,MAAM;AAC7E,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,cAAc,cAAc,SAAS,MAAM,UAAU,MAAM,IAAI;AACrE,cAAM,UAAU,cAAc,KAAK,EAAE,UAAU,EAAE,IAAI;AACrD,cAAM,SAAS,eAAe,UAAU,MAAM,UAAU,WAAW;AACnE,cAAM,WAA8B;AAAA,UAClC,EAAC,MAAM,KAAK,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,KAAK,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,KAAK,MAAM,MAAK;AAAA,UAC3E,EAAC,MAAM,aAAa,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,iBAAiB,MAAM,MAAK;AAAA,QACvE;AACA,eAAO;AAAA,sBACO,SAAS;AAAA,gCACC,YAAY,KAAK,KAAK,KAAK,YAAY,SAAS;AAAA,gCAChD,YAAY,KAAK,KAAK,KAAK,YAAY,SAAS;AAAA,IAC5E,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,aAAa,SAAS,MAAM,CAAC;AAAA,IACtF,aAAa,UAAU;AAAA,UACjB;AAAA,UAAW;AAAA,UAAW;AAAA,QACxB,CAAC,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAQO,YAAY,KAAK,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAwBnC;AAEA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,kBAAiB;AAAA,QAC/B,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,MAAM,UAAU,6BAAgC,CAAC;AAAA,UACzF,eAAe;AAAA,UACf;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEG,IAAM,iBACT,CAAC,SAAyB,GAAe,GAAe,GAAe,YACtE,OAA6B,SAA+B,WAC5D,sBAA4C,YAAiC,eAA+B;AAC3G,YAAM,mBAAmB,QAAQ,cAAc;AAC/C,YAAM,qBAAqB,QAAQ,cAAc;AACjD,YAAM,qBAAsB,oBAAoB,qBAAsB,WAAW,qBAAqB;AACtG,YAAM,sBAAsB,qBAAqB,WAAW;AAE5D,YAAM,kBAAkB,CAAC,WAAW,WAAW,WAAW,UAAU,qBAAqB,WAAW,QAAQ;AAC5G,YAAM,kBAAkB,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;AACnD,YAAM,MAAM,mBAAmB,QAAQ;AAAA,QACJ,wBAAwB,iBAAiB,GAAG,iBAAiB,EAAE,QAAQ;AAAA,QACvE,EAAC,QAAQ,iBAAiB,SAAS,CAAC,CAAC,EAAC;AAAA,MAAC,EAAE,CAAC,IAC9C;AAG/B,YAAM,oBAAoB,CAAC,WAAW,WAAW,WAAW,UAAU,qBAAqB,WAAW,QAAQ;AAC9G,YAAM,oBAAoB,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;AACzD,YAAM,QAAQ,qBACV,QAAQ;AAAA,QACJ,wBAAwB,mBAAmB,GAAG,mBAAmB,EAAE,QAAQ;AAAA,QAC3E,EAAC,QAAQ,mBAAmB,SAAS,CAAC,CAAC,EAAC;AAAA,MAAC,EAAE,CAAC,IAChD;AACJ,YAAM,UAAU,CAAC,GAAG,GAAG;AACvB,UAAI,sBAAsB;AACxB,gBAAQ,KAAK,oBAAoB;AAAA,MACnC;AAGA,YAAM,QAAQ,QAAQ;AAAA,QAClB;AAAA,UACI;AAAA,UAAS;AAAA,UAAG;AAAA,UAAK;AAAA,UAAsB;AAAA,UAAY;AAAA,UAAY;AAAA,QAAkB;AAAA,QACrF,EAAC,QAAQ,SAAS,SAAS,CAAC,EAAE,EAAC;AAAA,MAAC,EAAE,CAAC;AAGvC,cAAQ;AAAA,QACJ;AAAA,UACI;AAAA,UAAS;AAAA,UAAO,WAAW,YAAY,WAAW,WAAW,WAAW;AAAA,UACxE;AAAA,QAAmB;AAAA,QACvB,EAAC,QAAQ,CAAC,KAAK,GAAG,SAAS,CAAC,EAAC;AAAA,MAAC;AAGlC,YAAM,UAAU,CAAC,OAAO,KAAK;AAC7B,cAAQ;AAAA,QACJ,kCAAkC,SAAS,OAAO,OAAO,YAAY,kBAAkB;AAAA,QACvF,EAAC,QAAQ,SAAS,SAAS,CAAC,CAAC,EAAC;AAAA,MAAC;AAAA,IACrC;AAEJ,IAAM,UAAU,CAAC,SAAyB,eAAoC;AAC5E,YAAM,cAAc;AAAA,QAClB,WAAW;AAAA,QACX,WAAW;AAAA,QACX,WAAW;AAAA,QACX,WAAW;AAAA,MACb;AACA,YAAM,IAAI,WAAW;AACrB,YAAM,IAAI,WAAW;AACrB,YAAM,IAAI,WAAW;AACrB,YAAM,YAAY;AAClB,YAAM,WAAW;AAAA,QACf,GAAG,KAAK,KAAK,WAAW,WAAW,SAAS;AAAA,QAC5C,GAAG,KAAK,KAAK,WAAW,iBAAiB,SAAS;AAAA,QAClD,GAAG,WAAW,YAAY,WAAW;AAAA,MACvC;AACA,YAAM,SAAS,CAAC,QAAQ,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC,CAAC;AACvE,YAAM,kBAAoC;AAAA,QACxC,EAAC,uBAAuB,MAAM,EAAC;AAAA,QAAG,EAAC,uBAAuB,MAAM,EAAC;AAAA,QAAG,EAAC,uBAAuB,MAAM,EAAC;AAAA,QACnG,EAAC,uBAAuB,MAAM,WAAW,SAAQ;AAAA,QAAG,EAAC,uBAAuB,MAAM,WAAW,SAAQ;AAAA,QACrG,EAAC,uBAAuB,MAAM,WAAW,WAAU;AAAA,QACnD,EAAC,uBAAuB,MAAM,WAAW,aAAa,WAAW,aAAa,WAAW,YAAW;AAAA,MACtG;AAEA,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,UAAU,eAAe,YAAY,OAAO,CAAC,EAAE,UAAU,WAAW;AAC1E,cAAM,UAAU,eAAe,YAAY,OAAO,CAAC,EAAE,UAAU,WAAW;AAC1E,cAAM,UAAU,eAAe,YAAY,OAAO,CAAC,EAAE,UAAU,WAAW;AAC1E,cAAM,QAAQ,cAAc,SAAS,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,IAAI;AACvE,cAAM,SAAS,cAAc,UAAU,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,IAAI;AACzE,cAAM,OAAO,cAAc,QAAQ,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,IAAI;AACrE,cAAM,WAAW,MAAM,KAAK;AAE5B,cAAM,WAA8B;AAAA,UAClC,EAAC,MAAM,KAAK,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,KAAK,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,KAAK,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,aAAa,MAAM,MAAK;AAAA,UAC7G,EAAC,MAAM,aAAa,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,eAAe,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,OAAO,MAAM,MAAK;AAAA,QACjG;AACA,eAAO;AAAA,sBACW,SAAS;AAAA,oCACK,QAAQ,KAAK,YAAY,SAAS;AAAA,sCAChC,QAAQ,KAAK,YAAY,SAAS;AAAA,sCAClC,QAAQ,KAAK,YAAY,SAAS;AAAA,sCAClC,QAAQ,KAAK,YAAY,SAAS;AAAA,IACpE,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,OAAO,QAAQ,MAAM,SAAS,SAAS,OAAO,CAAC;AAAA,IACxG,aAAa,UAAU;AAAA,UACrB;AAAA,UAAW;AAAA,UAAW;AAAA,QACxB,CAAC,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAWa,QAAQ;AAAA,mBACR,QAAQ;AAAA,mBACR,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAoCzB;AAEA,aAAO,QAAQ;AAAA,QACX;AAAA,UACE,MAAM;AAAA,UACN,aAAa,EAAC,mBAAmB,CAAC,QAAQ,QAAQ,MAAM,EAAC;AAAA,UACzD,YAAY,OAAO;AAAA,YACjB,SAAS;AAAA,cACP,EAAC,MAAM,aAAa,UAAU,QAAQ,OAAO,CAAC,EAAE,UAAU,6BAAgC;AAAA,cAC1F,EAAC,MAAM,aAAa,UAAU,QAAQ,OAAO,CAAC,EAAE,UAAU,6BAAgC;AAAA,cAC1F,EAAC,MAAM,aAAa,UAAU,QAAQ,OAAO,CAAC,EAAE,UAAU,6BAAgC;AAAA,YAC5F;AAAA,YACA,eAAe;AAAA,YACf;AAAA,UACF;AAAA,UACA;AAAA,QACF;AAAA,QACA,EAAC,QAAQ,SAAS,CAAC,IAAI,IAAI,EAAE,EAAC;AAAA,MAAC;AAAA,IACrC;AAEO,IAAM,YAAY,CAAC,SAAyB,eAAqC;AACtF,YAAM,SAAS,wBAAwB,QAAQ,QAAQ,UAAU;AAEjE,YAAM,CAAC,GAAG,GAAG,CAAC,IAAI,QAAQ,SAAS,MAAM;AAEzC,aAAO;AAAA,QACH;AAAA,QAAS;AAAA,QAAG;AAAA,QAAG;AAAA,QAAG,QAAQ,OAAO,CAAC;AAAA,QAAG;AAAA,QAAW;AAAA,QAAW;AAAA,QAAW,QAAQ,OAAO,CAAC;AAAA,QAAG;AAAA,QAAQ;AAAA,MAAU;AAAA,IACjH;AAAA;AAAA;;;AClsBA,IAsBME,iBAkCA,qCAgFO,0BAGA;AA3Ib;AAAA;AAAA;AAGA;AAEA;AAEA;AACA;AAGA;AAWA,IAAMA,kBAAiB,CAAC,QAA+B,eAA0C;AAC/F,UAAI,CAAC,UAAU,OAAO,WAAW,GAAG;AAClC,cAAM,IAAI,MAAM,sCAAsC;AAAA,MACxD;AAEA,YAAM,kBAAkB,CAAC,QAA2B,UAA6B,YAAoB;AACnG,cAAM,IAAI,SAAS;AACnB,YAAI,MAAM,OAAO,QAAQ;AACvB,gBAAM,IAAI,MAAM,GAAG,OAAO,uBAAuB,CAAC,EAAE;AAAA,QACtD;AACA,iBAAS,QAAQ,CAAC,GAAG,MAAM;AACzB,cAAI,MAAM,OAAO,CAAC,GAAG;AACnB,kBAAM,IAAI,MAAM,GAAG,OAAO,SAAS,CAAC,gBAAgB;AAAA,UACtD;AAAA,QACF,CAAC;AAAA,MACH;AAEA,UAAI,OAAO,CAAC,EAAE,KAAK,SAAS,GAAG;AAC7B,cAAM,QAAQ,WAAW,WAAW,SAC/B,WAAW,UAAU,OAAO,CAAC,EAAE,KAAK,MAAM,EAAE,IACvB,OAAO,CAAC,EAAE,KAAK,MAAM,EAAE,EAAE,OAAO,OAAO,CAAC,EAAE,KAAK,MAAM,GAAG,OAAO,CAAC,EAAE,KAAK,SAAS,CAAC,CAAC,IACxG,OAAO,CAAC,EAAE,KAAK,MAAM,GAAG,WAAW,UAAU,IAAI,MAAS;AAC9D,wBAAgB,OAAO,CAAC,EAAE,MAAM,OAAO,qBAAqB;AAC5D,wBAAgB,OAAO,CAAC,EAAE,MAAM,OAAO,iBAAiB;AACxD,wBAAgB,OAAO,CAAC,EAAE,MAAM,OAAO,oBAAoB;AAC3D,wBAAgB,OAAO,CAAC,EAAE,MAAM,OAAO,mBAAmB;AAAA,MAC5D,OAAO;AACL,wBAAgB,OAAO,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,qBAAqB;AAC1D,wBAAgB,OAAO,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,iBAAiB;AACtD,wBAAgB,OAAO,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,oBAAoB;AACzD,wBAAgB,OAAO,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,mBAAmB;AAAA,MAC1D;AAAA,IACF;AAEA,IAAM,sCACF,CAAC,QAA+B,eAAiD;AAC/E,YAAM,EAAC,SAAS,SAAS,OAAM,IAAI;AACnC,YAAM,SAAS,OAAO,CAAC,EAAE;AACzB,YAAM,aAAa,UAAU,iBAAiB,OAAO,OAAO,SAAS,CAAC,CAAC,IAAI;AAC3E,YAAM,cAAc,WAAW,UAAU,OAAO,SAAS,IAAI,aAAa;AAC1E,YAAM,aAAa,UAAU,KAAK,MAAM,IAAI;AAE5C,YAAM,oBAAoB;AAC1B,YAAM,cAAc,oBAAoB,OAAO,SAAS;AACxD,YAAM,IAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,MAAM,UAAU;AAC3E,YAAM,QAAQ,cAAc,SAAS,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,MAAM,WAAW;AACpF,YAAM,OAAO,cAAc,QAAQ,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,MAAM,WAAW;AAClF,YAAM,YAAY,cAAc,aAAa,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,MAAM,WAAW;AAC5F,YAAM,WAAW,cAAc,YAAY,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,MAAM,WAAW;AAC1F,YAAM,IAAI,eAAe,KAAK,OAAO,CAAC,EAAE,UAAU,aAAa,UAAU;AAGzE,YAAM,cAAc,MAAc;AAChC,YAAI,UAAU;AACd,YAAI,SAAS;AACX,oBAAU,iBACN,OAAO,WAAW,IAAM,OACpB,WAAW,SAAS,iBAAiB,OAAO,SAAS,CAAC,OAAO,UAAU,KACnD,kBAAkB;AAAA,QAChD,OAAO;AACL,cAAI,WAAW,QAAQ;AACrB,sBAAU;AAAA,cACR,EAAE,WAAW,iBAAiB,KAAK,GAAG,CAAC;AAAA,4BACzB,EAAE,gBAAgB,eAAe,CAAC;AAAA,UACpD,OAAO;AAEL,sBAAU,kBAAkB,MAAM,KAAK,OAAO;AAAA,qDACL,OAAO,SAAS,CAAC;AAE1D,qBAAS,IAAI,GAAG,IAAI,MAAM,MAAM,KAAK;AACnC,yBAAW,YAAY,CAAC,qBAAqB,CAAC;AAAA,YAChD;AACA,uBAAW,iBAAiB,MAAM,gBAAgB,UAAU,CAAC;AAAA,UAC/D;AAAA,QACF;AACA,eAAO;AAAA,MACT;AACA,YAAM,+BAA+B,CAAC,WAAyB;AAAA,oBACjD,OAAO;AAAA,IACvB,OAAO,gBAAgB,cAAc,KAAK,EAAE,iBAAiB,GAAG,OAAO,MAAM,WAAW,UAAU,CAAC,CAAC;AAAA,IACpG,OAAO,UAAU,CAAC;AAAA,IAClB,OAAO,sCAAsC,qBAAqB,CAAC;AAAA,0BAC7C,EAAE,gBAAgB,gBAAgB,UAAU,EAAE,CAAC;AAAA,MACnE,YAAY,CAAC;AAAA,kBACD,MAAM,YAAY,SAAS,CAAC;AAAA,iBAC7B,KAAK,YAAY,SAAS,CAAC;AAAA,sBACtB,UAAU,YAAY,SAAS,CAAC;AAAA,qBACjC,SAAS,YAAY,SAAS,CAAC;AAAA,cACtC,EAAE,YAAY,YAAY,CAAC;AAAA;AAAA,MAEnC,EAAE,YAAY,cAAc,OAAO,CAAC;AAAA;AAEpC,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa;AAAA,UACX,MAAM,GAAG,WAAW,OAAO,IAAI,WAAW,MAAM,IAAI,OAAO,IAAI,UAAU;AAAA,UACzE,mBAAmB,oBAAoB,CAAC,QAAQ,QAAQ,QAAQ,QAAQ,MAAM,IAAI;AAAA,QACpF;AAAA,QACA,iBAAiB;AAAA,QACjB,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,OAAO,CAAC,EAAE,MAAM,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,UAC9D,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa;AAAA;AAAA,UAAuB,EAAC;AAAA,UAClE,iBAAiB,oBACb;AAAA,YACE,EAAC,uBAAuB,MAAM,WAAU;AAAA,YACxC,GAAG,2BAA2B,MAAM;AAAA,UACtC,IACA;AAAA,YACE,EAAC,uBAAuB,MAAM,WAAU;AAAA,UAC1C;AAAA,QACN;AAAA,MACF;AAAA,IACF;AAEG,IAAM,2BAA2B,CAAC,eACrC,4BAA4B,UAAoE;AAE7F,IAAM,YAAY,CAAC,SAAyB,eAA8C;AAC/F,YAAM,EAAC,QAAQ,YAAW,IAAI;AAC9B,YAAM,oBAAoB,yBAAyB,EAAC,GAAG,YAAY,YAAW,CAAC;AAC/E,UAAIC,KAAI,OAAO,sBAAsB;AACnC,QAAAD,gBAAe,QAAQ,iBAAiB;AAAA,MAC1C;AACA,UAAI,WAAW,cAAc;AAC3B,cAAM,IAAI,MAAM,uDAAuD;AAAA,MACzE,OAAO;AACL,gBAAQ,QAAQ,oCAAoC,QAAQ,iBAAiB,CAAC;AAAA,MAChF;AAAA,IACF;AAAA;AAAA;;;ACtJA,IASME,iBAkBA,0BAkCO;AA7Db;AAAA;AAAA;AAIA;AAGA;AAEA,IAAMA,kBAAiB,CAAC,WAAwC;AAC9D,UAAI,OAAO,CAAC,EAAE,KAAK,WAAW,GAAG;AAC/B,cAAM,IAAI,MAAM,gCAAgC;AAAA,MAClD;AAEA,UAAI,CAAC,CAAC,KAAK,KAAK,IAAI,EAAE,SAAS,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG;AACjD,cAAM,IAAI,MAAM,+CAA+C;AAAA,MACjE;AAEA,UAAI,OAAO,CAAC,EAAE,KAAK,WAAW,GAAG;AAC/B,cAAM,IAAI,MAAM,uCAAuC;AAAA,MACzD;AAEA,UAAI,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG;AAC3C,cAAM,IAAI,MAAM,mDAAmD;AAAA,MACrE;AAAA,IACF;AAEA,IAAM,2BAA2B,CAAC,WAA+C;AAC/E,YAAM,cAAc,OAAO,CAAC,EAAE;AAE9B,YAAM,WAAW,OAAO,CAAC,EAAE,KAAK,CAAC;AAEjC,YAAM,aAAa,UAAU,KAAK,WAAW,IAAI;AAEjD,YAAM,WAAW,OAAO,CAAC,EAAE;AAC3B,YAAM,QAAQ,cAAc,SAAS,UAAU,aAAa,CAAC;AAC7D,YAAM,OAAO,cAAc,QAAQ,UAAU,CAAC,QAAQ,GAAG,CAAC;AAC1D,YAAM,WAAW,cAAc,YAAY,UAAU,aAAa,CAAC;AACnE,YAAM,SAAS,eAAe,UAAU,UAAU,aAAa,CAAC;AAEhE,YAAM,kBAAkB,CAAC,iBAA+B;AAAA,qBACrC,QAAQ;AAAA,IACzB,aAAa,iBAAiB,OAAO,MAAM,UAAU,MAAM,CAAC;AAAA;AAAA,IAE5D,aAAa,UAAU,CAAC;AAAA,MACtB,aAAa,sCAAsC,UAAU,CAAC;AAAA,kBAClD,MAAM,YAAY,YAAY,CAAC;AAAA,UACvC,KAAK,YAAY,uBAAuB,CAAC,MAAM,SAAS,YAAY,YAAY,CAAC;AAAA,MACrF,OAAO,YAAY,cAAc,OAAO,CAAC;AAAA;AAG7C,aAAO;AAAA,QACL,MAAM;AAAA,QACN,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,UAC3D,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa;AAAA;AAAA,UAAuB,EAAC;AAAA,QACpE;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEO,IAAM,UAAU,CAAC,YAAkC;AACxD,MAAAA,gBAAe,QAAQ,MAAM;AAC7B,cAAQ,QAAQ,yBAAyB,QAAQ,MAAM,CAAC;AAAA,IAC1D;AAAA;AAAA;;;AChEA,IAeM,gCA4BA,8BAiBO,KAIA,MAIA,OAIA,MAIA,OAIA,MAGA,OASA,qBAIA,MA8BP,kCAMO,MAaA,MAIA,KAIA,MAQA,sBAGA,KAgBA,SAcA,KAKA,KAIA,OAIA,MAMA,WAOA,KAIA,KAIA,YAIA,MAMA,SASA,4BAMA,aASA,KAIA,MAIA,MAIA,KAIA,gBAEA,MAKA,cAUA,oBAGA,UAOA,iBAQA;AAzTb;AAAA;AAAA;AAGA;AAEA;AACA;AAGA;AAMA,IAAM,iCACF,CAAC,cAA4B,UAAkB,eAAuB,gBACrE,UAAmC,6BAA8C;AAChF,YAAM,UAAU,KAAK,KAAK,WAAW,CAAC;AAEtC,UAAI,aAAa;AACjB,UAAI,OAAO,aAAa,UAAU;AAChC,qBAAa,GAAG,QAAQ;AAAA,MAC1B,OAAO;AACL,qBAAa,SAAS,GAAG;AAAA,MAC3B;AAEA,YAAM,QAAQ,cAAc,aAAa,eAAe,CAAC,OAAO,GAAG,CAAC;AACpE,YAAM,SAAS,eAAe,cAAc,gBAAgB,CAAC,OAAO,GAAG,CAAC;AAExE,aAAO;AAAA,QACL,aAAa,gBAAgB,YAAY,KAAK,EAAE,iBAAiB,OAAO,MAAM,CAAC;AAAA;AAAA,IAEnF,4BAA4B,EAAE;AAAA;AAAA,IAE9B,aAAa,UAAU,CAAC;AAAA,MACtB,aAAa,sCAAsC,mBAAmB,CAAC;AAAA;AAAA,cAE/D,MAAM,YAAY,YAAY,CAAC;AAAA,MACvC,OAAO,YAAY,cAAc,UAAU,CAAC;AAAA;AAAA,IAE9C;AAEJ,IAAM,+BACF,CAAC,OAAmB,MAAc,UAAmC,0BACpE,UAAmB,iBAAyB,MAAM,cAA2B;AAAA,MAC5E;AAAA,MACA,aAAa,EAAC,MAAM,UAAU,mBAAmB,CAAC,MAAM,EAAC;AAAA,MACzD,iBAAiB,kBAAgB;AAAA,QAC7B;AAAA,QAAc,UAAU,KAAK,MAAM,IAAI;AAAA,QAAG,MAAM;AAAA,QAAU;AAAA,QAAgB;AAAA,QAAU;AAAA,MAAwB;AAAA,MAChH,YAAY,CAAC,kBAAkB;AAAA,QAC7B,SAAS,CAAC,EAAC,MAAM,MAAM,MAAM,UAAU,eAAc,CAAC;AAAA,QACtD,eACI,EAAC,GAAG,KAAK;AAAA,UAAK,UAAU,KAAK,aAAa,CAAC,EAAE,IAAI,IAAI,KAA0B;AAAA;AAAA,QAAgB,EAAC;AAAA,QACpG,iBAAiB;AAAA,UACf,EAAC,uBAAuB,MAAM,KAAK,KAAK,UAAU,KAAK,MAAM,IAAI,IAAI,CAAC,EAAC;AAAA,QACzE;AAAA,MACF;AAAA,IACF;AAEG,IAAM,MAAM,CAAC,YAAkC;AACpD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,OAAO,KAAK,CAAC;AAAA,IAC/E;AAEO,IAAM,OAAO,CAAC,YAAkC;AACrD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,QAAQ,MAAM,CAAC;AAAA,IACjF;AAEO,IAAM,QAAQ,CAAC,YAAkC;AACtD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,SAAS,OAAO,CAAC;AAAA,IACnF;AAEO,IAAM,OAAO,CAAC,YAAkC;AACrD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,QAAQ,MAAM,CAAC;AAAA,IACjF;AAEO,IAAM,QAAQ,CAAC,YAAkC;AACtD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,SAAS,OAAO,CAAC;AAAA,IACnF;AAEO,IAAM,OAAO,CAAC,YAAkC;AACrD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,QAAQ,MAAM,CAAC;AAAA,IACjF;AACO,IAAM,QAAQ,CAAC,YAAkC;AACtD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,SAAS,OAAO,CAAC;AAAA,IACnF;AAOO,IAAM,sBAAsB,CAAC,eAChC,4BAA4B,UAA0B;AAGnD,IAAM,OAAO,CAAC,SAAyB,eAAqC;AACjF,UAAI;AACJ,cAAQ,WAAW,IAAI;AAAA,QACrB;AACE,iBAAO;AACP;AAAA,QACF;AACE,iBAAO;AACP;AAAA,QACF;AACE,iBAAO;AACP;AAAA,QACF;AACE,iBAAO;AACP;AAAA,QACF;AACE,iBAAO;AACP;AAAA,QACF;AACE,gBAAM,IAAI,WAAW,0EAA0E,WAAW,EAAE,EAAE;AAAA,MAClH;AACA,cAAQ;AAAA,QACJ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,QAAQ,MAAM,QAAW,WAAW,UAAU,WAAW,EAAE;AAAA,MAAC;AAAA,IAClH;AAOA,IAAM,mCAAmC,CAAC,WAAkD;AAC1F,YAAM,MAAO,OAAO,UAAU,KAAK,OAAO,CAAC,EAAE,SAAS,IAAK,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAC,IAAI;AAC5F,YAAM,MAAO,OAAO,UAAU,KAAK,OAAO,CAAC,EAAE,SAAS,IAAK,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAC,IAAI;AAC5F,aAAO,4BAA4B,EAAC,KAAK,IAAG,CAAC;AAAA,IAC/C;AAEO,IAAM,OAAO,CAAC,SAAyB,mBAAyC;AACrF,YAAM,aAAa,QAAQ,OAAO,WAAW,IAAI,iBAAiB,iCAAiC,QAAQ,MAAM;AACjH,YAAM,WAAW,0BAA0B,QAAQ,OAAO,CAAC,EAAE,QAAQ;AACrE,cAAQ;AAAA,QACJ;AAAA,UACI,QAAQ,OAAO,CAAC;AAAA,UAAG;AAAA,UAAQ,OAAK,SAAS,CAAC;AAAA,UAA2B;AAAA,4BACnD,QAAQ,YAAY,QAAQ,IAAI,WAAW,GAAG;AAAA,4BAC9C,QAAQ,YAAY,QAAQ,IAAI,WAAW,GAAG;AAAA;AAAA,UAEhE,WAAW;AAAA,QAAQ;AAAA,QACvB,EAAC,QAAQ,CAAC,CAAC,EAAC;AAAA,MAAC;AAAA,IACnB;AAEO,IAAM,OAAO,CAAC,YAAkC;AACrD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,QAAQ,MAAM,CAAC;AAAA,IACjF;AAEO,IAAM,MAAM,CAAC,YAAkC;AACpD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,OAAO,KAAK,CAAC;AAAA,IAC/E;AAEO,IAAM,OAAO,CAAC,YAAkC;AACrD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,QAAQ,MAAM,CAAC;AAAA,IACjF;AAMO,IAAM,uBAAuB,CAAC,eACjC,4BAA4B,UAA6B;AAEtD,IAAM,MAAM,CAAC,SAAyB,eAAsC;AACjF,YAAM,WAAW,0BAA0B,QAAQ,OAAO,CAAC,EAAE,QAAQ;AACrE,cAAQ,QAAQ;AAAA,QACZ,QAAQ,OAAO,CAAC;AAAA,QAAG;AAAA,QAAO,OAAK,YAAY,CAAC;AAAA,QAAK;AAAA,uBAChC,QAAQ,IAAI,WAAW,KAAK;AAAA;AAAA,kBAEjC,QAAQ,QAAQ,QAAQ;AAAA;AAAA;AAAA;AAAA,wBAIlB,QAAQ,cAAc,QAAQ;AAAA;AAAA;AAAA,QAGhD,WAAW;AAAA,MAAQ,CAAC;AAAA,IAC1B;AAEO,IAAM,UAAU,CAAC,UAAU,UAAU;AAAA,YAChC,OAAO;AAAA,YACP,OAAO;AAAA,YACP,OAAO;AAAA,YACP,OAAO;AAAA,YACP,OAAO;AAAA,YACP,OAAO;AAAA;AAAA,sBAEG,OAAO,cAAc,OAAO;AAAA;AAAA;AAAA;AAAA;AAM3C,IAAM,MAAM,CAAC,YAAkC;AACpD,YAAM,WAAW,0BAA0B,QAAQ,OAAO,CAAC,EAAE,QAAQ;AACrE,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,OAAO,OAAK,YAAY,CAAC,KAAK,QAAQ,QAAQ,CAAC,CAAC;AAAA,IAClH;AAEO,IAAM,MAAM,CAAC,YAAkC;AACpD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,OAAO,KAAK,CAAC;AAAA,IAC/E;AAEO,IAAM,QAAQ,CAAC,YAAkC;AACtD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,SAAS,OAAO,CAAC;AAAA,IACnF;AAEO,IAAM,OAAO,CAAC,YAAkC;AACrD,YAAM,WAAW,0BAA0B,QAAQ,OAAO,CAAC,EAAE,QAAQ;AACrE,cAAQ,QAAQ;AAAA,QACZ,QAAQ,OAAO,CAAC;AAAA,QAAG;AAAA,QAAQ,OAAK,SAAS,CAAC,sBAAsB,CAAC;AAAA,QAA2B,QAAQ,QAAQ;AAAA,MAAC,CAAC;AAAA,IACpH;AAEO,IAAM,YAAY,CAAC,SAAyB,eAAsC;AACvF,YAAM,WAAW,0BAA0B,QAAQ,OAAO,CAAC,EAAE,QAAQ;AACrE,cAAQ,QAAQ;AAAA,QACZ,QAAQ,OAAO,CAAC;AAAA,QAAG;AAAA,QAAa,OAAK,8BAA8B,CAAC,KAAK,CAAC,KAAK,CAAC,YAAY,QAAQ;AAAA,QACpG,6BAA6B,QAAQ,IAAI,WAAW,KAAK;AAAA,QAAM,WAAW;AAAA,MAAQ,CAAC;AAAA,IACzF;AAEO,IAAM,MAAM,CAAC,YAAkC;AACpD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,OAAO,OAAK,IAAI,CAAC,EAAE,CAAC;AAAA,IACtF;AAEO,IAAM,MAAM,CAAC,YAAkC;AACpD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,OAAO,OAAK,IAAI,CAAC,EAAE,CAAC;AAAA,IACtF;AAEO,IAAM,aAAa,CAAC,YAAkC;AAC3D,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,cAAc,OAAK,OAAO,CAAC,EAAE,CAAC;AAAA,IAChG;AAEO,IAAM,OAAO,CAAC,YAAkC;AACrD,YAAM,WAAW,0BAA0B,QAAQ,OAAO,CAAC,EAAE,QAAQ;AACrE,cAAQ,QAAQ;AAAA,QACZ,QAAQ,OAAO,CAAC;AAAA,QAAG;AAAA,QAAQ,OAAK,eAAe,QAAQ,WAAW,CAAC,KAAK,CAAC,WAAW,QAAQ;AAAA,MAAS,CAAC;AAAA,IAC5G;AAEO,IAAM,UAAU,CAAC,YAAkC;AACxD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,WAAW,OAAK,sBAAsB,CAAC,KAAK,CAAC;AAAA,IAC/G;AAOO,IAAM,6BAA6B,CAAC,eACvC,4BAA4B,UAG3B;AAEE,IAAM,cAAc,CAAC,SAAyB,eAA4C;AAC/F,YAAM,WAAW,0BAA0B,QAAQ,OAAO,CAAC,EAAE,QAAQ;AACrE,cAAQ,QAAQ;AAAA,QACZ,QAAQ,OAAO,CAAC;AAAA,QAAG;AAAA,QACnB,OAAK,YAAY,QAAQ,oBAAoB,QAAQ,WAAW,WAAW,KAAK,MAAM,CAAC,WAAW,QAAQ,KACtG,WAAW,IAAI;AAAA,QACnB;AAAA,QAAW,WAAW;AAAA,MAAQ,CAAC;AAAA,IACrC;AAEO,IAAM,MAAM,CAAC,YAAkC;AACpD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,OAAO,KAAK,CAAC;AAAA,IAC/E;AAEO,IAAM,OAAO,CAAC,YAAkC;AACrD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,QAAQ,MAAM,CAAC;AAAA,IACjF;AAEO,IAAM,OAAO,CAAC,YAAkC;AACrD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,QAAQ,MAAM,CAAC;AAAA,IACjF;AAEO,IAAM,MAAM,CAAC,YAAkC;AACpD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,OAAO,KAAK,CAAC;AAAA,IAC/E;AAEO,IAAM,iBAAiB,CAAC,MAAc,QAAQ,CAAC,yBAAyB,CAAC,2BAA2B,CAAC;AAErG,IAAM,OAAO,CAAC,YAAkC;AAErD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,QAAQ,cAAc,CAAC;AAAA,IACzF;AAEO,IAAM,eAAe,CAAC,UAAU,UAAU;AAAA,qBAC5B,OAAO;AAAA,qBACP,OAAO;AAAA,qBACP,OAAO;AAAA;AAAA,oBAER,OAAO,cAAc,OAAO;AAAA,WACrC,eAAe,GAAG,CAAC;AAAA;AAAA;AAIvB,IAAM,qBAAqB,CAAC,MAC/B,uCAAuC,CAAC,qBAAqB,CAAC,MAAM,CAAC,uBAAuB,CAAC;AAE1F,IAAM,WAAW,CAAC,YAAkC;AACzD,YAAM,WAAW,0BAA0B,QAAQ,OAAO,CAAC,EAAE,QAAQ;AACrE,cAAQ,QAAQ;AAAA,QACZ,QAAQ,OAAO,CAAC;AAAA,QAAG;AAAA,QAAY;AAAA,QAAoB,aAAa,QAAQ;AAAA,QAAG;AAAA,QAC3E,QAAQ,OAAO,CAAC,EAAE;AAAA,MAAQ,CAAC;AAAA,IACjC;AAEO,IAAM,kBAAkB,CAAC,SAAyB,eAAwC;AAC/F,YAAM,WAAW,0BAA0B,QAAQ,OAAO,CAAC,EAAE,QAAQ;AACrE,cAAQ,QAAQ;AAAA,QACZ,QAAQ,OAAO,CAAC;AAAA,QAAG;AAAA,QAAmB,OAAK,eAAe,QAAQ,WAAW,CAAC,KAAK,CAAC;AAAA,QACpF,wCAAwC,QAAQ,KAAK,WAAW,KAAK;AAAA,QAAM,WAAW;AAAA,MAAQ,CAAC;AACnG,aAAO;AAAA,IACT;AAEO,IAAM,MAAM,CAAC,YAAkC;AACpD,cAAQ,QAAQ,6BAA6B,QAAQ,OAAO,CAAC,GAAG,OAAO,KAAK,CAAC;AAAA,IAC/E;AAAA;AAAA;;;AC3TA,IAUMC,iBAkBA,gCAyCO;AArEb;AAAA;AAAA;AAIA;AAGA;AACA;AAEA,IAAMA,kBAAiB,CAAC,WAAwC;AAC9D,UAAI,OAAO,CAAC,EAAE,KAAK,WAAW,GAAG;AAC/B,cAAM,IAAI,MAAM,gCAAgC;AAAA,MAClD;AAEA,UAAI,CAAC,CAAC,MAAM,MAAM,KAAK,EAAE,SAAS,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG;AACpD,cAAM,IAAI,MAAM,4CAA4C;AAAA,MAC9D;AAEA,UAAI,OAAO,CAAC,EAAE,KAAK,WAAW,GAAG;AAC/B,cAAM,IAAI,MAAM,uCAAuC;AAAA,MACzD;AAEA,UAAI,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG;AAC3C,cAAM,IAAI,MAAM,mDAAmD;AAAA,MACrE;AAAA,IACF;AAEA,IAAM,iCAAiC,CAAC,WAA+C;AACrF,YAAM,cAAc,OAAO,CAAC,EAAE,KAAK,MAAM;AACzC,kBAAY,CAAC,IAAI,YAAY,CAAC,IAAI;AAElC,YAAM,QAAQ,cAAc,SAAS,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,MAAM,CAAC;AAC1E,YAAM,OAAO,cAAc,QAAQ,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,CAAC;AAC7E,YAAM,SAAS,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,aAAa,CAAC;AAE1E,YAAM,aAAa,UAAU,KAAK,WAAW,IAAI;AACjD,YAAM,WAAW,4BAA4B,OAAO,CAAC,EAAE,QAAQ;AAE/D,YAAM,kBAAkB,CAAC,iBAA+B;AAAA;AAAA,yBAEjC,OAAO,CAAC,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC;AAAA;AAAA,IAE9C,aAAa,iBAAiB,OAAO,MAAM,MAAM,CAAC;AAAA;AAAA,IAElD,QAAQ,QAAQ,CAAC;AAAA;AAAA,IAEjB,aAAa,UAAU,CAAC;AAAA,MACtB,aAAa,sCAAsC,UAAU,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAQ9D,OAAO,YAAY,cAAc,uBAAuB,CAAC;AAAA;AAG7D,aAAO;AAAA,QACL,MAAM;AAAA,QACN,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,UAC3D,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa;AAAA;AAAA,UAAuB,EAAC;AAAA,QACpE;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEO,IAAM,gBAAgB,CAAC,YAAkC;AAC9D,MAAAA,gBAAe,QAAQ,MAAM;AAC7B,cAAQ,QAAQ,+BAA+B,QAAQ,MAAM,CAAC;AAAA,IAChE;AAAA;AAAA;;;ACxEA,IAiBM,6BAqGA,2BAsEA,aAQO,KAIA,KAIA,OAMA,KAIA,KAsBA,KAIA,SAMA,MAMA,gBAMA;AAlQb;AAAA;AAAA;AAGA;AAEA;AAGA;AASA,IAAM,8BACF,CAAC,cAA4B,OAA0B,OAA0B,YAChF,WAAoB,aAAsB,6BAAsC,UAChF,OAAe,OAAe,YAAoB,6BAAsC;AACvF,UAAI;AACJ,UAAI;AACJ,UAAI,OAAO,aAAa,UAAU;AAChC,2BAAmB,mBAAmB,CAACC,IAAGC,OAAM,GAAG,QAAQ,KAAKD,EAAC,MAAMC,EAAC;AAAA,MAC1E,WAAW,OAAO,aAAa,YAAY;AACzC,2BAAmB,mBAAmB;AAAA,MACxC,OAAO;AACL,2BAAmB,SAAS;AAC5B,2BAAmB,SAAS;AAAA,MAC9B;AAEA,YAAM,SAAS,eAAe,cAAc,YAAY,WAAW,QAAQ,CAAC;AAC5E,YAAM,IAAI,cAAc,SAAS,OAAO,MAAM,QAAQ,CAAC;AACvD,YAAM,IAAI,cAAc,SAAS,OAAO,MAAM,QAAQ,CAAC;AAEvD,UAAI;AACJ,UAAI,WAAW;AACb,YAAI,aAAa;AACf,gBAAM,gBAAgB,UAAU,KAAK,KAAK,MAAM;AAChD,gBAAM,gBAAgB,UAAU,KAAK,KAAK,MAAM;AAChD,gBAAM,uBAAuB,MAAM,SAAS,KAAK,MAAM,MAAM,SAAS,CAAC,IAAI,MAAM;AACjF,gBAAM,uBAAuB,MAAM,SAAS,KAAK,MAAM,MAAM,SAAS,CAAC,IAAI,MAAM;AACjF,cAAI,iBAAiB,eAAe;AAClC,yBAAa,OAAO;AAAA,cAChB;AAAA,cACA;AAAA,gBACI,gBAAgB,GAAG,EAAE,KAAK,KAAK,IAAI,EAAE,YAAY,GAAG,CAAC,QAAQ,EAAE,YAAY,YAAY;AAAA,gBACvF,gBAAgB,GAAG,EAAE,KAAK,KAAK,IAAI,EAAE,YAAY,GAAG,CAAC,QAAQ,EAAE,YAAY,YAAY;AAAA,cAAC;AAAA,YAAC;AAAA,UACnG,OAAO;AACL,yBAAa;AAAA,kCACS,OAAO,gBAAgB,iBAAiB,CAAC;AAAA,4BAC/C,EAAE,2BAA2B,iBAAiB,MAAM,CAAC;AAAA,4BACrD,EAAE,2BAA2B,iBAAiB,MAAM,CAAC;AAAA,cAEjE,OAAO;AAAA,cACH;AAAA,cACA;AAAA,gBACI,+BAA+B,uBAC3B,EAAE,YAAY,cAAc,IAC5B,GAAG,EAAE,KAAK,KAAK,IAAI,EAAE,YAAY,cAAc,CAAC;AAAA,gBACpD,+BAA+B,uBAC3B,EAAE,YAAY,cAAc,IAC5B,GAAG,EAAE,KAAK,KAAK,IAAI,EAAE,YAAY,cAAc,CAAC;AAAA,cAAiB;AAAA,YAAC,CAAC;AAAA;AAAA,UAErF;AAAA,QACF,OAAO;AACL,uBAAa,OAAO;AAAA,YAChB;AAAA,YAAc,iBAAiB,EAAE,YAAY,YAAY,GAAG,EAAE,YAAY,YAAY,CAAC;AAAA,UAAC;AAAA,QAC9F;AAAA,MACF,OAAO;AACL,YAAI,CAAC,aAAa;AAChB,gBAAM,IAAI,MAAM,sFAAsF;AAAA,QACxG;AAEA,cAAM,mBAAmB,CAAC,QAAgB,GAAW,WAAW,OAAO;AACrE,gBAAM,cAAc,eAAe,CAAC,eAAe,CAAC;AACpD,gBAAM,cAAc,eAAe,CAAC,eAAe,CAAC;AACpD,iBAAO;AAAA,+BACc,CAAC,MAAM,OAAO,gBAAgB,qBAAqB,CAAC,GAAG,CAAC;AAAA,yBAC9D,CAAC,MAAM,EAAE,2BAA2B,gBAAgB,CAAC,IAAI,MAAM,CAAC;AAAA,yBAChE,CAAC,MAAM,EAAE,2BAA2B,gBAAgB,CAAC,IAAI,MAAM,CAAC;AAAA,wBACjE,CAAC,aAAa,CAAC;AAAA,wBACf,CAAC,aAAa,CAAC;AAAA,4BACX,CAAC,aAAa,CAAC;AAAA,4BACf,CAAC,aAAa,CAAC;AAAA,cAC7B,MAAM,IAAI,CAAC,OAAO,QAAQ,IAAI,iBAAiB,aAAa,WAAW,CAAC;AAAA;AAAA,QAE9E;AACA,YAAI,6BAA8B;AAChC,uBAAa;AAAA;AAAA,cAET,iBAAiB,QAAQ,GAAG,KAAK,CAAC;AAAA,cAClC,iBAAiB,QAAQ,GAAG,KAAK,CAAC;AAAA,cAClC,iBAAiB,QAAQ,GAAG,KAAK,CAAC;AAAA,cAClC,iBAAiB,QAAQ,GAAG,KAAK,CAAC;AAAA;AAAA,QAExC,OAAO;AACL,uBAAa;AAAA,cACT,iBAAiB,0BAA0B,CAAC,CAAC;AAAA,cAC7C,iBAAiB,0BAA0B,CAAC,CAAC;AAAA,cAC7C,iBAAiB,0BAA0B,CAAC,CAAC;AAAA,cAC7C,iBAAiB,0BAA0B,CAAC,CAAC;AAAA;AAAA,QAEnD;AAAA,MACF;AAEA,aAAO;AAAA,UACH,aAAa,gBAAgB,YAAY,KAAK,EAAE,iBAAiB,GAAG,GAAG,MAAM,CAAC;AAAA;AAAA,UAE9E,4BAA4B,EAAE;AAAA;AAAA,UAE9B,aAAa,UAAU,CAAC;AAAA,UACxB,aAAa,sCAAsC,mBAAmB,CAAC;AAAA,UACvE,UAAU;AAAA;AAAA,IAEhB;AAEJ,IAAM,4BACF,CAAC,MAAc,UAAkB,GAAe,GAAe,UAC9D,0BAAmC,iBAAyB,EAAE,aAA0B;AACvF,YAAM,cAAc,CAAC,UAAU,SAAS,EAAE,MAAM,EAAE,IAAI;AACtD,UAAI,cAAc,EAAE;AACpB,UAAI,aAAa,UAAU,KAAK,EAAE,IAAI;AAEtC,UAAI,YAAY;AAChB,UAAI,8BAA8B;AAGlC,YAAM,cAAc,CAAC,WAAW;AAChC,UAAI,aAAa;AACf,cAAM,kBAAkB,cAAc,UAAU,EAAE,MAAM,EAAE,MAAM,KAAK;AACrE,YAAI,CAAC,iBAAiB;AACpB,gBAAM,IAAI,MAAM,8CAA+C;AAAA,QACjE;AACA,sBAAc;AACd,qBAAa,UAAU,KAAK,WAAW;AACvC,cAAM,gBAAgB,UAAU,KAAK,EAAE,IAAI,MAAM;AACjD,cAAM,gBAAgB,UAAU,KAAK,EAAE,IAAI,MAAM;AACjD,cAAM,uBAAuB,EAAE,KAAK,SAAS,KAAK,EAAE,KAAK,EAAE,KAAK,SAAS,CAAC,IAAI,MAAM;AACpF,cAAM,uBAAuB,EAAE,KAAK,SAAS,KAAK,EAAE,KAAK,EAAE,KAAK,SAAS,CAAC,IAAI,MAAM;AACpF,oBAAY,KAAK,aAAa;AAC9B,oBAAY,KAAK,aAAa;AAC9B,oBAAY,KAAK,oBAAoB;AACrC,oBAAY,KAAK,oBAAoB;AAErC,YAAI,kBAAkB;AACtB,iBAAS,IAAI,GAAG,IAAI,YAAY,QAAQ,KAAK;AAC3C,gBAAM,OAAO,EAAE,KAAK,EAAE,KAAK,SAAS,CAAC,KAAK;AAC1C,gBAAM,OAAO,EAAE,KAAK,EAAE,KAAK,SAAS,CAAC,KAAK;AAC1C,cAAI,SAAS,MAAM;AACjB,+BAAmB;AAAA,UACrB,OAAO;AACL;AAAA,UACF;AAAA,QACF;AACA,YAAI,kBAAkB,MAAM,GAAG;AAC7B,wCAA8B;AAC9B,sBAAY;AAAA,QACd,WAAW,iBAAiB,iBAAiB,wBAAwB,sBAAsB;AACzF,sBAAY;AAAA,QACd;AAAA,MACF,OAAO;AAEL,oBAAY;AAAA,MACd;AACA,kBAAY,KAAK,SAAS;AAE1B,aAAO;AAAA,QACL;AAAA,QACA,aAAa;AAAA,UACX,MAAM,WAAW,YAAY,IAAI,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,KAAK,GAAG;AAAA,UAC9D,mBAAmB,CAAC,QAAQ,MAAM;AAAA,QACpC;AAAA,QACA,iBAAiB,CAAC,iBAAiB;AAAA,UAC/B;AAAA,UAAc,EAAE;AAAA,UAAM,EAAE;AAAA,UAAM;AAAA,UAAa;AAAA,UAAW;AAAA,UAAa;AAAA,UAA6B;AAAA,UAChG,EAAE;AAAA,UAAU,EAAE;AAAA,UAAU;AAAA,UAAgB;AAAA,QAAwB;AAAA,QACpE,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,eAAc,CAAC;AAAA,UACvD,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa,KAA0B;AAAA;AAAA,UAAsB,EAAC;AAAA,UAC3F,iBAAiB;AAAA,YACf,EAAC,uBAAuB,MAAM,KAAK,KAAK,UAAU,KAAK,WAAW,IAAI,CAAC,EAAC;AAAA,YACxE,GAAG,2BAA2B,EAAE,MAAM,EAAE,MAAM,WAAW;AAAA,UAC3D;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEJ,IAAM,cACF,CAAC,SAAyB,MAAc,UAA8B,0BACrE,UAAmB,mBAAkC;AACpD,cAAQ,QAAQ;AAAA,QACZ;AAAA,QAAM,YAAY;AAAA,QAAI,QAAQ,OAAO,CAAC;AAAA,QAAG,QAAQ,OAAO,CAAC;AAAA,QAAG;AAAA,QAAU;AAAA,QACtE;AAAA,MAAc,CAAC;AAAA,IACrB;AAEG,IAAM,MAAM,CAAC,YAAkC;AACpD,kBAAY,SAAS,OAAO,CAAC,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC,EAAE;AAAA,IACnD;AAEO,IAAM,MAAM,CAAC,YAAkC;AACpD,kBAAY,SAAS,OAAO,CAAC,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC,EAAE;AAAA,IACnD;AAEO,IAAM,QAAQ,CAAC,YAAkC;AACtD;AAAA,QACI;AAAA,QAAS;AAAA,QAAU,EAAC,QAAQ,CAAC,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,KAAK,QAAQ,CAAC,GAAG,MAAM,aAAa,CAAC,KAAK,CAAC,IAAG;AAAA,QAAI;AAAA,QACtG;AAAA;AAAA,MAAwB;AAAA,IAC9B;AAEO,IAAM,MAAM,CAAC,YAAkC;AACpD,kBAAY,SAAS,OAAO,CAAC,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC,EAAE;AAAA,IACnD;AAEO,IAAM,MAAM,CAAC,YAAkC;AACpD,YAAM,OAAO,cAAc,SAAS,QAAQ,OAAO,CAAC,EAAE,UAAU,QAAQ,OAAO,CAAC,EAAE,IAAI,EAAE,KAAK;AAC7F,YAAM,WAAW,SAAS,QAAQ,UAAU;AAC5C;AAAA,QACI;AAAA,QAAS;AAAA,QAAQ,EAAC,QAAQ,CAAC,GAAG,MAAM,cAAc,CAAC,IAAI,CAAC,KAAK,QAAQ,CAAC,GAAG,MAAM,qBAAqB,CAAC,IAAI,CAAC,IAAG;AAAA,QAC7G;AAAA,wBACkB,IAAI,SAAS,IAAI,QAAQ,IAAI;AAAA,iBACpC,IAAI;AAAA,iBACJ,IAAI;AAAA,uBACE,IAAI;AAAA,iBACV,IAAI;AAAA;AAAA,+BAEU,IAAI,6BAA6B,IAAI,qBAAqB,IAAI,IACnF,QAAQ;AAAA;AAAA,oCAEkB,IAAI,eAAe,IAAI,cAAc,IAAI;AAAA;AAAA,oBAEzD,IAAI;AAAA;AAAA;AAAA,MAEjB;AAAA,IACP;AAEO,IAAM,MAAM,CAAC,YAAkC;AACpD,kBAAY,SAAS,OAAO,CAAC,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC,EAAE;AAAA,IACnD;AAEO,IAAM,UAAU,CAAC,YAAkC;AACxD;AAAA,QACI;AAAA,QAAS;AAAA,QAAY,EAAC,QAAQ,CAAC,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,QAAQ,CAAC,GAAG,MAAM,aAAa,CAAC,IAAI,CAAC,IAAG;AAAA,QAAI;AAAA,QACtG;AAAA;AAAA,MAAwB;AAAA,IAC9B;AAEO,IAAM,OAAO,CAAC,YAAkC;AACrD;AAAA,QACI;AAAA,QAAS;AAAA,QAAS,EAAC,QAAQ,CAAC,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,QAAQ,CAAC,GAAG,MAAM,aAAa,CAAC,IAAI,CAAC,IAAG;AAAA,QAAI;AAAA,QACnG;AAAA;AAAA,MAAwB;AAAA,IAC9B;AAEO,IAAM,iBAAiB,CAAC,YAAkC;AAC/D;AAAA,QACI;AAAA,QAAS;AAAA,QAAmB,EAAC,QAAQ,CAAC,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,KAAK,QAAQ,CAAC,GAAG,MAAM,aAAa,CAAC,KAAK,CAAC,IAAG;AAAA,QAC3G;AAAA,QAAW;AAAA;AAAA,MAAwB;AAAA,IACzC;AAEO,IAAM,cAAc,CAAC,YAAkC;AAC5D;AAAA,QACI;AAAA,QAAS;AAAA,QAAgB,EAAC,QAAQ,CAAC,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,KAAK,QAAQ,CAAC,GAAG,MAAM,aAAa,CAAC,KAAK,CAAC,IAAG;AAAA,QACxG;AAAA,QAAW;AAAA;AAAA,MAAwB;AAAA,IACzC;AAAA;AAAA;;;ACtQA,IAiBa,sBAuBA,8BAaA,0BAUA;AA/Db;AAAA;AAAA;AAGA;AACA;AAaO,IAAM,uBACT,CAAC,YAA0C,WAAmB,WAAW,UAAkB;AACzF,cAAQ,WAAW,YAAY;AAAA,QAC7B,KAAK;AACH,iBAAO,sBAAsB,SAAS;AAAA,QACxC,KAAK;AACH,iBAAO,YAAY,SAAS,YAAY,SAAS;AAAA,QACnD,KAAK;AACH,iBAAO,wBAAwB,SAAS,IAAI,QAAQ,yBAAyB,SAAS,IAClF,QAAQ;AAAA,QACd,KAAK;AACH,iBAAO,eAAe,SAAS,cAAc,SAAS,UAAU,QAAQ,8BACpE,QAAQ;AAAA,QACd,KAAK;AACH,iBAAO,kBAAkB,QAAQ,6CAA6C,SAAS;AAAA,QACzF,KAAK;AACH,iBAAO;AAAA,QAET;AACE,gBAAM,IAAI,MAAM,0BAA0B,WAAW,UAAU,EAAE;AAAA,MACrE;AAAA,IACF;AAEG,IAAM,+BACT,CAAC,YAA0C,mBAAqC;AAC9E,UAAI,WAAW,eAAe,QAAQ;AACpC,uBAAe;AAAA,UACX,EAAC,qBAAsB,MAAM,WAAW,QAAQ;AAAA,UAAG,EAAC,qBAAsB,MAAM,WAAW,QAAQ;AAAA,QAAC;AAAA,MAC1G,WAAW,WAAW,eAAe,eAAe;AAClD,uBAAe;AAAA,UACX,EAAC,qBAAsB,MAAM,WAAW,MAAM;AAAA,UAAG,EAAC,qBAAsB,MAAM,WAAW,KAAK;AAAA,QAAC;AAAA,MACrG,WAAW,WAAW,eAAe,aAAa;AAChD,uBAAe,KAAK,EAAC,qBAAsB,MAAM,WAAW,MAAM,CAAC;AAAA,MACrE;AAAA,IACF;AAEG,IAAM,2BAA2B,CAAC,YAA0C,aAAgC;AACjH,UAAI,WAAW,eAAe,QAAQ;AACpC,iBAAS,KAAK,EAAC,MAAM,YAAY,MAAM,MAAK,GAAG,EAAC,MAAM,YAAY,MAAM,MAAK,CAAC;AAAA,MAChF,WAAW,WAAW,eAAe,eAAe;AAClD,iBAAS,KAAK,EAAC,MAAM,SAAS,MAAM,MAAK,GAAG,EAAC,MAAM,QAAQ,MAAM,MAAK,CAAC;AAAA,MACzE,WAAW,WAAW,eAAe,aAAa;AAChD,iBAAS,KAAK,EAAC,MAAM,SAAS,MAAM,MAAK,CAAC;AAAA,MAC5C;AAAA,IACF;AAEO,IAAM,oCACT,CAAC,eAAgF;AAC/E,YAAM,aAAa,YAAY,cAAwB;AACvD,UAAI,eAAe,eAAe;AAChC,cAAM,CAAC,OAAO,IAAI,IAAI,YAAY,qBAAyC,CAAC,KAAK,GAAG;AACpF,eAAO,EAAC,YAAY,OAAO,KAAI;AAAA,MACjC,WAAW,eAAe,QAAQ;AAChC,cAAM,CAAC,SAAS,OAAO,IAAI,YAAY,qBAAyC,CAAC,UAAU,QAAQ;AACnG,eAAO,EAAC,YAAY,SAAS,QAAO;AAAA,MACtC,WAAW,eAAe,aAAa;AACrC,cAAM,CAAC,KAAK,IAAI,YAAY,qBAAiC,CAAC,IAAI;AAClE,eAAO,EAAC,YAAY,MAAK;AAAA,MAC3B;AACA,aAAO,EAAC,WAAU;AAAA,IACpB;AAAA;AAAA;;;AC7EJ,IAqBa,aAeA;AApCb;AAAA;AAAA;AAqBO,IAAM,cAAc,CAAC,WAAmB,aAAqB;AAClE,cAAQ,WAAW;AAAA,QACjB,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO,QAAQ,QAAQ;AAAA,QACzB,KAAK;AACH,iBAAO,QAAQ,QAAQ;AAAA,QACzB,KAAK;AACH,iBAAO,QAAQ,QAAQ;AAAA,QACzB;AACE,gBAAM,IAAI,MAAM,GAAG,SAAS,8BAA8B;AAAA,MAC9D;AAAA,IACF;AAEO,IAAM,cAAc,CAAC,YAA6B;AAAA,QACjD,UAAU,mDAAmD,EAAE;AAAA;AAAA;AAAA;;;ACrCvE,IAqBa;AArBb;AAAA;AAAA;AAqBO,IAAM,gBAAgB,CAAC,cAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UAO3C,SAAS,YAAY,SAAS,YAAY,SAAS;AAAA;AAAA;AAAA;AAAA;;;AC5B7D,IA8BM,4BAiBA,wBAyBO,4BAuFP,wBAiBA,yBAKO,wBAiKP,yBA8EO;AApab;AAAA;AAAA;AAqBA;AAEA;AAEA;AACA;AAEA;AAEA,IAAM,6BAA6B,CAACC,YAAoB,cAA8B;AACpF,UAAIA,YAAW;AACb,eAAO;AAAA;AAAA;AAAA,wDAG6C,YAAY,mBAAmB,EAAE;AAAA;AAAA,MAGvF,OAAO;AACL,eAAO;AAAA;AAAA;AAAA,gDAGqC,YAAY,mBAAmB,EAAE;AAAA;AAAA,MAE/E;AAAA,IACF;AAEA,IAAM,yBAAyB,CAAC,YAAqB,qBAA6B;AAChF,UAAI,YAAY;AACd,eAAO;AAAA;AAAA;AAAA;AAAA,UAID,qBAAqB,IAAI,KAAK,6DAA6D;AAAA;AAAA;AAAA;AAAA;AAAA,YAKzF,qBAAqB,IAAI,KAAK,2CAA2C;AAAA;AAAA,MAEnF,OAAO;AACL,eAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAMC,qBAAqB,IAAI,KAAK,yCAAyC;AAAA;AAAA,MAEjF;AAAA,IACF;AAEO,IAAM,6BACT,CAAC,eAAyB,eAAyC,OAAO,OAAO,WAChF,aAAa,OAAO,YAAY,IAAI,SAAS,OAAO,kBAAkB,OAAe;AACpF,YAAM,aAAa,cAAc,CAAC,IAAI,cAAc,CAAC;AACrD,YAAM,aAAa,cAAc,CAAC,IAAI,cAAc,CAAC;AACrD,YAAM,aAAa,aAAa,aAAa;AAC7C,YAAM,aAAa,aAAa,YAAY;AAC5C,YAAM,mBAAmB,aAAa,cAAc,CAAC;AACrD,YAAM,gBAAgB,YAAY,cAAc,CAAC;AAEjD,UAAI,GAAI,cAAc,qBAAqB,KAAK,cAAc,CAAC,MAAM,KAC7D,CAAC,eAAe,qBAAqB,KAAK,qBAAqB,OACjE,aAAa,cAAc,CAAC,MAAM,KAAK,YAAY,cAAc,CAAC,MAAM,KAAK,cAAc,CAAC,MAAM,IAAI;AAC1G,cAAM,IAAI,MAAM,iBAAiB,UAAU,8BACvC,gBAAgB,yBAAyB,cAAc,CAAC,CAAC;AAAA,oCACjC,gBAAgB;AAAA,eACrC,UAAU,yCAAyC,cAAc,CAAC,CAAC,eACtE,SAAS,0CAA0C,cAAc,CAAC,CAAC,kBACnE,cAAc,CAAC,CAAC,aAAa;AAAA,MACnC;AACA,aAAO;AAAA,yCAC4B,gBAAgB,IAAI,IAAI,MAAM,aAAa,gBAAgB,MAAM,UAAU;AAAA,2CACzE,IAAI,MAAM,aAAa,cAAc,CAAC,CAAC,MAAM,SAAS;AAAA;AAAA,uBAE1E,cAAc,CAAC,CAAC;AAAA,uBAChB,cAAc,CAAC,CAAC;AAAA,2BACZ,gBAAgB;AAAA,oBACvB,SAAS;AAAA;AAAA,2BAEF,cAAc,CAAC,CAAC,KAAK,cAAc,CAAC,CAAC,KAAK,cAAc,CAAC,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAUrE,SAAS,MAAM,iBAAiB;AAAA,IAC5C,YAAY,sBAAsB,UAAU,gBAAgB,YAAY,CAAC,MAAM,EAAE;AAAA,8CACvC,UAAU;AAAA;AAAA,oBAEpC,SAAS,GAAG,KAAK,KAAK,kBAAkB,SAAS,CAAC,KAAK,0CAA0C;AAAA,iBACpG,SAAS,qBAAqB,eAAe,KAAK,GAAG;AAAA;AAAA,wBAE9C,IAAI;AAAA;AAAA;AAAA,8BAGE,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAM/B,2BAA2B,YAAY,SAAS,CAAC;AAAA;AAAA;AAAA;AAAA,0CAInB,aAAa;AAAA;AAAA;AAAA,sFAI7C,YAAY,mBAAmB,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAU/B,qBAAqB,IAAI,KAAK,4DAA4D;AAAA;AAAA,YAE1F,uBAAuB,YAAY,gBAAgB,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAU5D;AAEJ,IAAM,yBAAyB,CAACA,YAAoB,cAA8B;AAChF,UAAIA,YAAW;AACb,eAAO;AAAA;AAAA;AAAA,yCAG8B,YAAY,mBAAmB,EAAE;AAAA;AAAA,MAGxE,OAAO;AACL,eAAO;AAAA;AAAA;AAAA,iCAGsB,YAAY,mBAAmB,EAAE;AAAA;AAAA,MAEhE;AAAA,IACF;AAEA,IAAM,0BAA0B,CAAC,eAC7B,aAAa,kDAAkD;AAI5D,IAAM,yBACT,CAAC,eAAyB,eAAyC,OAAO,OAAO,WAChF,aAAa,OAAO,YAAY,IAAI,SAAS,OAAO,kBAAkB,IACtE,4BAA4B,UAAkB;AAC7C,YAAM,aAAa,cAAc,CAAC,IAAI,cAAc,CAAC;AACrD,YAAM,aAAa,cAAc,CAAC,IAAI,cAAc,CAAC;AACrD,YAAM,aAAa,aAAa,aAAa;AAC7C,YAAM,aAAa,aAAa,YAAY;AAE5C,UAAI,EAAE,aAAa,cAAc,CAAC,MAAM,KAAK,aAAa,cAAc,CAAC,MAAM,KACzE,YAAY,cAAc,CAAC,MAAM,IAAI;AACzC,cAAM,IAAI,MAAM,cAAc,UAAU,yCACpC,cAAc,CAAC,CAAC,gBAAgB,UAAU,yCAC1C,cAAc,CAAC,CAAC,eAAe,SAAS,yCAAyC,cAAc,CAAC,CAAC,EAAE;AAAA,MACzG;AACA,YAAM,gBAAgB,aAAa,cAAc,CAAC;AAClD,YAAM,gBAAgB,aAAa,cAAc,CAAC;AAClD,YAAM,gBAAgB,YAAY,cAAc,CAAC;AACjD,YAAM,gBAAgB,4BAClB;AAAA;AAAA;AAAA,gDAGsC,UAAU;AAAA,gDACV,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA,iDAKT,UAAU,2BAA2B,cAAc,CAAC,CAAC;AAAA,mDACnD,UAAU,2BAA2B,cAAc,CAAC,CAAC;AAAA,YAC5F,uBAAuB,YAAY,SAAS,CAAC;AAAA;AAAA;AAAA;AAAA,iDAIR,SAAS,2BAA2B,cAAc,CAAC,CAAC;AAAA,uDAC9C,UAAU,2BAA2B,cAAc,CAAC,CAAC;AAAA;AAAA;AAAA,uCAGrE,YAAY,mBAAmB,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,4BAO5C,IAAI;AAAA;AAAA;AAAA,2DAG2B,cAAc,CAAC,CAAC;AAAA;AAAA;AAAA,0BAI7D,aAAa,oCAAoC,cAAc,CAAC,CAAC,OACpD,iCAAiC,cAAc,CAAC,CAAC,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0DAUzB,cAAc,CAAC,CAAC;AAAA;AAAA,4DAEd,cAAc,CAAC,CAAC;AAAA;AAAA;AAAA;AAAA,QAKlE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,4CAMkC,UAAU;AAAA;AAAA,kCAEpB,aAAa;AAAA,kCACb,aAAa;AAAA,kCACb,aAAa;AAAA;AAAA;AAAA;AAAA,sCAIT,aAAa;AAAA,wCACX,aAAa;AAAA;AAAA;AAAA,QAG7C,uBAAuB,YAAY,SAAS,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,sCAKf,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,8BAMrB,YAAY,mBAAmB,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAOvC,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAOpB,wBAAwB,UAAU,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBrC,aAAO;AAAA,yCAC4B,IAAI,KAAK,UAAU,MAAM,UAAU;AAAA,yCACnC,IAAI,KAAK,UAAU,MAAM,SAAS;AAAA,yBAClD,cAAc,CAAC,CAAC;AAAA,yBAChB,cAAc,CAAC,CAAC;AAAA,sBACnB,SAAS;AAAA;AAAA,2BAEJ,cAAc,CAAC,CAAC,KAAK,cAAc,CAAC,CAAC,KAAK,cAAc,CAAC,CAAC;AAAA;AAAA;AAAA;AAAA,kBAInE,SAAS,MAAM,iBAAiB;AAAA,MAC5C,YAAY,sBAAsB,UAAU,gBAAgB,YAAY,CAAC,MAAM,EAAE;AAAA,sBAE7E,SAAS,GAAG,KAAK,KAAK,kBAAkB,SAAS,CAAC,KAAK,0CAA0C;AAAA,mBACxF,SAAS,qBAAqB,eAAe,KAAK,GAAG;AAAA;AAAA,4BAE5C,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAQ1B,aAAa;AAAA;AAAA;AAAA,IAGf;AAEJ,IAAM,0BACF,CAAC,WAAmB,SAAkB,iBAAyB,WAC9D,aAAuC,iBAAiB,UAAkB;AACzE,YAAM,CAAC,aAAa,aAAa,UAAU,IAAI;AAC/C,YAAM,CAAC,eAAe,WAAW,WAAWC,eAAc,IAAI;AAC9D,YAAM,iBAAiB,iBAAiB,aAAa,UAAU;AAC/D,YAAM,iBAAiB,iBAAiB,aAAa,UAAU;AAC/D,YAAM,WAAW,4BAA4B,UAAU,CAAC,EAAE,KAAK,MAAM;AACrE,YAAM,cAAc,MAAM;AACxB,cAAM,QAAQ,UAAU;AACxB,cAAM,YAAY,cAAc;AAChC,YAAI,SAAS,iBAAiB,UAAU,KAAK,OAAO;AACpD,iBAAS,IAAI,QAAQ,IAAI,GAAG,IAAI,YAAY,GAAG,KAAK,GAAG,KAAK,KAAK;AAC/D,oBAAU;AAAA,WAAc,CAAC,OAAO,YAAY,IAAI,gBAAgB,CAAC,MAAM,cAAc;AAAA,QACvF;AACA,uBAAe,QAAQ,OAAK;AAC1B,oBAAU;AAAA,WAAc,CAAC;AAAA,QAC3B,CAAC;AACD,kBAAU;AAAA,WAAc,QAAQ,CAAC;AAAA,8BACX,QAAQ,CAAC;AAC/B,eAAO;AAAA,MACT;AACA,YAAM,cAAc,MAAM;AACxB,cAAM,QAAQ,UAAU;AACxB,cAAM,YAAY,cAAc;AAChC,YAAI,SAAS,iBAAiB,UAAU,KAAK,OAAO;AACpD,iBAAS,IAAI,QAAQ,IAAI,GAAG,IAAI,YAAY,GAAG,KAAK,GAAG,KAAK,KAAK;AAC/D,oBAAU;AAAA,WAAc,CAAC,OAAO,YAAY,IAAI,gBAAgB,CAAC,MAAM,cAAc;AAAA,QACvF;AACA,uBAAe,QAAQ,OAAK;AAC1B,oBAAU;AAAA,WAAc,CAAC;AAAA,QAC3B,CAAC;AACD,kBAAU;AAAA,WAAc,QAAQ,CAAC;AAAA,8BACX,QAAQ,CAAC;AAC/B,eAAO;AAAA,MACT;AACA,YAAM,SAAS;AAAA,kEAC6C,cAAc,KAAK,OAAO,QAClF,YAAY,WAAW,QAAQ,CAAC;AAAA,oBACtB,YAAY,WAAW,QAAQ,CAAC;AAAA,0BAC1B,SAAS;AAAA;AAAA;AAAA,UAGzB,YAAY,CAAC;AAAA,kBACL,UAAU,aAAa,UAAU,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,kEAKc,cAAc,KAAK,OAAO,QAClF,YAAY,WAAW,QAAQ,CAAC;AAAA,oBACtB,YAAY,WAAW,QAAQ,CAAC;AAAA,0BAC1B,SAAS;AAAA;AAAA;AAAA,UAGzB,YAAY,CAAC;AAAA,kBACL,UAAU,aAAa,UAAU,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,6DAKS,YAAY,WAAW,QAAQ,CAAC;AAAA,0BACnE,SAAS;AAAA;AAAA;AAAA;AAAA,UAKzB,UACI,mBAAmB,iBAAiB,gBAAgB,GAAG,YAAY,WAAW,QAAQ,CAAC,aAAa,MAChE,EAAsC;AAAA,UAC9E,eAAe;AAAA,UACfA,gBAAe,aAAa,qBAAqB,OAAO,CAAC;AAAA;AAAA;AAAA;AAI7D,aAAO;AAAA,IACT;AAEG,IAAM,0BACT,CAAC,QAA+B,sBAAoD,aACnF,qBACA,iBAAiB,UAAyD;AACzE,YAAM,SAAS,OAAO,CAAC,EAAE;AACzB,YAAM,SAAS,OAAO,CAAC,EAAE;AACzB,YAAM,aAAa,OAAO,MAAM,GAAG,EAAE;AACrC,YAAM,aAAa,OAAO,MAAM,GAAG,EAAE;AACrC,YAAM,YAAY,sBAAsB,oBAAoB,MAAM,GAAG,EAAE,IAAI,YAAY,MAAM,GAAG,EAAE;AAClG,YAAM,YAAY,UAAU,KAAK,SAAS;AAC1C,YAAM,YAAY,OAAO,OAAO,SAAS,CAAC;AAC1C,YAAM,WAAW,OAAO,OAAO,SAAS,CAAC;AACzC,YAAM,YAAY,OAAO,OAAO,SAAS,CAAC;AAC1C,YAAM,SAAS,WAAW,MAAM,KAAK,YAAY,MAAM;AAGvD,YAAM,oBAAoB,aAAa,IAAI,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC;AAC/D,YAAM,gBAA0C,CAAC,GAAG,GAAG,CAAC;AACxD,YAAM,WAAW;AAAA,QACf,KAAK,KAAK,YAAY,cAAc,CAAC,IAAI,kBAAkB,CAAC,CAAC;AAAA,QAC7D,KAAK,KAAK,YAAY,cAAc,CAAC,IAAI,kBAAkB,CAAC,CAAC;AAAA,QAC7D,KAAK,KAAK,YAAY,cAAc,CAAC,IAAI,kBAAkB,CAAC,CAAC;AAAA,MAC/D;AAEA,YAAM,aAAa,SAAS,IAAI;AAChC,YAAM,aAAa,CAAC,GAAG,YAAY,WAAW,WAAW,UAAU;AACnE,YAAM,QAAQ,WAAW;AACzB,YAAM,aAAa,CAAC,GAAG,YAAY,UAAU,YAAY,UAAU;AACnE,YAAM,QAAQ,WAAW;AACzB,YAAM,kBAAkB,CAAC,WAAW,WAAW,YAAY,UAAU;AACrE,YAAM,kBAAoC;AAAA,QACxC,EAAC,qBAAsB,MAAM,UAAS;AAAA,QAAG,EAAC,qBAAsB,MAAM,UAAS;AAAA,QAC/E,EAAC,qBAAsB,MAAM,SAAQ;AAAA,MACvC;AACA,mCAA6B,sBAAsB,eAAe;AAClE,sBAAgB,KAAK,GAAG,2BAA2B,WAAW,YAAY,UAAU,CAAC;AACrF,YAAM,oBAAwD,CAAC,QAAQ,MAAM;AAE7E,YAAM,UAAU,OAAO,SAAS;AAChC,UAAI,SAAS;AACX,wBAAgB,KAAK,GAAG,2BAA2B,OAAO,CAAC,EAAE,IAAI,CAAC;AAClE,0BAAkB,KAAK,MAAM;AAAA,MAC/B;AACA,sBAAgB,KAAK,GAAG,2BAA2B,eAAe,CAAC;AAEnE,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,YAAY,UAAU;AAC5B,cAAM,YAAY,iBAAiB,aAAa,OAAO,CAAC,EAAE,UAAU,WAAW,CAAC;AAChF,cAAM,WAAW,4BAA4B,OAAO,CAAC,EAAE,QAAQ;AAE/D,cAAM,IAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,UAAU;AAClE,cAAM,IAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,UAAU;AAClE,cAAM,SAAS,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,gBAAgB,QAAQ,UAAU;AAC9F,cAAM,iBAAiB,CAAC,GAAG,CAAC;AAC5B,YAAI,SAAS;AACX,gBAAM,iBAAiB,iBAAiB,aAAa;AACrD,yBAAe,KAAK,cAAc,QAAQ,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,QAAQ,cAAc,CAAC;AAAA,QACtG;AACA,cAAM,WACF,CAAC,EAAC,MAAM,eAAe,MAAM,MAAK,GAAG,EAAC,MAAM,eAAe,MAAM,MAAK,GAAG,EAAC,MAAM,aAAa,MAAM,MAAK,CAAC;AAC7G,iCAAyB,sBAAsB,QAAQ;AACvD,cAAM,WAAW,4BAA4B,OAAO,KAAK,MAAM;AAC/D,cAAM,kBAAkB,qBAAqB,sBAAsB,OAAO,KAAK,OAAO,QAAQ;AAC9F,cAAM,mBAAmB;AAAA,UACrB;AAAA,UAAY;AAAA,UAAS;AAAA,UAAiB,CAAC,WAAW,GAAG,GAAG,MAAM;AAAA,UAAG,CAAC,YAAY,YAAY,SAAS;AAAA,UACnG;AAAA,QAAc;AAClB,eAAO;AAAA,IAEH,aAAa,iBAAiB,QAAQ,EAAE,0BAA0B,SAAS,EAAE;AAAA,UACzE,GAAG;AAAA,UAAgB;AAAA,QAAM,CAAC;AAAA,IACtC,gBAAgB;AAAA,IAER,SAAS,2BAA2B,mBAAmB,eAAe,UAAU,SAAS,IAChF,uBAAuB,mBAAmB,eAAe,UAAU,SAAS,CAAC;AAAA;AAAA,MAE5F;AACA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa;AAAA,UACX,MAAM,GAAG,iBAAiB,IAAI,qBAAqB,UAAU,IAAI,MAAM,IAAI,cAAc;AAAA,UACzF;AAAA,QACF;AAAA,QACA,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,UAC3D,eAAe,EAAC,GAAG,SAAS,CAAC,GAAG,GAAG,SAAS,CAAC,GAAG,GAAG,SAAS,CAAC,EAAC;AAAA,UAC9D;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA;AAAA;;;AC7fJ,IAiCM,qBA4HO;AA7Jb;AAAA;AAAA;AAqBA;AACA;AAGA;AAEA;AAEA;AACA;AACA;AAEA,IAAM,sBACF,CAAC,gBAAyB,WAAoB,WAAoB,UAAmB,UAAU,OAC9F,YAA4B,oBAAoB,GAAG,oBAAoB,GAAG,mBAAmB,GAC7F,WAAW,UAAkB;AAC5B,YAAM,cAAc,CAACC,sBAA6B;AAChD,gBAAQA,mBAAkB;AAAA,UACxB,KAAK;AACH,mBAAO;AAAA,UACT,KAAK;AACH,mBAAO,kBAAkB,QAAQ;AAAA,UACnC,KAAK;AACH,mBAAO;AAAA,UACT;AACE,kBAAM,IAAI,MAAM,oBAAoBA,iBAAgB,oBAAoB;AAAA,QAC5E;AAAA,MACF;AACA,YAAM,cAAc,CAACA,sBAA6B;AAChD,gBAAQA,mBAAkB;AAAA,UACxB,KAAK;AACH,mBAAO;AAAA,UACT,KAAK;AACH,mBAAO;AAAA,UACT;AACE,kBAAM,IAAI,MAAM,oBAAoBA,iBAAgB,oBAAoB;AAAA,QAC5E;AAAA,MACF;AACA,YAAM,gBAAgB,iBAAiB;AAAA;AAAA,QAGA;AAAA;AAAA;AAIvC,YAAM,kBAAkB,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAOA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQzC,YAAM,UAAU,iBAAiB,6BAA6B;AAC9D,YAAM,SAAS,iBAAiB,6BAA6B;AAC7D,YAAM,MAAM,iBAAiB,QAAQ;AACrC,YAAM,MAAM,iBAAiB,QAAQ;AACrC,YAAM,eAAe;AAAA;AAAA,qBAEN,iBAAiB,kCAAkC,+BAA+B;AAAA,mBACpF,GAAG;AAAA,mBACH,GAAG;AAAA;AAAA,iBAEL,GAAG;AAAA,iBACH,GAAG;AAAA;AAAA;AAAA,gBAGJ,GAAG;AAAA,oBACC,YAAY,mBAAmB,QAAQ,CAAC;AAAA;AAAA;AAAA,8BAG9B,OAAO,2BAA2B,MAAM;AAAA,QAC9D,aAAa;AAAA;AAAA,QAEb,YAAY,iBAAiB,CAAC;AAAA;AAAA;AAIhC,YAAM,UAAU,iBAAkB,aAAa,WAAW;AAAA,wBACxC,iBAAiB;AAAA,MACnC,YAAY,KAC8C;AAAA,wBACxC,iBAAiB;AAAA;AAAA,QAEjC,YAAY;AAAA;AAAA,aAEP,YAAY,mBAAmB,QAAQ,CAAC,WACb,YAAY,YAAY;AAAA,wBACxC,iBAAiB;AAAA,MACnC,YAAY,KAC8C;AAAA,wBACxC,iBAAiB;AAAA;AAAA,QAEjC,YAAY;AAAA;AAAA,aAEP,YAAY,mBAAmB,QAAQ,CAAC;AAE/C,YAAM,UAAU,GAAG,YAAY,iBAAiB,CAAC;AAEjD,YAAM,UAAU,YAAY,kBAAkB,QAAQ;AACtD,YAAM,QACF,iBAAiB,YAAY,mBAAmB,QAAQ,IAAI,YAAY,mBAAmB,QAAQ;AACvG,YAAM,QACF,iBAAiB,YAAY,mBAAmB,QAAQ,IAAI,YAAY,mBAAmB,QAAQ;AACvG,YAAM,kBAAkB,qBAAqB,YAAY,SAAS,QAAQ;AAC1E,YAAM,WAAW;AAAA,yDACkC,KAAK;AAAA,QACtD,iBAAiB,UAAU,OAAO;AAAA;AAAA;AAAA,yDAGe,KAAK;AAAA,QACtD,iBAAiB,UAAU,OAAO;AAAA;AAAA;AAAA,gEAGsB,OAAO;AAAA,0BAC7C,gBAAgB;AAAA;AAAA;AAAA;AAAA,uBAInB,iBAAiB,kCAAkC,+BAA+B;AAAA,QACjG,eAAe;AAAA,QACf,YAAY,OAAO,CAAC;AAAA,QACpB,eAAe;AAAA;AAAA;AAAA;AAIjB,aAAO;AAAA,IACT;AAEG,IAAM,gCACT,CAAC,QAA+B,YAA4B,aAAgC,WAC3F,WAAmB,UAAkB,SAAkB,8BAAoD;AAC1G,YAAM,iBAAiB,WAAW,WAAW;AAC7C,YAAM,aAAa,iBAAiB,OAAO,CAAC,EAAE,KAAK,CAAC,IAAI,OAAO,CAAC,EAAE,KAAK,CAAC;AACxE,YAAM,YAAY,YAAY,CAAC;AAC/B,YAAM,WAAW,iBAAiB,YAAY,CAAC,IAAI,YAAY,CAAC;AAChE,YAAM,YAAY,iBAAiB,YAAY,CAAC,IAAI,YAAY,CAAC;AACjE,YAAM,cAAc,iBAAiB,YAAY,CAAC,IAAI,YAAY,CAAC;AAEnE,YAAM,SAAS,mBAAmB,aAAa,MAAM,KAAK,aAAa,MAAM,MAAM,cAAc,MAAM;AAGvG,YAAM,YAAY,iBAAiB,cAAc,WAAW;AAC5D,YAAM,YAAY,iBAAiB,WAAW,YAAY;AAC1D,YAAM,gBAA0C,CAAC,GAAG,GAAG,CAAC;AACxD,YAAM,oBAAoB,aAAa,IAAI,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC;AAC/D,YAAM,WAAW;AAAA,QACf,KAAK,KAAK,YAAY,cAAc,CAAC,IAAI,kBAAkB,CAAC,CAAC;AAAA,QAC7D,KAAK,KAAK,YAAY,cAAc,CAAC,IAAI,kBAAkB,CAAC,CAAC;AAAA,QAC7D,KAAK,KAAK,YAAY,cAAc,CAAC,IAAI,kBAAkB,CAAC,CAAC;AAAA,MAC/D;AAEA,gBAAU,WAAW,MAAM,iCAAiC,QAAQ,EAAE;AAEtE,YAAM,mBAAmB,SAAU,kBAAkB,aAAa,MAAM,IAAI,IAAI,IAAK;AACrF,YAAM,aAAa,cAAc,CAAC,IAAI,kBAAkB,CAAC;AACzD,YAAM,aAAa,cAAc,CAAC,IAAI,kBAAkB,CAAC;AACzD,YAAM,YAAY,KAAK,IAAI,cAAc,CAAC,IAAI,kBAAkB,cAAc,CAAC,CAAC;AAChF,YAAM,YAAY,YAAY,eAAe;AAC7C,YAAM,YAAY,YAAY,eAAe;AAC7C,YAAM,WAAW,WAAW,cAAc;AAC1C,YAAM,eAAe,SAAS,CAAC,kBAAkB,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC;AAEjE,YAAM,kBAAoC;AAAA,QACxC,EAAC,qBAAsB,MAAM,UAAS;AAAA,QAAG,EAAC,qBAAsB,MAAM,UAAS;AAAA,QAC/E,EAAC,qBAAsB,MAAM,SAAQ;AAAA,QAAG,EAAC,qBAAsB,MAAM,CAAC,WAAW,KAAK,CAAC,GAAG,WAAW,KAAK,CAAC,CAAC,EAAC;AAAA,QAC7G,EAAC,qBAAsB,MAAM,WAAW,QAAO;AAAA,QAAG,EAAC,qBAAsB,MAAM,WAAW,UAAS;AAAA,MACrG;AACA,mCAA6B,YAAY,eAAe;AACxD,sBAAgB,KAAK,GAAG,2BAA2B,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,EAAE,IAAI,CAAC;AAClF,YAAM,oBAAwD,CAAC,QAAQ,MAAM;AAC7E,UAAI,SAAS;AACX,wBAAgB,KAAK,GAAG,2BAA2B,OAAO,CAAC,EAAE,IAAI,CAAC;AAClE,0BAAkB,KAAK,MAAM;AAAA,MAC/B;AACA,sBAAgB,KAAK,GAAG,2BAA2B,WAAW,CAAC;AAE/D,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,WAA8B;AAAA,UAClC,EAAC,MAAM,eAAe,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,eAAe,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,aAAa,MAAM,MAAK;AAAA,UACvG,EAAC,MAAM,OAAO,MAAM,OAAO,QAAQ,EAAC;AAAA,UAAG,EAAC,MAAM,UAAU,MAAM,OAAO,QAAQ,EAAC;AAAA,UAC9E,EAAC,MAAM,YAAY,MAAM,OAAO,QAAQ,EAAC;AAAA,QAC3C;AACA,iCAAyB,YAAY,QAAQ;AAG7C,cAAM,aAAa,SAAS,IAAI;AAChC,cAAM,IAAI,4BAA4B,OAAO,CAAC,EAAE,QAAQ;AACxD,YAAI,mBAAmB;AAAA,qDACsB,SAAS,QAAQ,CAAC,MAAM,CAAC;AAAA,8BAChD,SAAS,QAAQ,CAAC,MAAM,CAAC;AAAA;AAAA,6EAEsB,SAAS,QAAQ,CAAC,MAAM,CAAC;AAAA;AAAA,qCAEjE,SAAS,QAAQ,EAAE;AAAA;AAEhD,cAAM,IAAI;AAAA,UACN;AAAA,UAAK,OAAO,CAAC,EAAE;AAAA,UAAU,OAAO,CAAC,EAAE,KAAK;AAAA,UAAQ,qBAAqB,IAAI,IAAI;AAAA,QAAgB;AACjG,cAAM,IAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,QAAQ,UAAU;AAClF,cAAM,iBAAiB,CAAC,GAAG,CAAC;AAC5B,cAAM,SAAS,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,YAAY,QAAQ,UAAU;AAC1F,YAAI,SAAS;AACX,gBAAM,OAAO,cAAc,QAAQ,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,QAAQ,UAAU;AACxF,yBAAe,KAAK,IAAI;AACxB,8BAAoB;AAAA,0DAC4B,SAAS,QAAQ,CAAC,MAAM,CAAC;AAAA,+BACpD,iBAAiB,MAAM,GAAG,GAAG,SAAS,QAAQ,EAAE;AAAA;AAAA,QAEvE;AAEA,eAAO;AAAA,UACL,cAAc,yBAAyB,CAAC;AAAA;AAAA;AAAA;AAAA,UAIxC,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,GAAG,gBAAgB,MAAM,CAAC;AAAA,UACnF,gBAAgB;AAAA,UAEd;AAAA,UACI;AAAA,UAAgB;AAAA,UAAW;AAAA,UAAW;AAAA,UAAU;AAAA,UAAS;AAAA,UAAY,aAAa,CAAC;AAAA,UAAG,aAAa,CAAC;AAAA,UACpG,aAAa,CAAC;AAAA,UAAG;AAAA,QAAC,CAAC;AAAA,UAEvB,SACI,2BAA2B,mBAAmB,eAAe,GAAG,QAAW,CAAC,gBAAgB,SAAS,IACrG;AAAA,UACI;AAAA,UAAmB;AAAA,UAAe;AAAA,UAAG;AAAA,UAAW,CAAC;AAAA,UAAgB;AAAA,UAAW;AAAA,UAAO;AAAA,UACnF;AAAA,QAAyB,CAAC;AAAA,MACxC;AACA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa;AAAA,UACX,MAAM,GAAG,WAAW,QAAQ,IAAI,gBAAgB,IAAI,MAAM,IAAI,SAAS,IAAI,SAAS,IAAI,QAAQ,IAC5F,UAAU,IAAI,UAAU,IAAI,SAAS;AAAA,UACzC;AAAA,QACF;AAAA,QACA,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,UAC3D,eAAe,EAAC,GAAG,SAAS,CAAC,GAAG,GAAG,SAAS,CAAC,GAAG,GAAG,SAAS,CAAC,EAAC;AAAA,UAC9D;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA;AAAA;;;AC9QJ,IAgBa,8BAuGA;AAvHb;AAAA;AAAA;AAGA;AAEA;AAGA;AACA;AACA;AAMO,IAAM,+BACT,CAAC,QAA+B,YAC/B,+BAAqF;AACpF,YAAM,UAAU,OAAO,SAAS;AAChC,YAAM,cAAc,UAAU,gCAAgC;AAC9D,YAAM,SAAS,OAAO,CAAC,EAAE;AACzB,YAAM,SAAS,OAAO,CAAC,EAAE;AACzB,YAAM,yBAAyB,OAAO,CAAC,IAAI,WAAW;AAEtD,YAAM,gBAAgB,WAAW,WAAW;AAC5C,YAAM,cAAc;AAAA,QAChB;AAAA,QAAQ;AAAA,QAAQ,WAAW;AAAA,QAAW,WAAW;AAAA,QAAM,WAAW;AAAA,QAAS;AAAA,MAAa;AAC5F,YAAM,aAAa,UAAU,KAAK,WAAW;AAE7C,YAAM,kBAAoC;AAAA,QACxC,EAAC,uBAAuB,MAAM,WAAU;AAAA,QAAG,EAAC,uBAAuB,MAAM,WAAW,UAAS;AAAA,QAC7F,EAAC,uBAAuB,MAAM,CAAC,WAAW,QAAQ,CAAC,GAAG,WAAW,QAAQ,CAAC,CAAC,EAAC;AAAA,QAC5E,EAAC,uBAAuB,MAAM,CAAC,WAAW,KAAK,CAAC,GAAG,WAAW,KAAK,CAAC,CAAC,EAAC;AAAA,QACtE,EAAC,uBAAuB,MAAM,uBAAsB;AAAA,MACtD;AACA,mCAA6B,YAAY,eAAe;AACxD,sBAAgB,KAAK,GAAG,2BAA2B,QAAQ,MAAM,CAAC;AAClE,YAAM,oBAAwD,CAAC,QAAQ,MAAM;AAC7E,UAAI,SAAS;AACX,wBAAgB,KAAK,GAAG,2BAA2B,OAAO,CAAC,EAAE,IAAI,CAAC;AAClE,0BAAkB,KAAK,MAAM;AAAA,MAC/B;AACA,sBAAgB,KAAK,GAAG,2BAA2B,WAAW,CAAC;AAE/D,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,SAAS,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,YAAY,MAAM;AAC9E,cAAM,WAAW,4BAA4B,OAAO,KAAK,MAAM;AAC/D,cAAM,kBAAkB,qBAAqB,YAAY,OAAO,KAAK,OAAO,QAAQ;AACpF,cAAM,IAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,MAAM;AAC9D,cAAM,IAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,MAAM;AAC9D,cAAM,YAAY,CAAC,GAAG,CAAC;AACvB,YAAI,SAAS;AACX,oBAAU,KAAK,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,MAAM,CAAC;AAAA,QAC9E;AAEA,cAAM,WAA8B;AAAA,UAClC,EAAC,MAAM,eAAe,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,aAAa,MAAM,OAAO,QAAQ,WAAW,UAAU,OAAM;AAAA,UACxG,EAAC,MAAM,WAAW,MAAM,OAAO,QAAQ,EAAC;AAAA,UAAG,EAAC,MAAM,QAAQ,MAAM,OAAO,QAAQ,EAAC;AAAA,UAChF,EAAC,MAAM,6BAA6B,MAAM,MAAK;AAAA,QACjD;AACA,iCAAyB,YAAY,QAAQ;AAC7C,eAAO;AAAA,IACX,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,GAAG,WAAW,MAAM,CAAC;AAAA;AAAA,IAE9E,aAAa,UAAU,CAAC;AAAA,MACtB,aAAa,sCAAsC,sBAAsB,CAAC;AAAA;AAAA,0BAEtD,OAAO,gBAAgB,YAAY,CAAC;AAAA;AAAA,8CAEhB,gBAAgB,IAAI,CAAC;AAAA,yDACV,gBAAgB,IAAI,CAAC,oBAClE,gBAAgB,IAAI,CAAC;AAAA;AAAA;AAAA,iBAGhB,OAAO,KAAK,KAAK,MAAM,OAAO,KAAK,KAAK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0DAMC,gBAAgB,IAAI,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0DAMrB,gBAAgB,IAAI,CAAC;AAAA;AAAA;AAAA;AAAA,uBAKnE,gBAAgB,EAAE,IAAI,SAAS,WAAW,UAAU,eAAe,IACnD,EAAE,IAAI,SAAS,iBAAiB,WAAW,QAAQ,CAAC;AAAA,uBACzD,EAAE,IAAI,kBAAkB,cAAc,WAAW,QAAQ,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,MAK3E,WAAW;AAAA,MACX,eAAe;AAAA,MACf,OAAO,YAAY,cAAc,OAAO,CAAC;AAAA;AAAA,MAEzC;AACA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,WAAW,UAAU,kBAAiB;AAAA,QAC1D,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC;AAAA,YACR,MAAM,6BAA6B,2BAA2B,WAAW,IAAI;AAAA,YAC7E,UAAU,OAAO,CAAC,EAAE;AAAA,UACtB,CAAC;AAAA,UACD,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa;AAAA;AAAA,UAAuB,EAAC;AAAA,UAClE;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEG,IAAM,wCACT,CAAC,QAA+B,YAA4B,gBAAgD;AAC1G,YAAM,UAAU,OAAO,SAAS;AAChC,YAAM,aAAa,iBAAiB,YAAY,CAAC,CAAC;AAClD,YAAM,eAAe,iBAAiB,YAAY,CAAC,CAAC;AACpD,YAAM,aAAa,UAAU,KAAK,WAAW,IAAI,aAAa;AAC9D,YAAM,SAAS,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,EAAE,KAAK,CAAC,IAAI,UAAU;AACvG,YAAM,SAAS,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,EAAE,KAAK,CAAC,IAAI,UAAU;AACvG,YAAM,sBAAsB,CAAC,YAAY,CAAC,GAAG,YAAY,CAAC,GAAG,YAAY,CAAC,GAAG,YAAY,CAAC,IAAI,UAAU;AAExG,YAAM,kBAAoC;AAAA,QACxC,EAAC,uBAAuB,MAAM,WAAU;AAAA,QACxC,EAAC,qBAAsB,MAAM,CAAC,WAAW,QAAQ,CAAC,GAAG,WAAW,QAAQ,CAAC,CAAC,EAAC;AAAA,QAC3E,EAAC,qBAAsB,MAAM,CAAC,WAAW,KAAK,CAAC,GAAG,WAAW,KAAK,CAAC,CAAC,EAAC;AAAA,MACvE;AACA,mCAA6B,YAAY,eAAe;AACxD,sBAAgB,KAAK,GAAG,2BAA2B,QAAQ,QAAQ,mBAAmB,CAAC;AACvF,YAAM,WAAW,eAAe,KAAK,WAAW,QAAQ,CAAC,IAAI,OAAO,CAAC;AACrE,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,SAAS,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,oBAAoB,QAAQ,UAAU;AAClG,cAAM,WAAW,4BAA4B,OAAO,KAAK,MAAM;AAC/D,cAAM,kBAAkB,qBAAqB,YAAY,OAAO,KAAK,OAAO,QAAQ;AACpF,cAAM,IAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,QAAQ,UAAU;AAC1E,cAAM,IAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,QAAQ,UAAU;AAC1E,cAAM,YAAY,CAAC,GAAG,CAAC;AACvB,YAAI,SAAS;AACX,oBAAU,KAAK,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,MAAM,UAAU,CAAC;AAAA,QACnF;AACA,cAAM,cAAc,UAAU,gCAAgC;AAC9D,cAAM,WAA8B;AAAA,UAClC,EAAC,MAAM,eAAe,MAAM,MAAK;AAAA,UACjC,EAAC,MAAM,WAAW,MAAM,OAAO,QAAQ,EAAC;AAAA,UACxC,EAAC,MAAM,QAAQ,MAAM,OAAO,QAAQ,EAAC;AAAA,QACvC;AACA,iCAAyB,YAAY,QAAQ;AAC7C,eAAO;AAAA,IACX,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,GAAG,WAAW,MAAM,CAAC;AAAA,IAC9E,aAAa,UAAU,CAAC;AAAA,MACtB,aAAa,sCAAsC,sBAAsB,CAAC;AAAA;AAAA;AAAA;AAAA,8CAIlC,YAAY;AAAA,oCACtB,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAOxB,EAAE,KAAK,KAAK,KAAK,OAAO;AAAA,wBACxB,OAAO,KAAK,KAAK,KAAK,YAAY;AAAA;AAAA;AAAA,8CAGZ,OAAO,CAAC,CAAC;AAAA;AAAA;AAAA,8BAGzB,OAAO;AAAA;AAAA;AAAA,0BAGX,EAAE,IAAI,SAAS,iBAAiB,gBAAgB,eAAe,CAAC;AAAA;AAAA,0BAEhE,EAAE,KAAK,KAAK;AAAA;AAAA;AAAA,gDAGU,OAAO,CAAC,CAAC;AAAA,wBACjC,EAAE,IAAI,YAAY,WAAW,KAAK,gBAAgB,CAAC;AAAA,iCAC1C,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,2BAOlB,YAAY;AAAA;AAAA,QAE/B,WAAW;AAAA,QACX,eAAe;AAAA,QACf,OAAO,IAAI,SAAS,OAAO,WAAW,kBAAkB,OAAO,CAAC;AAAA;AAAA;AAAA,MAGlE;AAEA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa;AAAA,UACX,MAAM,GAAG,WAAW,QAAQ,IAAI,UAAU,IAAI,YAAY,IAAI,OAAO,IAAI,OAAO,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC;AAAA,UAC/F,mBAAmB,UAAU,CAAC,QAAQ,QAAQ,MAAM,IAAI,CAAC,QAAQ,MAAM;AAAA,QACzE;AAAA,QACA,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,UAC3D,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa;AAAA;AAAA,UAAuB,EAAC;AAAA,UAClE;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA;AAAA;;;ACvNJ,IAYa,8BA6IPC,iBAUO;AAnKb;AAAA;AAAA;AAGA;AAEA;AAGA;AACA;AACA;AAEO,IAAM,+BACT,CAAC,QAA+B,sBAAoD,aACnF,qBACA,iBAAiB,UAAyD;AACzE,YAAM,SAAS,OAAO,CAAC,EAAE;AACzB,YAAM,SAAS,OAAO,CAAC,EAAE;AAEzB,YAAM,IAAI,OAAO,OAAO,SAAS,CAAC;AAClC,YAAM,IAAI,OAAO,OAAO,SAAS,CAAC;AAClC,YAAM,IAAI,OAAO,OAAO,SAAS,CAAC;AAClC,YAAM,aAAa,iBAAiB,CAAC;AACrC,YAAM,cAAc,iBAAiB,CAAC;AACtC,YAAM,eAAe,iBAAiB,CAAC;AACvC,YAAM,aAAa,UAAU,KAAK,WAAW,IAAI,aAAa;AAC9D,YAAM,UAAU,OAAO,SAAS;AAChC,YAAM,YAAY,sBAAsB,oBAAoB,MAAM,GAAG,EAAE,IAAI,YAAY,MAAM,GAAG,EAAE;AAClG,YAAM,YAAY,UAAU,KAAK,SAAS;AAC1C,YAAM,sBAAsB,CAAC,WAAW,GAAG,CAAC;AAE5C,YAAM,kBAAoC;AAAA,QACxC,EAAC,uBAAuB,MAAM,WAAU;AAAA,QAAG,EAAC,uBAAuB,MAAM,EAAC;AAAA,QAAG,EAAC,uBAAuB,MAAM,EAAC;AAAA,QAC5G,EAAC,uBAAuB,MAAM,EAAC;AAAA,MACjC;AACA,mCAA6B,sBAAsB,eAAe;AAClE,sBAAgB,KAAK,GAAG,2BAA2B,WAAW,QAAQ,MAAM,CAAC;AAC7E,UAAI,SAAS;AACX,wBAAgB,KAAK,GAAG,2BAA2B,OAAO,CAAC,EAAE,IAAI,CAAC;AAAA,MACpE;AACA,sBAAgB,KAAK,GAAG,2BAA2B,mBAAmB,CAAC;AAEvE,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,YAAY,iBAAiB,cAAc,OAAO,CAAC,EAAE,UAAU,UAAU,MAAM;AACrF,cAAM,IAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,QAAQ,WAAW;AAC3E,cAAM,IAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,QAAQ,UAAU;AAC1E,cAAM,SAAS,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,oBAAoB,QAAQ,UAAU;AAClG,cAAM,WAAW,4BAA4B,OAAO,KAAK,MAAM;AAC/D,cAAM,kBAAkB,qBAAqB,sBAAsB,OAAO,KAAK,OAAO,QAAQ;AAC9F,cAAM,iBAAiB,CAAC,GAAG,CAAC;AAC5B,YAAI,cAAc;AAClB,YAAI,SAAS;AACX,gBAAM,iBAAiB,iBAAiB,aAAa;AACrD,yBAAe,KAAK,cAAc,QAAQ,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,QAAQ,cAAc,CAAC;AACpG,wBAAc,GACV,iBAAiB,uBAAuB,cAAc,OACrC,YAAY,OAAO,KAAK,KAAK,kBAAkB;AAAA,QACtE;AAEA,cAAM,aAAa,OAAO,MAAM,GAAG,EAAE;AACrC,cAAM,aAAa,OAAO,MAAM,GAAG,EAAE;AACrC,cAAM,iBAAiB,iBAAiB,YAAY,SAAS;AAC7D,cAAM,iBAAiB,iBAAiB,YAAY,SAAS;AAC7D,cAAM,WAA8B;AAAA,UAClC,EAAC,MAAM,eAAe,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,KAAK,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,KAAK,MAAM,MAAK;AAAA,UACrF,EAAC,MAAM,KAAK,MAAM,MAAK;AAAA,QACzB;AACA,iCAAyB,sBAAsB,QAAQ;AAEvD,cAAM,aAAa,CAAC,UAAyB,kBAA4B;AACvE,gBAAM,OAAO,SAAS;AACtB,gBAAM,OAAO,SAAS;AACtB,cAAI,SAAS,GAAG;AACd,mBAAO,OAAO,IAAI,cAAc,SAAS,KAAK,OAAO;AAAA,UACvD;AACA,gBAAM,YAAY,UAAU;AAC5B,cAAI,SAAS,OAAO,IAAI,aAAa,SAAS,KAAK,OAAO;AAC1D,mBAAS,IAAI,OAAO,IAAI,GAAG,IAAI,YAAY,GAAG,KAAK,GAAG,KAAK,KAAK;AAC9D,sBAAU;AAAA,EAAK,IAAI,YAAY,CAAC,OAAO,YAAY,IAAI,iBAAiB,CAAC,MAAM,eAAe;AAAA,UAChG;AACA,wBAAc,QAAQ,OAAK;AACzB,sBAAU;AAAA,EAAK,IAAI,YAAY,CAAC;AAAA,UAClC,CAAC;AACD,oBAAU,GAAG,IAAI,YAAY,OAAO,CAAC;AAAA,uBACxB,IAAI,YAAY,OAAO,CAAC;AACrC,iBAAO;AAAA,QACT;AAEA,cAAM,aAAa,MAAc;AAC/B,cAAI,UAAU,eAAe,EAAE,KAAK,KAAK;AACzC,mBAAS,IAAI,GAAG,IAAI,aAAa,KAAK;AACpC,uBAAW;AAAA,0BACG,CAAC,yBAAyB,CAAC,2BAA2B,UAAU;AAAA,UAChF;AACA,mBAAS,IAAI,GAAG,IAAI,cAAc,KAAK;AACrC,uBAAW,iCAAiC,CAAC,yBAAyB,WAAW;AAEjF,qBAAS,IAAI,GAAG,IAAI,aAAa,KAAK;AACpC,yBAAW;AAAA,qBACJ,CAAC,WAAW,EAAE,KAAK,KAAK,UAAU,gBAAgB,IAAI,KAAK,IAAI,CAAC,GAAG,YAAY,CAAC,YACnF,CAAC;AAAA;AAAA,YACP;AAAA,UACF;AACA,iBAAO;AAAA,QACT;AAEA,eAAO;AAAA,IAEH,aAAa,iBAAiB,QAAQ,EAAE,0BAA0B,SAAS,EAAE;AAAA,UACzE,GAAG;AAAA,UAAgB;AAAA,QAAM,CAAC;AAAA,IACtC,aAAa,UAAU,CAAC;AAAA,MACtB,aAAa,sCAAsC,sBAAsB,CAAC;AAAA,4CACpC,UAAU,QAAQ,UAAU;AAAA,8CAC1B,UAAU;AAAA,iCACvB,YAAY;AAAA,qCACR,YAAY;AAAA;AAAA;AAAA,MAG3C,YAAY,WAAW,IAAI,KAAK,uBAAuB,UAAU,gBAAgB,OAAO,CAAC,GAAG;AAAA,MAC5F,WAAW,GAAG,cAAc,CAAC;AAAA,qBACd,EAAE,gBAAgB,WAAW,CAAC;AAAA,MAC7C,WAAW,GAAG,cAAc,CAAC;AAAA,qBACd,EAAE,gBAAgB,WAAW,CAAC;AAAA,wBAC3B,OAAO,KAAK,KAAK,KAAK,YAAY;AAAA,oDACN,WAAW;AAAA,QACvD,WAAW,CAAC;AAAA;AAAA,2BAEO,YAAY;AAAA;AAAA,QAE/B,WAAW;AAAA,QACX,eAAe;AAAA,0BACG,OAAO,KAAK,OAAO;AAAA,qBACxB,OAAO,gBAAgB,aAAa,CAAC;AAAA,QAClD,OAAO,YAAY,YAAY,UAAU,IAAI,OAAO,CAAC;AAAA;AAAA;AAAA;AAAA,MAIvD;AACA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa;AAAA,UACX,MAAM,GAAG,qBAAqB,UAAU,IAAI,UAAU,IAAI,WAAW,IAAI,YAAY,IAAI,cAAc;AAAA,UACvG,mBAAmB,UAAU,CAAC,QAAQ,QAAQ,MAAM,IAAI,CAAC,QAAQ,MAAM;AAAA,QACzE;AAAA,QACA,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,UAC3D,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa;AAAA;AAAA,UAAuB,EAAC;AAAA,UAClE;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEJ,IAAMA,kBAAiB,CAAC,WAAwC;AAC9D,UAAI,CAAC,UAAU,OAAO,WAAW,GAAG;AAClC,cAAM,IAAI,MAAM,2BAA2B;AAAA,MAC7C;AAEA,UAAI,OAAO,CAAC,EAAE,KAAK,OAAO,CAAC,EAAE,KAAK,SAAS,CAAC,MAAM,OAAO,CAAC,EAAE,KAAK,OAAO,CAAC,EAAE,KAAK,SAAS,CAAC,GAAG;AAC3F,cAAM,IAAI,MAAM,kCAAkC;AAAA,MACpD;AAAA,IACF;AAEO,IAAM,SAAS,CAAC,YAAkC;AACvD,MAAAA,gBAAe,QAAQ,MAAM;AAC7B,YAAM,cAAc,cAAc,UAAU,QAAQ,OAAO,CAAC,EAAE,MAAM,QAAQ,OAAO,CAAC,EAAE,MAAM,IAAI;AAChG,UAAI,CAAC,aAAa;AAChB,cAAM,IAAI,MAAM,uCAAwC;AAAA,MAC1D;AACA,YAAM,IAAI,YAAY,YAAY,SAAS,CAAC;AAC5C,YAAM,IAAI,QAAQ,OAAO,CAAC,EAAE,KAAK,QAAQ,OAAO,CAAC,EAAE,KAAK,SAAS,CAAC;AAClE,UAAI,IAAI,KAAK,IAAI,GAAG;AAClB,gBAAQ,QAAQ,6BAA6B,QAAQ,QAAQ,EAAC,YAAY,GAAE,GAAG,WAAW,CAAC;AAAA,MAC7F,OAAO;AACL,gBAAQ,QAAQ,wBAAwB,QAAQ,QAAQ,EAAC,YAAY,GAAE,GAAG,WAAW,CAAC;AAAA,MACxF;AAAA,IACF;AAAA;AAAA;;;AChLA,IAea,sBA6BP,0BAEAC,iBAmDA,2BAmBO,qBA0BP,QAyIA,QA0BO;AAjTb;AAAA;AAAA;AAIA;AAIA;AACA;AACA;AACA;AACA;AACA;AAEO,IAAM,uBACT,CAAC,YAA+B,aAAgC,WAC/D,YAA+B,SAA4B,kBAAqC;AAC/F,YAAM,YAAY,WAAW,CAAC;AAC9B,YAAM,oBAAoB,WAAW,MAAM,gBAAgB,IAAI,GAAG,gBAAgB,IAAI,CAAC;AACvF,YAAM,cAAc,kBAAkB;AACtC,YAAM,cAAc,YAAY,CAAC;AACjC,YAAM,qBAAqB,YAAY,MAAM,CAAC;AAC9C,YAAM,qBAAqB,mBAAmB,IAAI,CAAC,GAAG,MAAM,KAAK,IAAI,MAAM,UAAU,CAAC,IAAI,EAAE;AAC5F,YAAM,2BAA2B,kBAAkB,IAAI,CAAC,GAAG,MAAM,IAAI,WAAW,CAAC,IAAI,WAAW,IAAI,WAAW,CAAC;AAChH,YAAM,cACF,yBAAyB,IAAI,CAAC,GAAG,MAAM,KAAK,OAAO,IAAI,mBAAmB,CAAC,IAAI,QAAQ,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC;AAC5G,kBAAY,OAAO,GAAG,GAAG,SAAS;AAClC,kBAAY,OAAO,gBAAgB,IAAI,GAAG,GAAG,WAAW;AACxD,aAAO;AAAA,IACT;AAcJ,IAAM,2BAA2B,CAAC,GAAG,GAAG,GAAG,CAAC;AAE5C,IAAMA,kBAAiB,CAAC,QAA+B,eAAqC;AAG1F,UAAI,CAAC,UAAW,OAAO,WAAW,KAAK,OAAO,WAAW,GAAI;AAC3D,cAAM,IAAI,MAAM,6BAA6B;AAAA,MAC/C;AAGA,UAAI,OAAO,CAAC,EAAE,KAAK,WAAW,KAAK,OAAO,CAAC,EAAE,KAAK,WAAW,GAAG;AAC9D,cAAM,IAAI,MAAM,uCAAuC;AAAA,MACzD;AAEA,UAAI,OAAO,CAAC,EAAE,KAAK,WAAW,OAAO,CAAC,EAAE,KAAK,QAAQ;AACnD,cAAM,IAAI,MAAM,8CAA8C;AAAA,MAChE;AAGA,YAAM,cAAc,OAAO,CAAC,EAAE,KAAK,WAAW,WAAW,SAAS,OAAO,CAAC,EAAE,KAAK,SAAS,IAAI,CAAC;AAC/F,YAAM,kBAAkB,OAAO,CAAC,EAAE,KAAK,CAAC,IAAI,WAAW;AACvD,UAAI,gBAAgB,iBAAiB;AACnC,cAAM,IAAI,MAAM,mDAAmD;AAAA,MACrE;AAGA,UAAI,OAAO,WAAW,MAAM,OAAO,CAAC,EAAE,KAAK,WAAW,KAAK,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,OAAO,CAAC,EAAE,KAAK,CAAC,IAAI;AACnG,cAAM,IAAI,MAAM,cAAc;AAAA,MAChC;AAEA,YAAM,cAAc,OAAO,CAAC,EAAE,KAAK,SAAS;AAE5C,UAAI,WAAW,UAAU,WAAW,aAAa;AAC/C,cAAM,IAAI,MAAM,uBAAuB,WAAW,GAAG;AAAA,MACvD;AAGA,UAAI,WAAW,QAAQ,WAAW,aAAa;AAC7C,cAAM,IAAI,MAAM,qBAAqB,WAAW,GAAG;AAAA,MACrD;AAGA,UAAI,WAAW,KAAK,WAAW,cAAc,GAAG;AAC9C,cAAM,IAAI,MAAM,kBAAkB,cAAc,CAAC,GAAG;AAAA,MACtD;AAIA,UAAI,WAAW,YAAY,WAAW,KAAK,WAAW,YAAY,WAAW,OAAO,CAAC,EAAE,KAAK,SAAS,GAAG;AACtG,cAAM,IAAI,MAAM,sBAAsB;AAAA,MACxC;AAAA,IACF;AAEA,IAAM,4BAA4B,CAA2B,YAAe,WAAqC;AAC/G,YAAM,cAAc,WAAW,YAAY,MAAM;AAEjD,eAAS,IAAI,GAAG,IAAI,OAAO,CAAC,EAAE,KAAK,QAAQ,EAAE,GAAG;AAC9C,YAAI,YAAY,IAAI,CAAC,MAAM,GAAG;AAC5B,sBAAY,IAAI,CAAC,IAAI,OAAO,CAAC,EAAE,KAAK,CAAC;AAAA,QACvC;AAAA,MACF;AACA,YAAM,OAAO,WAAW,KAAK,MAAM;AACnC,mBAAa;AAAA,QACT,OAAO,CAAC,EAAE;AAAA,QAAM,WAAW;AAAA,QAAS,WAAW;AAAA,QAAW;AAAA,QAAa;AAAA,QAAM,WAAW,WAAW;AAAA,QACnG,WAAW;AAAA,MAAO;AAGtB,YAAM,gBAAmB,OAAO,OAAO,CAAC,GAAG,UAAU;AACrD,aAAO,OAAO,eAAe,EAAC,aAAa,KAAI,CAAC;AAChD,aAAO;AAAA,IACT;AAEO,IAAM,sBAAsB,CAAC,eAAwD;AAC1F,YAAM,uBAAuB,kCAAkC,UAAU;AAEzE,YAAM,SAAS,WAAW;AAC1B,YAAM,UAAU,CAAC,UAAU,SAAS,cAAc,YAAY,EAAE,WAAW,QAAkB;AAC7F,YAAM,YAAY,WAAW;AAC7B,YAAM,QAAQ,WAAW;AACzB,YAAM,cAAc,WAAW;AAC/B,YAAM,OAAO,WAAW;AACxB,YAAM,UAAU,WAAW;AAC3B,YAAM,WAAY,WAAW,WAA6B;AAE1D,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,GAAG;AAAA,QACH,UAAU,GAAG,WAAW,MAAM,IAAI,qBAAqB,UAAU;AAAA,MACnE;AAAA,IACF;AAEA,IAAM,SAAS,CAAC,SAAyB,QAA+B,eAAqC;AAC3G,YAAM,qBAAqB,0BAA0B,YAAY,MAAM;AAKvE,YAAM,iBAAiB,WAAW,WAAW;AAC7C,UAAI,WAAW,UAAU,GAAG;AAK1B,cAAM,6BAA6B,CAAC,QAAQ,YAAY,eAAe,QAAQ;AAC/E,YAAI,8BAA8B,kBAAkB,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,WAAW,SACjF,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,KAAK,WAAW,UAAU,CAAC,MAAM,KAAK,WAAW,UAAU,CAAC,MAAM,GAAG;AAC7F,gBAAMC,eAAc;AAAA,YAChB,OAAO,CAAC,EAAE;AAAA,YAAM,OAAO,CAAC,EAAE;AAAA,YAAM,WAAW;AAAA,YAAW,mBAAmB;AAAA,YAAM,WAAW;AAAA,YAC1F;AAAA,UAAc;AAClB,gBAAMC,oBAAoB,QAAQ,iBAAiB,MAC/C,QAAQ;AAAA,YACJ,2BAA2B,OAAO,CAAC,GAAG,wBAAwB;AAAA,YAC9D,EAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,CAAC,WAAW,WAAW,KAAK,EAAE,EAAC;AAAA,UAAC,EAAE,CAAC;AAClE,cAAI,WAAW,YAAY,CAAC,QAAQ,iBAAiB,IAAI;AACvD,oBAAQ,iBAAiB,KAAKA;AAAA,UAChC;AACA,gBAAMC,cAAa,CAAC,OAAO,CAAC,GAAGD,iBAAgB;AAC/C,cAAI,OAAO,WAAW,GAAG;AACvB,YAAAC,YAAW,KAAK,OAAO,CAAC,CAAC;AAAA,UAC3B;AACA,kBAAQ;AAAA,YACJ,sCAAsCA,aAAY,oBAAoBF,YAAW;AAAA,YAAG,EAAC,QAAQE,YAAU;AAAA,UAAC;AAAA,QAC9G,OAAO;AACL,kBAAQ,QAAQ,6BAA6B,QAAQ,kBAAkB,CAAC;AAAA,QAC1E;AACA;AAAA,MACF;AAEA,YAAM,UAAU,OAAO,WAAW;AAClC,YAAM,cAAc,OAAO,CAAC,EAAE,KAAK,iBAAiB,IAAI,CAAC;AACzD,YAAM,aAAa,OAAO,CAAC,EAAE,KAAK,iBAAiB,IAAI,CAAC;AACxD,YAAM,gBAAgB,OAAO,CAAC,EAAE,KAAK,iBAAiB,IAAI,CAAC;AAC3D,YAAM,eAAe,OAAO,CAAC,EAAE,KAAK,CAAC;AACrC,YAAM,cAAc,OAAO,CAAC,EAAE,KAAK,CAAC;AAEpC,YAAM,cAAc;AAAA,QAChB,OAAO,CAAC,EAAE;AAAA,QAAM,OAAO,CAAC,EAAE;AAAA,QAAM,WAAW;AAAA,QAAW,mBAAmB;AAAA,QAAM,WAAW;AAAA,QAC1F;AAAA,MAAc;AAClB,YAAM,YAAY,YAAY,iBAAiB,IAAI,CAAC;AACpD,YAAM,WAAW,YAAY,iBAAiB,IAAI,CAAC;AACnD,YAAM,cAAc,YAAY,iBAAiB,IAAI,CAAC;AAEtD,YAAM,WAAW,kBAAkB,iBAAiB,eAAe,gBAAgB,cAC/E,WAAW,KAAK,CAAC,MAAM,KAAK,WAAW,KAAK,CAAC,MAAM;AACvD,UAAI,YACC,iBAAiB,KAAK,gBAAgB,KAAK,WAAW,UAAU,CAAC,MAAM,KAAK,WAAW,UAAU,CAAC,MAAM,KACxG,WAAW,QAAQ,CAAC,MAAM,KAAK,WAAW,QAAQ,CAAC,MAAM,KAAK,WAAW,KAAK,CAAC,MAAM,KACrF,WAAW,KAAK,CAAC,MAAM,GAAI;AAE9B,cAAM,QAAQ,YAAY,CAAC;AAC3B,YAAI,WAAW,WAAW;AAC1B,cAAM,eAAe,CAAC;AACtB,YAAI,gBAAgB;AAClB,gBAAMD,oBAAoB,QAAQ,iBAAiB,MAC/C,QAAQ;AAAA,YACJ,2BAA2B,OAAO,CAAC,GAAG,wBAAwB;AAAA,YAC9D,EAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,CAAC,WAAW,WAAW,KAAK,EAAE,EAAC;AAAA,UAAC,EAAE,CAAC;AAClE,cAAI,WAAW,YAAY,CAAC,QAAQ,iBAAiB,IAAI;AACvD,oBAAQ,iBAAiB,KAAKA;AAAA,UAChC;AACA,cAAI,UAAU;AACZ,kBAAM,YAAY,cAAc,aAAa;AAC7C,wBAAY,OAAO,CAAC,EAAE,QAAQ,CAAC,GAAG,OAAO,SAAS,CAAC;AACnD,wBAAYA,kBAAiB,QAAQ,CAAC,GAAG,WAAW,WAAW,CAAC;AAChE,gCAAoB,CAAC,GAAG,OAAO,WAAW;AAAA,UAC5C,OAAO;AACL,wBAAY,OAAO,CAAC,EAAE,QAAQ,CAAC,OAAO,cAAc,YAAY,aAAa,CAAC;AAC9E,wBAAYA,kBAAiB,QAAQ,CAAC,GAAG,eAAe,WAAW,CAAC;AACpE,gCAAoB,CAAC,OAAO,YAAY,UAAU,WAAW;AAAA,UAC/D;AACA,uBAAa,KAAK,SAAS;AAC3B,uBAAa,KAAK,SAAS;AAAA,QAC7B,OAAO;AACL,sBAAY,OAAO,CAAC,EAAE,QAAQ,CAAC,OAAO,eAAe,cAAc,UAAU,CAAC;AAC9E,sBAAY,OAAO,CAAC,EAAE,QAAQ,CAAC,GAAG,aAAa,aAAa,CAAC;AAC7D,8BAAoB,CAAC,OAAO,aAAa,YAAY,QAAQ;AAC7D,uBAAa,KAAK,SAAS;AAC3B,uBAAa,KAAK,SAAS;AAAA,QAC7B;AACA,YAAI,SAAS;AACX,uBAAa,KAAK,OAAO,CAAC,CAAC;AAAA,QAC7B;AACA,cAAM,IAAI,kBAAkB,CAAC;AAC7B,cAAM,IAAI,aAAa,CAAC,EAAE,KAAK,aAAa,CAAC,EAAE,KAAK,SAAS,CAAC;AAE9D,YAAI,IAAI,KAAK,IAAI,GAAG;AAClB,kBAAQ;AAAA,YACJ;AAAA,cACI;AAAA,cAAc;AAAA,cAAoB;AAAA,cAAa;AAAA,cAAmB;AAAA,YAAc;AAAA,YACpF,EAAC,QAAQ,aAAY;AAAA,UAAC;AAAA,QAC5B,OAAO;AACL,kBAAQ;AAAA,YACJ,wBAAwB,cAAc,oBAAoB,aAAa,mBAAmB,cAAc;AAAA,YACxG,EAAC,QAAQ,aAAY;AAAA,UAAC;AAAA,QAC5B;AACA;AAAA,MACF;AAIA,YAAM;AAAA;AAAA,QAAgE;AAAA;AAGtE,YAAM,mBAAoB,QAAQ,iBAAiB,MAC/C,QAAQ;AAAA,QACJ,2BAA2B,OAAO,CAAC,GAAG,wBAAwB;AAAA,QAC9D,EAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,CAAC,WAAW,WAAW,KAAK,EAAE,EAAC;AAAA,MAAC,EAAE,CAAC;AAClE,UAAI,WAAW,YAAY,CAAC,QAAQ,iBAAiB,IAAI;AACvD,gBAAQ,iBAAiB,KAAK;AAAA,MAChC;AAGA,YAAM,aAAa,CAAC,OAAO,CAAC,GAAG,gBAAgB;AAC/C,UAAI,SAAS;AACX,mBAAW,KAAK,OAAO,CAAC,CAAC;AAAA,MAC3B;AAGA,YAAM,YAAY,iBAAiB,YAAY,WAAW;AAC1D,YAAM,YAAY,iBAAiB,cAAc,YAAY;AAC7D,YAAM,WAAW,eAAe,cAAc;AAC9C,cAAQ;AAAA,QACJ;AAAA,UACI;AAAA,UAAY;AAAA,UAAoB;AAAA,UAAa;AAAA,UAAW;AAAA,UAAW;AAAA,UAAU;AAAA,UAC7E;AAAA,QAAyB;AAAA,QAC7B,EAAC,QAAQ,WAAU;AAAA,MAAC;AAAA,IAC1B;AAEA,IAAM,SAAS,CAAC,SAAyB,eAAqC;AAE5E,YAAM,gBAAgB,WAAW,WAAW;AAC5C,YAAM,SAAS;AAAA,QACb,QAAQ,OAAO,CAAC,EAAE;AAAA,UACd;AAAA;AAAA,YAEI,CAAC,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,GAAG,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC;AAAA;AAAA;AAAA,YAEnF,CAAC,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,GAAG,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC;AAAA;AAAA,QAAC;AAAA;AAAA,QAE5F,QAAQ,OAAO,CAAC,EAAE,QAAQ,CAAC,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,GAAG,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;AAAA,MAChH;AACA,UAAI,QAAQ,OAAO,WAAW,GAAG;AAC/B,eAAO,KAAK,QAAQ,OAAO,CAAC,CAAC;AAAA,MAC/B;AACA,YAAM,OAAO,CAAC,GAAG,WAAW,KAAK,CAAC,GAAG,GAAG,WAAW,KAAK,CAAC,CAAC;AAC1D,YAAM,UAAU,CAAC,CAAC,EAAE,OAAO,WAAW,OAAO;AAC7C,YAAM,YAAY,CAAC,CAAC,EAAE,OAAO,WAAW,SAAS;AACjD,YAAM,cAAc,CAAC,CAAC,EAAE,OAAO,WAAW,WAAW;AACrD,YAAM,qBAAqB,0BAA0B,EAAC,GAAG,YAAY,MAAM,SAAS,WAAW,YAAW,GAAG,MAAM;AACnH,cAAQ,QAAQ;AAAA,QACZ;AAAA,QAAQ;AAAA,QACR,iBAAe,gBAAgB,CAAC,YAAY,CAAC,GAAG,YAAY,CAAC,GAAG,YAAY,CAAC,CAAC,IAAI,CAAC;AAAA,MAAC,CAAC;AAAA,IAC3F;AAEO,IAAM,OAAO,CAAC,SAAyB,eAAqC;AACjF,MAAAF,gBAAe,QAAQ,QAAQ,UAAU;AACzC,UAAI,QAAQ,OAAO,CAAC,EAAE,KAAK,WAAW,GAAG;AACvC,eAAO,SAAS,UAAU;AAAA,MAC5B,OAAO;AACL,eAAO,SAAS,QAAQ,QAAQ,UAAU;AAAA,MAC5C;AAAA,IACF;AAAA;AAAA;;;ACxTA,IAiCM,8BA2HO;AA5Jb;AAAA;AAAA;AAqBA;AACA;AAGA;AAEA;AAEA;AACA;AACA;AAEA,IAAM,+BACF,CAAC,gBAAyB,UAAU,OAAO,YAAqC,MAC/E,mBAAmB,MAAc;AAChC,YAAM,cAAc,CAACI,sBAA6B;AAChD,gBAAQA,mBAAkB;AAAA,UACxB,KAAK;AACH,mBAAO;AAAA,UACT,KAAK;AACH,mBAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAQE,IAAI;AAAA;AAAA,UAEf;AACE,kBAAM,IAAI,MAAM,oBAAoBA,iBAAgB,oBAAoB;AAAA,QAC5E;AAAA,MACF;AACA,YAAM,gBAAgB,iBAAiB;AAAA;AAAA,UAGA;AAAA;AAAA;AAIvC,YAAM,kBAAkB,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAOA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQzC,YAAM,UAAU,iBAAiB,6BAA6B;AAC9D,YAAM,SAAS,iBAAiB,6BAA6B;AAC7D,YAAM,MAAM,iBAAiB,QAAQ;AACrC,YAAM,MAAM,iBAAiB,QAAQ;AAErC,YAAM,eAAe;AAAA,yBACF,iBAAiB,6BAA6B,0BAA0B;AAAA,uBAC1E,iBAAiB,kCAAkC,+BAA+B;AAAA,qBACpF,GAAG;AAAA,qBACH,GAAG;AAAA;AAAA,mBAEL,GAAG;AAAA,mBACH,GAAG;AAAA;AAAA;AAAA,kCAGY,OAAO;AAAA,iBACxB,IAAI;AAAA;AAAA,kCAEa,MAAM;AAAA,iBACvB,IAAI;AAAA;AAAA;AAAA;AAAA,kBAIH,GAAG;AAAA,QACb,aAAa;AAAA,0EACqD,gBAAgB;AAEpF,YAAM,UAAU,iBAAiB;AAAA,0BACb,gBAAgB;AAAA;AAAA,UAEhC,YAAY;AAAA;AAAA,eAEP,IAAI,WACoB;AAAA,0BACb,gBAAgB;AAAA;AAAA,UAEhC,YAAY;AAAA;AAAA,eAEP,IAAI;AAEb,YAAM,UAAU;AAAA,0BACI,gBAAgB;AAAA,yBACjB,iBAAiB,6BAA6B,0BAA0B;AAAA;AAAA;AAAA,YAIvF,iBAAiB,2DACA,wDAAwD;AAAA;AAAA;AAAA,UAGzE,YAAY,gBAAgB,CAAC;AAAA;AAAA,eAExB,IAAI;AAAA;AAGb,YAAM,kBAAkB,qBAAqB,YAAY,IAAI;AAC7D,YAAM,WAAW;AAAA,uDACgC,IAAI;AAAA,MACrD,iBAAiB,UAAU,OAAO;AAAA;AAAA;AAAA,uDAGe,IAAI;AAAA,MACrD,iBAAiB,UAAU,OAAO;AAAA;AAAA;AAAA,iEAGyB,IAAI;AAAA,wBAC7C,gBAAgB;AAAA;AAAA;AAAA,uBAGjB,iBAAiB,kCAAkC,+BAA+B;AAAA,QACjG,eAAe;AAAA,QACf,YAAY,OAAO,CAAC;AAAA,QACpB,eAAe;AAAA,8EACuD,gBAAgB;AAAA;AAAA;AAGxF,aAAO;AAAA,IACT;AAEG,IAAM,yCACT,CAAC,QAA+B,YAAqC,aACpE,WAAmB,WAAmB,UAAkB,SACxD,8BAAoD;AACnD,YAAM,iBAAiB,WAAW,WAAW;AAC7C,YAAM,aAAa,iBAAiB,OAAO,CAAC,EAAE,KAAK,CAAC,IAAI,OAAO,CAAC,EAAE,KAAK,CAAC;AACxE,YAAM,YAAY,YAAY,CAAC;AAC/B,YAAM,WAAW,iBAAiB,YAAY,CAAC,IAAI,YAAY,CAAC;AAChE,YAAM,YAAY,iBAAiB,YAAY,CAAC,IAAI,YAAY,CAAC;AACjE,YAAM,cAAc,iBAAiB,YAAY,CAAC,IAAI,YAAY,CAAC;AAEnE,YAAM,SAAS,mBAAmB,aAAa,MAAM,KAAK,aAAa,MAAM,cAAc,MAAM;AAGjG,YAAM,YAAY,iBAAiB,cAAc,WAAW;AAC5D,YAAM,YAAY,iBAAiB,WAAW,YAAY;AAC1D,YAAM,gBAA0C,CAAC,GAAG,GAAG,CAAC;AACxD,YAAM,oBAAoB,aAAa,IAAI,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC;AAC/D,YAAM,WAAW;AAAA,QACf,KAAK,KAAK,YAAY,cAAc,CAAC,IAAI,kBAAkB,CAAC,CAAC;AAAA,QAC7D,KAAK,KAAK,YAAY,cAAc,CAAC,IAAI,kBAAkB,CAAC,CAAC;AAAA,QAC7D,KAAK,KAAK,YAAY,cAAc,CAAC,IAAI,kBAAkB,CAAC,CAAC;AAAA,MAC/D;AAEA,gBAAU,WAAW,MAAM,wCAAwC,QAAQ,EAAE;AAE7E,YAAM,mBAAmB,SAAS,IAAI;AACtC,YAAM,YAAY,KAAK,IAAI,cAAc,CAAC,IAAI,kBAAkB,cAAc,CAAC,CAAC;AAChF,YAAM,aAAa,SAAS,IAAI;AAChC,YAAM,aACF,CAAC,WAAW,YAAY,iBAAiB,IAAI,CAAC,GAAG,WAAW,YAAY,iBAAiB,IAAI,CAAC,CAAC;AACnG,YAAM,sBAAsB;AAAA,QAC1B,WAAW,CAAC,KAAK,WAAW,UAAU,CAAC,KAAK,IAAI,KAAK,WAAW,CAAC,IAAI,MAAM,WAAW,UAAU,CAAC,IAAI;AAAA,QACrG,WAAW,CAAC,KAAK,WAAW,UAAU,CAAC,KAAK,IAAI,KAAK,WAAW,CAAC,IAAI,MAAM,WAAW,UAAU,CAAC,IAAI;AAAA,MACvG;AACA,YAAM,OAAO;AAAA,QACX,oBAAoB,CAAC,IAAI,IAAI,KAAK,OAAO,WAAW,KAAK,CAAC,IAAI,WAAW,KAAK,CAAC,KAAK,CAAC;AAAA,QACrF,oBAAoB,CAAC,IAAI,IAAI,KAAK,OAAO,WAAW,KAAK,CAAC,IAAI,WAAW,KAAK,CAAC,KAAK,CAAC;AAAA,MACvF;AAEA,YAAM,kBAAoC;AAAA,QACxC,EAAC,qBAAsB,MAAM,UAAS;AAAA,QAAG,EAAC,qBAAsB,MAAM,UAAS;AAAA,QAC/E,EAAC,qBAAsB,MAAM,SAAQ;AAAA,QAAG,EAAC,qBAAsB,MAAM,WAAW,QAAO;AAAA,QACvF,EAAC,qBAAsB,MAAM,WAAW,UAAS;AAAA,QAAG,EAAC,qBAAsB,MAAM,WAAU;AAAA,QAC3F,EAAC,qBAAsB,MAAM,KAAI;AAAA,MACnC;AACA,mCAA6B,YAAY,eAAe;AACxD,sBAAgB,KAAK,GAAG,2BAA2B,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,EAAE,IAAI,CAAC;AAElF,YAAM,oBAAwD,CAAC,QAAQ,MAAM;AAC7E,UAAI,SAAS;AACX,wBAAgB,KAAK,GAAG,2BAA2B,OAAO,CAAC,EAAE,IAAI,CAAC;AAClE,0BAAkB,KAAK,MAAM;AAAA,MAC/B;AACA,sBAAgB,KAAK,GAAG,2BAA2B,WAAW,CAAC;AAE/D,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,IAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,QAAQ,UAAU;AAClF,cAAM,IAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,QAAQ,CAAC;AACzE,cAAM,SAAS,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,YAAY,QAAQ,UAAU;AAC1F,cAAM,iBAAiB,CAAC,GAAG,CAAC;AAE5B,YAAI,mBAAmB;AACvB,YAAI,SAAS;AACX,gBAAM,OAAO,cAAc,QAAQ,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,QAAQ,UAAU;AACxF,yBAAe,KAAK,IAAI;AACxB,8BAAoB;AAAA,4DAC8B,KAAK,KAAK,KAAK;AAAA,iCAC1C,iBAAiB,MAAM,GAAG,GAAG,SAAS,QAAQ,EAAE;AAAA;AAAA,QAEzE;AAEA,cAAM,WAA8B;AAAA,UAClC,EAAC,MAAM,eAAe,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,eAAe,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,aAAa,MAAM,MAAK;AAAA,UACvG,EAAC,MAAM,WAAW,MAAM,OAAO,QAAQ,EAAC;AAAA,UAAG,EAAC,MAAM,aAAa,MAAM,OAAO,QAAQ,EAAC;AAAA,UACrF,EAAC,MAAM,eAAe,MAAM,OAAO,QAAQ,WAAW,OAAM;AAAA,UAC5D,EAAC,MAAM,QAAQ,MAAM,OAAO,QAAQ,KAAK,OAAM;AAAA,QACjD;AACA,iCAAyB,YAAY,QAAQ;AAC7C,cAAM,WAAW,4BAA4B,OAAO,CAAC,EAAE,UAAU,CAAC;AAClE,YAAI,aAAa,SAAS,aAAa,OAAO;AAC5C,gBAAM,IAAI,MAAM,YAAY,QAAQ,oBAAoB;AAAA,QAC1D;AACA,eAAO;AAAA,UACL,cAAc,yBAAyB,CAAC;AAAA,UACxC,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,GAAG,gBAAgB,MAAM,CAAC;AAAA,UACnF,gBAAgB;AAAA,UAChB,6BAA6B,gBAAgB,SAAS,YAAY,EAAE,KAAK,OAAO,gBAAgB,CAAC;AAAA,UAE/F,SAAS;AAAA,UACI;AAAA,UAAmB;AAAA,UAAe;AAAA,UAAU;AAAA,UAAW,CAAC;AAAA,UAAgB;AAAA,QAAS,IACrF;AAAA,UACI;AAAA,UAAmB;AAAA,UAAe;AAAA,UAAU;AAAA,UAAW,CAAC;AAAA,UAAgB;AAAA,UAAW;AAAA,UACnF;AAAA,UAAW;AAAA,QAAyB,CAAC;AAAA,MACxD;AAEA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aACI,EAAC,MAAM,GAAG,WAAW,QAAQ,IAAI,iBAAiB,IAAI,aAAa,IAAI,MAAM,IAAI,kBAAiB;AAAA,QACtG,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,UAC3D,eAAe,EAAC,GAAG,SAAS,CAAC,GAAG,GAAG,SAAS,CAAC,GAAG,GAAG,SAAS,CAAC,EAAC;AAAA,UAC9D;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA;AAAA;;;ACvQJ,IA2BM,4CAiMO;AA5Nb;AAAA;AAAA;AAmBA;AACA;AAEA;AAEA;AAGA,IAAM,6CACF,CAAC,cAA4B,QAA+B,aAAgC,SAC3F,sBAA+B,SAAS,OAAO,UAAkB,UACjE,iBAAiB,UAAkB;AAClC,YAAM,SAAS,iBAAiB,IAAI;AACpC,YAAM,SAAS,iBAAiB,IAAI;AACpC,YAAM,aAAa,iBAAiB,IAAI;AACxC,YAAM,gBAAgB,SAAS,IAAI;AAEnC,UAAI,mBAAmB;AAAA,iDACoB,SAAS,QAAQ,QAAQ,MAAM,QAAQ;AAAA,0BAC9D,SAAS,QAAQ,QAAQ,MAAM,QAAQ;AAAA;AAE3D,UAAI,SAAS;AACX,4BAAoB;AAAA,sDAC0B,SAAS,QAAQ,QAAQ,MAAM,QAAQ;AAAA,2BAClE,iBAAiB,MAAM,GAAG,GAAG,SAAS,QAAQ,EAAE;AAAA;AAAA,MAErE;AACA,YAAM,aAAa,SAAS,IAAI;AAChC,YAAM,IAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,QAAQ,UAAU;AAClF,YAAM,KAAK,cAAc,MAAM,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,QAAQ,UAAU;AACpF,YAAM,iBAAiB,CAAC,IAAI,CAAC;AAC7B,UAAI,SAAS;AACX,uBAAe,KAAK,cAAc,QAAQ,OAAO,CAAC,EAAE,UAAU,CAAC,YAAY,UAAU,CAAC,EAAE,QAAQ,UAAU,CAAC;AAAA,MAC7G;AACA,YAAM,SAAS,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,YAAY,QAAQ,UAAU;AAE1F,YAAM,eAAe;AAAA,2BACA,uBAAuB,gBAAgB,gBAAgB;AAAA,kBAChE,uBAAuB,gBAAgB,gBAAgB;AAAA,kBACvD,uBAAuB,gBAAgB,gBAAgB,MAAM,aAAa;AAAA,wBACpE,uBAAuB,gBAAgB,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kCAM7C,QAAQ,MAAM,aAAa;AAAA,8BAC/B,aAAa;AAAA,8BACb,QAAQ;AAAA;AAAA;AAAA,uBAGf,QAAQ,kBAAkB,QAAQ,WAAW,QAAQ;AAAA;AAAA,oCAExC,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAOnB,QAAQ,kBAAkB,QAAQ,WAAW,QAAQ;AAAA,0BACpD,QAAQ,wBAAwB,QAAQ,WAAW,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sCAO/C,QAAQ;AAAA;AAAA;AAAA;AAAA,wCAIN,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gCAUhB,EAAE,IAAI,eAAe,eAAe,MAAM,IAAI,CAAC;AAAA,gCAC/C,EAAE,IAAI,eAAe,eAAe,UAAU,IAAI,CAAC;AAAA,gCACnD,EAAE,IAAI,eAAe,eAAe,UAAU,IAAI,CAAC;AAAA,gCACnD,EAAE,IAAI,eAAe,eAAe,UAAU,IAAI,CAAC;AAAA;AAAA,+BAEpD,GAAG,IAAI,SAAS,QAAQ,QAAQ,IAAI,CAAC;AAAA,oCAChC,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,4BAMhB,GAAG,IAAI,SAAS,QAAQ,SAAS,IAAI,CAAC;AAAA;AAAA,iDAEjB,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iDAMR,UAAU;AAAA;AAAA,gCAE3B,EAAE,IAAI,eAAe,eAAe,MAAM,IAAI,CAAC;AAAA,gCAC/C,EAAE,IAAI,eAAe,eAAe,UAAU,IAAI,CAAC;AAAA,gCACnD,EAAE,IAAI,eAAe,eAAe,UAAU,IAAI,CAAC;AAAA,gCACnD,EAAE,IAAI,eAAe,eAAe,UAAU,IAAI,CAAC;AAAA;AAAA,+BAEpD,GAAG,IAAI,SAAS,QAAQ,QAAQ,IAAI,CAAC;AAAA,oCAChC,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gCASZ,EAAE,IAAI,eAAe,eAAe,MAAM,IAAI,CAAC;AAAA,gCAC/C,EAAE,IAAI,eAAe,eAAe,UAAU,IAAI,CAAC;AAAA,gCACnD,EAAE,IAAI,eAAe,eAAe,UAAU,IAAI,CAAC;AAAA,gCACnD,EAAE,IAAI,eAAe,eAAe,UAAU,IAAI,CAAC;AAAA;AAAA,+BAEpD,GAAG,IAAI,SAAS,QAAQ,SAAS,IAAI,CAAC;AAAA,oCACjC,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mCAUT,aAAa;AAAA,qCACX,UAAU,cAAc,QAAQ,QAAQ,QAAQ;AAAA,YACzE,OAAO,IAAI,SAAS,KAAK,SAAS,MAAM,OAAO,CAAC;AAAA;AAAA;AAGtD,YAAM,cAAc;AAAA,gCACM,OAAO,gBAAgB,YAAY,CAAC;AAAA,wBAC5C,OAAO,WAAW,iBAAiB,CAAC,CAAC;AAAA,qBACxC,OAAO,WAAW,iBAAiB,UAAU,CAAC;AAAA,oBAC/C,OAAO,WAAW,iBAAiB,MAAM,CAAC;AAAA,oBAC1C,OAAO,WAAW,iBAAiB,MAAM,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0BAQpC,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA,yBAKT,QAAQ,iBAAiB,QAAQ,WAAW,QAAQ;AAAA;AAAA,sCAEvC,QAAQ,sBAAsB,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,2BAU/C,QAAQ,iBAAiB,QAAQ,WAAW,QAAQ;AAAA;AAAA,wCAEvC,QAAQ,sBAAsB,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,+BAQlE,iBAAiB,GAAG,IAAI,SAAS,QAAQ,QAAQ,cAAc,IAC9C,GAAG,IAAI,SAAS,gBAAgB,QAAQ,MAAM,CAAC;AAAA,+BAC3C,EAAE,IAAI,gBAAgB,eAAe,eAAe,aAAa,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kCAM/D,UAAU,aAAa,GAAG,QAAQ,OAAO;AAAA,YAC/D,OAAO,YAAY,cAAc,OAAO,CAAC;AAAA;AAG/C,aAAO;AAAA,IACT,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,GAAG,gBAAgB,MAAM,CAAC;AAAA,IACnF,gBAAgB;AAAA;AAAA,MAEd,aAAa,UAAU,CAAC;AAAA,MACxB,aAAa,sCAAsC,sBAAsB,CAAC;AAAA,IAC5E,SAAS,eAAe,WAAW;AAAA,IACnC;AAEG,IAAM,mCACT,CAAC,QAA+B,YAC/B,+BAAqF;AACpF,YAAM,UAAU,OAAO,SAAS;AAEhC,YAAM,cAAc,WAAW;AAC/B,YAAM,aAAa,UAAU,KAAK,WAAW;AAM7C,YAAM,WAAW;AAAA,QACf,KAAK,KAAK,aAAa,EAAE;AAAA,QACzB;AAAA,QACA;AAAA,MACF;AACA,gBAAU,WAAW,MAAM,uCAAuC,QAAQ,EAAE;AAE5E,YAAM,iBAAiB,WAAW,WAAW;AAC7C,YAAM,oBAAwD,CAAC,QAAQ,MAAM;AAC7E,YAAM,UAAU,CAAC,WAAW,QAAQ,CAAC,GAAG,WAAW,QAAQ,CAAC,CAAC;AAC7D,YAAM,aACF,CAAC,WAAW,YAAY,iBAAiB,IAAI,CAAC,GAAG,WAAW,YAAY,iBAAiB,IAAI,CAAC,CAAC;AACnG,YAAM,YAAY,CAAC,WAAW,UAAU,CAAC,GAAG,WAAW,UAAU,CAAC,CAAC;AACnE,YAAM,sBAAsB;AAAA,QAC1B,WAAW,CAAC,KACP,WAAW,UAAU,CAAC,KAAK,IACvB,KACC,WAAW,YAAY,iBAAiB,IAAI,CAAC,IAAI,MAAM,WAAW,UAAU,CAAC,IAAI;AAAA,QAC3F,WAAW,CAAC,KACP,WAAW,UAAU,CAAC,KAAK,IACvB,KACC,WAAW,YAAY,iBAAiB,IAAI,CAAC,IAAI,MAAM,WAAW,UAAU,CAAC,IAAI;AAAA,MAC7F;AACA,YAAM,OAAO;AAAA,QACX,oBAAoB,CAAC,IAAI,IAAI,KAAK,OAAO,WAAW,KAAK,CAAC,IAAI,WAAW,KAAK,CAAC,KAAK,CAAC;AAAA,QACrF,oBAAoB,CAAC,IAAI,IAAI,KAAK,MAAM,WAAW,KAAK,CAAC,IAAI,WAAW,KAAK,CAAC,CAAC,IAAI;AAAA,MACrF;AAEA,YAAM,SAAS;AACf,YAAM,QAAQ,WAAW;AACzB,YAAM,SAAS,OAAO,CAAC,EAAE;AACzB,YAAM,wBAAwB,OAAO,CAAC,IAAI;AAC1C,YAAM,yBAAyB,OAAO,CAAC;AAEvC,YAAM,kBAAoC;AAAA,QACxC,EAAC,uBAAuB,MAAM,WAAU;AAAA,QAAG,EAAC,uBAAuB,MAAM,QAAO;AAAA,QAChF,EAAC,uBAAuB,MAAM,WAAU;AAAA,QAAG,EAAC,uBAAuB,MAAM,UAAS;AAAA,QAClF,EAAC,uBAAuB,MAAM,oBAAmB;AAAA,QAAG,EAAC,qBAAsB,MAAM,KAAI;AAAA,QACrF,EAAC,uBAAuB,MAAM,sBAAqB;AAAA,QAAG,EAAC,uBAAuB,MAAM,uBAAsB;AAAA,QAC1G,GAAG,2BAA2B,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,EAAE,IAAI;AAAA,MAC9D;AACA,UAAI,SAAS;AACX,wBAAgB,KAAK,GAAG,2BAA2B,OAAO,CAAC,EAAE,IAAI,CAAC;AAClE,0BAAkB,KAAK,MAAM;AAAA,MAC/B;AACA,sBAAgB,KAAK,GAAG,2BAA2B,WAAW,CAAC;AAE/D,YAAM,uBAAuB,SAAS,CAAC,MAAM,KAAK,SAAS,CAAC,MAAM;AAClE,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,WAA8B;AAAA,UAClC,EAAC,MAAM,eAAe,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,WAAW,MAAM,OAAO,QAAQ,QAAQ,OAAM;AAAA,UACzF,EAAC,MAAM,eAAe,MAAM,OAAO,QAAQ,WAAW,OAAM;AAAA,UAC5D,EAAC,MAAM,aAAa,MAAM,OAAO,QAAQ,WAAW,OAAM;AAAA,UAC1D,EAAC,MAAM,yBAAyB,MAAM,OAAO,QAAQ,oBAAoB,OAAM;AAAA,UAC/E,EAAC,MAAM,QAAQ,MAAM,OAAO,QAAQ,KAAK,OAAM;AAAA,UAAG,EAAC,MAAM,4BAA4B,MAAM,MAAK;AAAA,UAChG,EAAC,MAAM,6BAA6B,MAAM,MAAK;AAAA,QACjD;AACA,cAAM,WAAW,4BAA4B,OAAO,CAAC,EAAE,QAAQ;AAC/D,eAAO,GACH;AAAA,UACI;AAAA,UAAc;AAAA,UAAQ;AAAA,UAAa;AAAA,UAAS;AAAA,UAAsB;AAAA,UAAQ;AAAA,UAAU;AAAA,UACpF;AAAA,QAAc,CAAC;AAAA,MACzB;AACA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,GAAG,WAAW,QAAQ,KAAK,kBAAiB;AAAA,QAChE,YAAY,OAAO;AAAA,UACjB,eAAe,EAAC,GAAG,SAAS,CAAC,GAAG,GAAG,SAAS,CAAC,GAAG,GAAG,SAAS,CAAC,EAAC;AAAA,UAC9D,SAAS,CAAC;AAAA,YACR,MAAM,6BAA6B,2BAA2B,WAAW,IAAI;AAAA,YAC7E,UAAU,OAAO,CAAC,EAAE;AAAA,UACtB,CAAC;AAAA,UACD;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA;AAAA;;;ACpTJ,IAYM,iBAIA,mBAWA,6BAiCA,oCAwCO,8BA+BPC,kBAqEA,qBAEA,iBAsDA,iBA6CO;AA7Sb;AAAA;AAAA;AAMA;AACA;AAEA;AACA;AAEA,IAAM,kBACF,CAAC,OAAe,QAAgB,KAAa,QAAgB,UAAkB,aAC1E,QAAQ,KAAK,SAAS,OAAO,SAAS,KAAK,WAAW,IAAI;AAEnE,IAAM,oBAAoB,CAAC,UAAkB,SAAiB,MAAgB,MAAc,SAAiB;AAC3G,YAAM,WAAW,KAAK,MAAM,WAAW,CAAC;AACxC,UAAI,YAAY,cAAc;AAC5B,aAAK,IAAI,IAAI;AACb,aAAK,IAAI,IAAI,WAAW;AAAA,MAC1B,WAAW,YAAY,cAAc;AACnC,aAAK,IAAI,IAAI,WAAW;AACxB,aAAK,IAAI,IAAI;AAAA,MACf;AAAA,IACF;AAEA,IAAM,8BACF,CAAC,YAA+B,aAAgC,WAA8B,SAC7F,OAAe,MAAgB,SAA4B,eAAwB,eACnF,gBAA0B;AACzB,YAAM,cAAc,WAAW,SAAS;AACxC,YAAM,oBAAoB,YAAY,WAAW;AACjD,UAAI,cAAc,WAAW,GAAG;AAC9B,iBAAS,IAAI,GAAG,IAAI,aAAa,EAAE,GAAG;AACpC,wBAAc,KAAK,CAAC;AAAA,QACtB;AAAA,MACF;AACA,YAAM,YAAY,WAAW,CAAC;AAC9B,YAAM,cAAc,YAAY,gBAAgB,IAAI,CAAC,IAAI;AACzD,eAAS,IAAI,GAAG,IAAI,WAAW,SAAS,eAAe,gBAAgB,IAAI,IAAI,IAAI,aAAa,EAAE,GAAG,EAAE,GAAG;AACxG,cAAM,SAAS,WAAW,CAAC;AAC3B,cAAM,UAAU,oBAAoB,SAAS,QAAQ,CAAC,IAAI,YAAY,CAAC;AACvE,cAAM,WAAW,gBAAgB,QAAQ,QAAQ,CAAC,GAAG,KAAK,CAAC,GAAG,YAAY,CAAC,GAAG,UAAU,CAAC,GAAG,OAAO;AACnG,0BAAkB,UAAU,SAAS,MAAM,GAAG,IAAI,WAAW;AAC7D,YAAI,mBAAmB;AACrB,sBAAY;AAAA,YACR,QAAQ,CAAC,KAAK,SAAS,KAAK,cAAc,CAAC,KAAK,YAAY,CAAC,IAAI,KAAK,UAAU,CAAC,IAAI,IAAI,KAAK,CAAC,IAC/F,KAAK,IAAI,WAAW;AAAA,UAAC;AAAA,QAC3B;AAAA,MACF;AACA,kBAAY,OAAO,GAAG,GAAG,SAAS;AAClC,kBAAY,OAAO,gBAAgB,IAAI,GAAG,GAAG,WAAW;AAAA,IAC1D;AAOJ,IAAM,qCACF,CAAoC,YAAe,WAAqC;AACtF,YAAM,cAAc,WAAW,YAAY,MAAM;AAEjD,UAAI,WAAW,YAAY,WAAW,KAAK,WAAW,YAAY,OAAO,CAAC,GAAG,MAAM,IAAI,GAAG,CAAC,MAAM,GAAG;AAClG,oBAAY,SAAS;AACrB,iBAAS,IAAI,GAAG,IAAI,OAAO,CAAC,EAAE,KAAK,QAAQ,EAAE,GAAG;AAC9C,sBAAY,KAAK,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC;AAAA,QACpC;AAAA,MACF;AACA,YAAM,iBAAiB,WAAW,WAAW;AAC7C,kBAAY,OAAO,GAAG,GAAG,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC;AAC1C,kBAAY,OAAO,iBAAiB,IAAI,GAAG,GAAG,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC;AAE/D,YAAM,OAAO,WAAW,KAAK,MAAM;AACnC,YAAM,cAAc,WAAW,YAAY,MAAM;AACjD,YAAM,gBAAgB,WAAW,cAAc,MAAM;AACrD,YAAM,aAAa,OAAO,CAAC,EAAE;AAC7B,UAAI,YAAY,WAAW,UAAU,MAAM;AAC3C,UAAI,UAAU,OAAO,CAAC,GAAG,MAAM,IAAI,GAAG,CAAC,MAAM,GAAG;AAC9C,cAAM,cAAc,OAAO,CAAC,EAAE,KAAK,SAAS;AAC5C,oBAAY,IAAI,MAAM,WAAW,EAAE,KAAK,CAAC;AAAA,MAC3C;AACA,UAAI,UAAU,WAAW,QAAQ,MAAM;AACvC,UAAI,QAAQ,OAAO,CAAC,GAAG,MAAM,IAAI,GAAG,CAAC,MAAM,GAAG;AAC5C,cAAM,cAAc,OAAO,CAAC,EAAE,KAAK,SAAS;AAC5C,kBAAU,IAAI,MAAM,WAAW,EAAE,KAAK,CAAC;AAAA,MACzC;AAGA;AAAA,QACI;AAAA,QAAY;AAAA,QAAa;AAAA,QAAW,WAAW;AAAA,QAAS,WAAW;AAAA,QAAO;AAAA,QAAM;AAAA,QAAS;AAAA,QACzF;AAAA,QAAe;AAAA,MAAW;AAG9B,YAAM,gBAAmB,OAAO,OAAO,CAAC,GAAG,UAAU;AACrD,aAAO,OAAO,eAAe,EAAC,aAAa,MAAM,eAAe,aAAa,WAAW,QAAO,CAAC;AAChG,aAAO;AAAA,IACT;AAEG,IAAM,+BAA+B,CAAC,eAAiE;AAC5G,YAAM,uBAAuB,kCAAkC,UAAU;AAEzE,YAAM,SAAS,WAAW;AAC1B,YAAM,UACF;AAAA,QAAC;AAAA,QAAU;AAAA,QAAS;AAAA,QACnB;AAAA,MAAY,EAAE,OAAO,WAAW,WAAW,cAAc,IAAI,WAAW,OAAiB;AAC9F,YAAM,YAAY,WAAW;AAC7B,YAAM,QAAQ,WAAW;AACzB,YAAM,cAAc,WAAW;AAC/B,YAAM,OAAO,WAAW;AACxB,YAAM,UAAU,WAAW;AAC3B,YAAM,WAAY,WAAW,SAA2B;AACxD,YAAM,gBAAgB,WAAW;AACjC,YAAM,cAAc,WAAW;AAC/B,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,GAAG;AAAA,QACH,UAAU,GAAG,WAAW,MAAM,IAAI,qBAAqB,UAAU;AAAA,MACnE;AAAA,IACF;AAEA,IAAMA,mBAAiB,CAAC,QAA+B,eAA8C;AAGnG,UAAI,CAAC,UAAW,OAAO,WAAW,KAAK,OAAO,WAAW,GAAI;AAC3D,cAAM,IAAI,MAAM,6BAA6B;AAAA,MAC/C;AAGA,UAAI,OAAO,CAAC,EAAE,KAAK,WAAW,KAAK,OAAO,CAAC,EAAE,KAAK,WAAW,GAAG;AAC9D,cAAM,IAAI,MAAM,2CAA2C;AAAA,MAC7D;AAEA,UAAI,OAAO,CAAC,EAAE,KAAK,WAAW,OAAO,CAAC,EAAE,KAAK,QAAQ;AACnD,cAAM,IAAI,MAAM,8CAA8C;AAAA,MAChE;AAGA,YAAM,cAAc,OAAO,CAAC,EAAE,KAAK,WAAW,WAAW,SAAS,OAAO,CAAC,EAAE,KAAK,SAAS,IAAI,CAAC;AAC/F,YAAM,kBAAkB,OAAO,CAAC,EAAE,KAAK,CAAC;AACxC,UAAI,gBAAgB,iBAAiB;AACnC,cAAM,IAAI,MAAM,mDAAmD;AAAA,MACrE;AAEA,YAAM,cAAc,OAAO,CAAC,EAAE,KAAK,CAAC,IAAI,WAAW;AAGnD,UAAI,OAAO,WAAW,MAAM,OAAO,CAAC,EAAE,KAAK,WAAW,KAAK,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,cAAc;AAC7F,cAAM,IAAI,MAAM,cAAc;AAAA,MAChC;AAEA,YAAM,cAAc,OAAO,CAAC,EAAE,KAAK,SAAS;AAC5C,YAAM,eAAe,WAAW,UAAU,OAAO,CAAC,GAAG,MAAM,IAAI,GAAG,CAAC,IAAI;AAEvE,UAAI,gBAAgB,WAAW,UAAU,WAAW,aAAa;AAC/D,cAAM,IAAI,MAAM,uBAAuB,WAAW,GAAG;AAAA,MACvD;AAEA,YAAM,aAAa,WAAW,QAAQ,OAAO,CAAC,GAAG,MAAM,IAAI,GAAG,CAAC,IAAI;AAEnE,UAAI,cAAc,WAAW,QAAQ,WAAW,aAAa;AAC3D,cAAM,IAAI,MAAM,qBAAqB,WAAW,GAAG;AAAA,MACrD;AAGA,YAAM,UAAU,WAAW,KAAK,OAAO,CAAC,GAAG,MAAM,IAAI,GAAG,CAAC,IAAI;AAC7D,UAAI,WAAW,WAAW,KAAK,WAAW,cAAc,GAAG;AACzD,cAAM,IAAI,MAAM,kBAAkB,cAAc,CAAC,GAAG;AAAA,MACtD;AAGA,UAAI,WAAW,cAAc,WAAW,eAAe,WAAW,cAAc,WAAW,GAAG;AAC5F,cAAM,IAAI,MAAM,4BAA4B,WAAW,GAAG;AAAA,MAC5D;AAIA,YAAM,iBAAiB,WAAW,YAAY,OAAO,CAAC,GAAG,MAAM,IAAI,GAAG,CAAC,IAAI;AAC3E,UAAI,kBAAkB,WAAW,YAAY,WAAW,KACpD,WAAW,YAAY,WAAW,OAAO,CAAC,EAAE,KAAK,SAAS,GAAG;AAC/D,cAAM,IAAI,MAAM,sBAAsB;AAAA,MACxC;AAGA,UAAI,WAAW,YAAY,WAAW,KAAK,WAAW,YAAY,WAAW,OAAO,CAAC,EAAE,KAAK,SAAS,GAAG;AACtG,cAAM,IAAI,MAAM,sBAAsB;AAAA,MACxC;AAAA,IACF;AAGA,IAAM,sBAAsB,CAAC,GAAG,GAAG,GAAG,CAAC;AAEvC,IAAM,kBACF,CAAC,SAAyB,QAA+B,eAA8C;AACrG,YAAM,qBAAqB,mCAAmC,YAAY,MAAM;AAChF,YAAM,iBAAiB,WAAW,WAAW;AAC7C,YAAM,cAAc,mBAAmB;AACvC,YAAM,cAAc,YAAY,iBAAiB,IAAI,CAAC;AACtD,YAAM,gBAAgB,OAAO,CAAC,EAAE,KAAK,iBAAiB,IAAI,CAAC;AAI3D,UAAI,mBAAmB,UAAU,KAAM,gBAAgB,KAAK,kBAAkB,GAAI;AAChF,gBAAQ,QAAQ,iCAAiC,QAAQ,kBAAkB,CAAC;AAC5E;AAAA,MACF;AACA,YAAM,YAAY,YAAY,iBAAiB,IAAI,CAAC;AACpD,YAAM,WAAW,YAAY,iBAAiB,IAAI,CAAC;AACnD,YAAM,eAAe,OAAO,CAAC,EAAE,KAAK,CAAC;AACrC,YAAM,cAAc,OAAO,CAAC,EAAE,KAAK,CAAC;AAEpC,YAAM,YAAY,iBAAiB,YAAY,WAAW;AAC1D,YAAM,YAAY,iBAAiB,cAAc,YAAY;AAC7D,YAAM,WAAW,eAAe,cAAc;AAE9C,YAAM;AAAA;AAAA,QAAgE;AAAA;AAItE,YAAM,mBAAoB,QAAQ,iBAAiB,MAC/C,QAAQ;AAAA,QACJ,2BAA2B,OAAO,CAAC,GAAG,mBAAmB;AAAA,QACzD,EAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,CAAC,WAAW,WAAW,KAAK,EAAE,EAAC;AAAA,MAAC,EAAE,CAAC;AAClE,UAAI,WAAW,YAAY,CAAC,QAAQ,iBAAiB,IAAI;AACvD,gBAAQ,iBAAiB,KAAK;AAAA,MAChC;AAGA,YAAM,sBAAsB,CAAC,OAAO,CAAC,GAAG,gBAAgB;AACxD,YAAM,UAAU,OAAO,WAAW;AAClC,UAAI,SAAS;AACX,YAAI,CAAC,kBAAkB,OAAO,CAAC,EAAE,KAAK,WAAW,GAAG;AAClD,8BAAoB,KAAK,OAAO,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;AAAA,QACvE,OAAO;AACL,8BAAoB,KAAK,OAAO,CAAC,CAAC;AAAA,QACpC;AAAA,MACF;AAGA,cAAQ;AAAA,QACJ;AAAA,UACI;AAAA,UAAqB;AAAA,UAAoB;AAAA,UAAa;AAAA,UAAW;AAAA,UAAW;AAAA,UAAU;AAAA,UACtF;AAAA,QAAyB;AAAA,QAC7B,EAAC,QAAQ,oBAAmB;AAAA,MAAC;AAAA,IACnC;AAEJ,IAAM,kBAAkB,CAAC,SAAyB,eAA8C;AAE9F,YAAM,gBAAgB,WAAW,WAAW;AAE5C,YAAM,SAAS;AAAA,QACb,QAAQ,OAAO,CAAC,EAAE;AAAA,UACd;AAAA;AAAA,YAEI,CAAC,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,GAAG,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC;AAAA;AAAA;AAAA,YAEnF,CAAC,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,GAAG,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC;AAAA;AAAA,QAAC;AAAA;AAAA,QAE5F,QAAQ,OAAO,CAAC,EAAE,QAAQ,CAAC,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG,GAAG,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;AAAA,MAChH;AACA,UAAI,QAAQ,OAAO,WAAW,GAAG;AAC/B,eAAO,KAAK,QAAQ,OAAO,CAAC,CAAC;AAAA,MAC/B;AACA,UAAI,cAAc,WAAW;AAC7B,UAAI,YAAY,WAAW,KAAK,YAAY,CAAC,MAAM,GAAG;AACpD,sBAAc,CAAC,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC;AAAA,MAC1C;AACA,UAAI,YAAY,WAAW;AAC3B,UAAI,UAAU,WAAW,KAAK,UAAU,CAAC,MAAM,GAAG;AAChD,oBAAY,CAAC,CAAC;AAAA,MAChB;AACA,UAAI,UAAU,WAAW;AACzB,UAAI,QAAQ,WAAW,KAAK,QAAQ,CAAC,MAAM,GAAG;AAC5C,kBAAU,CAAC,CAAC;AAAA,MACd;AACA,UAAI,OAAO,WAAW;AACtB,UAAI,KAAK,WAAW,GAAG;AACrB,eAAO,CAAC,GAAG,CAAC;AAAA,MACd;AACA,aAAO,CAAC,GAAG,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,CAAC;AAC9B,gBAAU,CAAC,CAAC,EAAE,OAAO,OAAO;AAC5B,kBAAY,CAAC,CAAC,EAAE,OAAO,SAAS;AAChC,oBAAc,CAAC,CAAC,EAAE,OAAO,WAAW;AACpC,YAAM,qBACF,mCAAmC,EAAC,GAAG,YAAY,MAAM,SAAS,WAAW,YAAW,GAAG,MAAM;AACrG,cAAQ,QAAQ;AAAA,QACZ;AAAA,QAAQ;AAAA,QACR,iBAAe,gBAAgB,CAAC,YAAY,CAAC,GAAG,YAAY,CAAC,GAAG,YAAY,CAAC,CAAC,IAC/C,CAAC,YAAY,CAAC,GAAG,YAAY,CAAC,GAAG,YAAY,CAAC,CAAC;AAAA,MAAC,CAAC;AAAA,IACtF;AAEO,IAAM,gBAAgB,CAAC,SAAyB,eAA8C;AACnG,MAAAA,iBAAe,QAAQ,QAAQ,UAAU;AACzC,UAAI,QAAQ,OAAO,CAAC,EAAE,KAAK,WAAW,GAAG;AACvC,wBAAgB,SAAS,UAAU;AAAA,MACrC,OAAO;AACL,wBAAgB,SAAS,QAAQ,QAAQ,UAAU;AAAA,MACrD;AAAA,IACF;AAAA;AAAA;;;ACpTA,IAgBM,yBAkDO,QAOA;AAzEb;AAAA;AAAA;AAGA;AAEA;AACA;AAGA;AAOA,IAAM,0BACF,CAAC,WAAmB,YAA+B,WAAuB,eACvD;AACb,YAAM,aAAa,UAAU,KAAK,UAAU;AAC5C,YAAM,OAAO,WAAW;AACxB,YAAM,QAAQ,cAAc,SAAS,WAAW,IAAI;AACpD,YAAM,SAAS,eAAe,UAAU,WAAW,IAAI;AACvD,YAAM,YAAY,UAAU,6BAA8B,UAAU,cAAc,EAAE,CAAC,IAC3B,OAAO,UAAU,iBAAiB,EAAE,CAAC,CAAC;AAChG,YAAM,OAAO,UAAU,cAAc,WAAW,IAAI;AACpD,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,QAAQ,QAAQ,MAAM,WAAW,gBAAgB,eAAe,CAAC;AACvE,cAAM,MAAM,aAAa,wBAAwB,iBAAiB,IAAI;AACtE,cAAM,aAAa,WAAW,UAAU,SAAS,WAAW,YAAY,SAAS,MAAM;AACvF,cAAM,aAAa,WAAW,UAAU,MAAM,SAAS,WAAW,YAAY,KAAK;AACnF,eAAO;AAAA,kBAEH,aAAa,gBAAgB,cAAc,KAAK,EAC3C,gBAAgB,QAAQ,KAAK,EAC7B,iBAAiB,OAAO,MAAM,CAAC;AAAA,kBAClC,aAAa,UAAU,CAAC;AAAA,oBACtB,aAAa,sCAAsC,qBAAqB,CAAC;AAAA,uCACtD,OAAO,gBAAgB,YAAY,CAAC;AAAA,8BAC7C,OAAO,KAAK,KAAK;AAAA,sCACT,UAAU;AAAA,qCACX,UAAU;AAAA;AAAA,sBAEzB,MAAM,WAAW,gBAAgB,iBAAiB,QAAQ,CAAC;AAAA,kCAC/C,MAAM,aAAa,cAAc,CAAC;AAAA;AAAA,oBAEhD,OAAO,YAAY,cAAc,KAAK,CAAC;AAAA;AAAA,MAEjD;AACA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,WAAW,UAAU,mBAAmB,CAAC,MAAM,EAAC;AAAA,QACpE,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,YAAY,UAAU,UAAS,CAAC;AAAA,UACjD,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa;AAAA;AAAA,UAAuB,EAAC;AAAA,UAClE,iBAAiB;AAAA,YACf,EAAC,uBAAuB,MAAM,WAAU;AAAA,YAAG,EAAC,uBAAuB,MAAM,KAAI;AAAA,YAC7E,GAAG,2BAA2B,YAAY,UAAU;AAAA,UACtD;AAAA,QAEF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAGD,IAAM,SAAS,CAAC,SAAyB,eAAuC;AACrF,YAAM,aAAa,QAAQ,OAAO,CAAC,EAAE;AACrC,YAAM,YAAY,QAAQ,OAAO,CAAC,EAAE;AACpC,YAAM,OAAO,QAAQ,OAAO,CAAC;AAC7B,cAAQ,QAAQ,wBAAwB,WAAW,YAAY,MAAM,UAAU,GAAG,EAAC,QAAQ,CAAC,CAAC,EAAC,CAAC;AAAA,IACjG;AAEO,IAAM,wBAAwB,CAAC,eAA0D;AAC9F,YAAM,YAAY,WAAW,cAAwB;AACrD,YAAM,UAAU,WAAW,YAAsB;AACjD,aAAO,4BAA4B,EAAC,WAAW,QAAO,CAAC;AAAA,IACzD;AAAA;AAAA;;;AC7EA,IAoBMC,kBASAC,mBAWA,+BA2DO,cAKA;AAxGb;AAAA;AAAA;AAGA;AAEA;AACA;AAGA;AAWA,IAAMD,mBAAiB,CAAC,WAAwC;AAC9D,UAAI,CAAC,UAAU,OAAO,WAAW,GAAG;AAClC,cAAM,IAAI,MAAM,gCAAgC;AAAA,MAClD;AACA,UAAI,OAAO,CAAC,EAAE,KAAK,WAAW,GAAG;AAC/B,cAAM,IAAI,MAAM,iCAAiC;AAAA,MACnD;AAAA,IACF;AAEA,IAAMC,oBAAmB,CAAC,MAAgB,MAAc,OAAsB,WAAkC;AAC9G,YAAM,cAAc,CAAC;AACrB,kBAAY,KAAK,cAAc,OAAO,KAAK,OAAO,QAAQ,MAAM,KAAK,OAAO;AAAA,aACjE,MAAM,KAAK,OAAO,GAAG;AAChC,eAAS,IAAI,GAAG,IAAI,MAAM,EAAE,GAAG;AAC7B,oBAAY,KAAK,MAAM,WAAW,KAAK,KAAK,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC;AAAA,MAC5D;AACA,kBAAY,KAAK,YAAY;AAC7B,aAAO,YAAY,KAAK,IAAI;AAAA,IAC9B;AAEA,IAAM,gCAAgC,CAAC,aAAyB,eAAoD;AAClH,UAAI,GAAW,GAAW,GAAW;AACrC,UAAI;AACJ,UAAI;AACJ,YAAM,gBAAgB,WAAW,WAAW;AAC5C,YAAM,YAAY,WAAW;AAC7B,YAAM,YAAY,WAAW,SAAS;AACtC,UAAI,eAAe;AACjB,SAAC,GAAG,GAAG,GAAG,CAAC,IAAI,YAAY;AAC3B,gBAAQ,YAAY,CAAC,GAAG,GAAG,GAAG,WAAW,WAAW,IAAK,aAAa,CAAE,IACpD,CAAC,GAAG,GAAG,GAAG,IAAK,aAAa,GAAI,WAAW,SAAS;AACxE,eAAO,YAAY,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAAA,MAC3D,OAAO;AACL,SAAC,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,YAAY,KAAK,CAAC,GAAG,YAAY,KAAK,CAAC,GAAG,YAAY,KAAK,CAAC,GAAG,YAAY,KAAK,CAAC,CAAC;AAClG,gBAAQ,YAAY,CAAC,GAAG,WAAW,WAAW,IAAK,aAAa,GAAI,GAAG,CAAC,IACpD,CAAC,GAAG,IAAK,aAAa,GAAI,WAAW,WAAW,GAAG,CAAC;AACxE,eAAO,YAAY,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAAA,MAC3D;AACA,YAAM,sBAAsB,YAAY,QAAQ,KAAK;AACrD,YAAM,oBAAoB,oBAAoB,KAAK;AACnD,YAAM,gBAAgB,YAAY;AAElC,YAAM,gBAAgB,cAAc,KAAK,eAAe,iBAAiB;AACzE,YAAM,eAAe,eAAe,UAAU,eAAe,iBAAiB;AAE9E,YAAM,kBAAkB,CAAC,iBAA+B;AAAA,IACtD,aAAa,gBAAgB,eAAe,KAAK,EAAE,iBAAiB,eAAe,YAAY,CAAC;AAAA;AAAA,IAEhGA,kBAAiB,MAAM,mBAAmB,eAAe,YAAY,CAAC;AAAA;AAAA,IAEtE,aAAa,UAAU,CAAC;AAAA,MACtB,aAAa,sCAAsC,sBAAsB,CAAC;AAAA;AAAA,oBAE5D,aAAa,gBAAgB,YAAY,CAAC;AAAA;AAAA;AAAA,MAGxD,aAAa,YAAY,cAAc,cAAc,aAAa,UAAU,CAAC,CAAC;AAAA;AAGlF,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,GAAG,YAAY,IAAI,IAAI,WAAW,SAAS,IAAI,WAAW,IAAI,IAAI,mBAAmB,CAAC,MAAM,EAAC;AAAA,QACjH,YAAY,CAAC,WAAW;AACtB,gBAAM,cAAc,gBAAgB,CAAC,GAAG,IAAI,WAAW,IAAI,WAAW,IAAK,aAAa,CAAE,IACtD,CAAC,GAAG,IAAK,aAAa,GAAI,IAAI,WAAW,IAAI,SAAS;AAC1F,gBAAM,aAAa,UAAU,KAAK,WAAW;AAC7C,gBAAM,kBAAkB,oBAAoB;AAC5C,gBAAM,iBAAiB,UAAU,gBAAgB,iBAAiB,IAAI;AACtE,iBAAO;AAAA,YACL,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,YAC3D,eAAe,EAAC,GAAG,KAAK;AAAA,cAAK,aAAa;AAAA;AAAA,YAAuB,EAAC;AAAA,YAClE,iBACI,CAAC,EAAC,uBAAuB,MAAM,WAAU,GAAG,GAAG,2BAA2B,iBAAiB,cAAc,CAAC;AAAA,UAChH;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEO,IAAM,eAAe,CAAC,SAAyB,eAA6C;AACjG,MAAAD,iBAAe,QAAQ,MAAM;AAC7B,cAAQ,QAAQ,8BAA8B,QAAQ,OAAO,CAAC,GAAG,UAAU,CAAC;AAAA,IAC9E;AAEO,IAAM,8BAA8B,CAAC,eACxC,4BAA4B;AAAA,MAC1B,WAAW,WAAW;AAAA,MACtB,MAAM,WAAW;AAAA,MACjB,QAAQ,WAAW;AAAA,IACrB,CAAC;AAAA;AAAA;;;AC7GL,IAsBM,eAEA,aACA,iBACA,YACA,gBAQA,YAqBA,gBA4HA,WAEA,yBA+GO,QAOA;AA5Sb;AAAA;AAAA;AAGA;AAEA;AACA;AAGA;AAaA,IAAM,gBACF;AACJ,IAAM,cAAc,MAAM,gBAAgB;AAC1C,IAAM,kBAAkB,MAAM,cAAc;AAC5C,IAAM,aAAa,MAAM,cAAc,QAAQ;AAC/C,IAAM,iBAAiB,MAAM,aAAa;AAQ1C,IAAM,aAAN,MAAiB;AAAA,MACf,YAAY,aAAa,IAAI;AAC3B,aAAK,kBAAkB,oBAAI,IAAsB;AACjD,aAAK,aAAa;AAAA,MACpB;AAAA;AAAA,MAGA,UAAU,QAAgB,OAAe;AACvC,YAAI,QAAQ,KAAK,gBAAgB,IAAI,MAAM;AAC3C,YAAI,UAAU,QAAW;AACvB,kBAAQ,CAAC,KAAK;AAAA,QAChB,OAAO;AACL,gBAAM,KAAK,KAAK;AAAA,QAClB;AACA,aAAK,gBAAgB,IAAI,QAAQ,KAAK;AAAA,MACxC;AAAA;AAAA,IAIF;AAEA,IAAM,iBAAN,MAAqB;AAAA,MACnB,YAAY,QAA+C,UAAkB;AAAlB;AACzD,aAAK,cAAc;AACnB,aAAK,eAAe,oBAAI,IAAwB;AAChD,aAAK,MAAM,IAAI,MAAkB;AACjC,aAAK,aAAa,CAAC;AAGnB,YAAI,CAAC,KAAK,GAAG,IAAI,SAAS,SAAS,IAAI,IAAI,SAAS,MAAM,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE;AAClF,YAAI,CAAC,IAAI,MAAM,OAAO,cAAc,CAAC,GAAG;AACtC,gBAAM,IAAI,MAAM,kBAAkB;AAAA,QACpC;AACA,cAAM,aAAa,IAAI,MAAM,GAAG;AAChC,mBAAW,QAAQ,CAAC,WAAW,UAAU;AACvC,gBAAM,OAAO,OAAO,KAAK,EAAE,KAAK,MAAM;AACtC,cAAI,CAAC,UAAU,MAAM,OAAO,eAAe,CAAC,GAAG;AAC7C,kBAAM,IAAI,MAAM,kBAAkB;AAAA,UACpC;AACA,gBAAM,aAAa,KAAK,YAAY,WAAW,MAAM,MAAM,KAAK;AAChE,eAAK,IAAI,KAAK,UAAU;AAAA,QAC1B,CAAC;AAGD,YAAI,QAAQ,IAAI;AAEd,iBAAO,CAAC,GAAG,KAAK,aAAa,QAAQ,CAAC,EAC1B,OAAO,CAAC,CAAC,KAAK,IAAI,MAAO,KAAK,UAAU,KAAK,QAAQ,KAAM,EAC3D,IAAI,CAAC,CAAC,GAAG,MAAM,GAAG,EAClB,KAAK,EAAE;AAAA,QACrB,OAAO;AACL,cAAI,CAAC,IAAI,MAAM,OAAO,WAAW,CAAC,GAAG;AACnC,kBAAM,IAAI,MAAM,aAAa;AAAA,UAC/B;AAAA,QACF;AAGA,cAAM,aAAa,IAAI,MAAM,OAAO,eAAe,GAAG,CAAC;AACvD,oBAAY,QAAQ,CAAC,WAAW;AAC9B,cAAI,WAAW,OAAO;AACpB,iBAAK,aAAa,KAAK,WAAW,OAAO,KAAK,YAAY;AAAA,UAC5D,OAAO;AACL,kBAAM,OAAO,KAAK,aAAa,IAAI,MAAM;AACzC,gBAAI,SAAS,QAAW;AACtB,oBAAM,IAAI,MAAM,oBAAoB;AAAA,YACtC;AACA,iBAAK,WAAW,KAAK,KAAK,QAAQ;AAAA,UACpC;AAAA,QACF,CAAC;AACD,aAAK,MAAM,KAAK,YAAY,KAAK,OAAO,KAAK,UAAU;AAAA,MACzD;AAAA;AAAA;AAAA,MAGA,UAAU,QAAgB,UAAkB,YAAoB;AAC9D,YAAI,OAAO,KAAK,aAAa,IAAI,MAAM;AACvC,YAAI,SAAS,QAAW;AACtB,cAAI,KAAK,aAAa,YAAY,KAAK,UAAU,GAAG;AAClD,kBAAM,IAAI,MAAM,oBAAoB;AAAA,UACtC,OAAO;AACL,iBAAK;AACL,iBAAK,aAAa,KAAK,UAAU;AAAA,UACnC;AAAA,QACF,OAAO;AACL,iBAAO,EAAC,OAAO,GAAG,UAAU,cAAc,CAAC,UAAU,EAAC;AAAA,QACxD;AACA,aAAK,aAAa,IAAI,QAAQ,IAAI;AAAA,MACpC;AAAA;AAAA,MAGA,YAAY,MAAc,SAAkB,MAAyB,QAAQ,IAAgB;AAC3F,cAAM,OAAO,KAAK;AAClB,YAAI,WAAW;AACf,YAAI,eAAe,CAAC;AACpB,YAAI,UAAU;AAEd,YAAI,CAAC,KAAK,MAAM,OAAO,eAAe,CAAC,MAAM,CAAC,WAAW,SAAS,KAAK;AACrE,gBAAM,IAAI,MAAM,kBAAkB;AAAA,QACpC;AACA,cAAM,eAAe,KAAK,MAAM,OAAO,eAAe,GAAG,CAAC;AAC1D,cAAM,aAAa,IAAI,WAAW,KAAK;AAEvC,sBAAc,QAAQ,CAAC,QAAgB,MAAc;AACnD,cAAI,WAAW,OAAO;AACpB,gBAAI,UAAU;AACZ,oBAAM,IAAI,MAAM,6CAA6C;AAAA,YAC/D;AACA,uBAAW;AACX,kBAAM,oBAAoB,OAAO,aAAa,SAAS;AACvD,gBAAI,oBAAoB,GAAG;AACzB,oBAAM,IAAI,MAAM,wBAAwB;AAAA,YAC1C;AACA,2BAAe,KAAK,MAAM,SAAS,UAAU,iBAAiB;AAC9D,gBAAI,KAAK,aAAa;AACpB,kBAAI,KAAK,aAAa,WAAW,aAAa,UAC1C,KAAK,aAAa,SAAS,MAAM,aAAa,SAAS,GAAG;AAC5D,sBAAM,IAAI,MAAM,8BAA8B;AAAA,cAChD;AAAA,YACF,WAAW,SAAS;AAClB,mBAAK,cAAc;AACnB,mBAAK,eAAe;AAAA,YACtB,OAAO;AACL,oBAAM,IAAI,MAAM,uCAAuC;AAAA,YACzD;AAEA,qBAAS,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;AAC5C,oBAAME,UAAS,OAAO,aAAa,IAAI,WAAW,CAAC,IAAI,CAAC;AACxD,yBAAW,UAAUA,SAAQ,IAAI,CAAC;AAClC,mBAAK,UAAUA,SAAQ,KAAK,SAAS,GAAG,KAAK;AAAA,YAC/C;AAAA,UACF,OAAO;AACL,uBAAW,UAAU,QAAQ,KAAK,KAAK,cAAc,KAAK,aAAa,SAAS,IAAI,EAAE;AACtF,iBAAK,UAAU,QAAQ,KAAK,SAAS,GAAG,KAAK;AAAA,UAC/C;AAAA,QACF,CAAC;AACD,eAAO;AAAA,MACT;AAAA;AAAA,IAQF;AAEA,IAAM,YAAY,CAAC,SAAyB,OAAO;AAEnD,IAAM,0BACF,CAAC,aAAuC,UAAkB,gBACzD,gBAAgD;AAC/C,YAAM,QAAQ,YAAY,IAAI,CAAC,SAAS,KAAK,MAAM;AACnD,YAAM,YAAY,MAAM,IAAI,CAAC,MAAM,UAAU,cAAc,QAAQ,KAAK,IAAI,UAAU,IAAI,CAAC;AAC3F,YAAM,aAAa,UAAU,KAAK,WAAW;AAC7C,YAAM,SAAS,eAAe,UAAU,UAAU,YAAY,MAAM;AACpE,YAAM,kBACF,CAAC,GAAG,eAAe,aAAa,KAAK,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,eAAe,IAAI,gBAAgB,IAAI,MAAM,CAAC;AAC9G,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,UAAoB,CAAC;AAC3B,cAAM,WAAW;AACjB,cAAM,UAAU;AAChB,cAAM,YAAY;AAClB,cAAM,sBAAgC,CAAC;AACvC,cAAM,uBAAiC,CAAC;AACxC,cAAM,uBAAiC,CAAC;AACxC,cAAM,kBAA4B,CAAC;AACnC,cAAM,yBAAyB,eAAe,aAAa,SAAS,eAAe,IAAI,gBAAgB;AACvG,uBAAe,aAAa,QAAQ,CAAC,MAAM,WAAW;AACpD,cAAI,eAAe,IAAI,gBAAgB,IAAI,MAAM,GAAG;AAClD,kBAAM,cAAc,eAAe,IAAI,gBAAgB,IAAI,MAAM,IAAI,CAAC;AACtE,gBAAI,gBAAgB,QAAW;AAC7B,6BAAe,IAAI,QAAQ,CAAC,MAAM,MAAM;AACtC,oBAAI,KAAK,aAAa,SAAS,CAAC,GAAG;AACjC,wBAAM,UAAU,KAAK,gBAAgB,IAAI,MAAM;AAC/C,sBAAI,YAAY,QAAW;AACzB,0BAAM,IAAI,MAAM,sBAAsB;AAAA,kBACxC;AACA,0BAAQ,QAAQ,CAAC,UAAU;AACzB,4BAAQ,KAAK,GACT,UAAU,CAAC,EAAE;AAAA,sBACT,QAAQ,CAAC;AAAA,sBAAW;AAAA,sBAAO,OAAO,WAAW,iBAAiB,WAAW;AAAA,oBAAC,CAAC,EAAE;AAAA,kBACvF,CAAC;AAAA,gBACH;AAAA,cACF,CAAC;AAAA,YACH;AAAA,UACF,OAAO;AACL,2BAAe,IAAI,QAAQ,CAAC,MAAM,MAAM;AACtC,kBAAI,KAAK,aAAa,SAAS,CAAC,GAAG;AACjC,sBAAM,UAAU,KAAK,gBAAgB,IAAI,MAAM;AAC/C,oBAAI,YAAY,QAAW;AACzB,wBAAM,IAAI,MAAM,sBAAsB;AAAA,gBACxC;AACA,wBAAQ,QAAQ,CAAC,UAAU;AACzB,sCAAoB,KAAK,GAAG,UAAU,CAAC,EAAE,WAAW,QAAQ,CAAC,WAAW,OAAO,GAAG,MAAM,EAAE,CAAC,EAAE;AAAA,gBAC/F,CAAC;AACD,gCAAgB,KAAK,WAAW,UAAU,CAAC,EAAE,aAAa,QAAQ,CAAC,SAAS,CAAC,GAAG;AAAA,cAClF;AAAA,YACF,CAAC;AACD,iCAAqB;AAAA,cACjB,WAAW,MAAM,cAAc,MAAM,eAAe,UAAU,MAAM,CAAC,KAAK,MAAM;AAAA,YAAO;AAC3F,iCAAqB,KAAK,GAAG;AAAA,UAC/B;AAAA,QACF,CAAC;AACD,cAAMC,aAAY,yBACd;AAAA,UACE,GAAG;AAAA,UACH,aAAa,UAAU,IAAI,CAAC,UAAU,MAAM,SAAS,aAAa,QAAQ,CAAC,SAAS,CAAC,EAAE,KAAK,KAAK,CAAC;AAAA,QACpG,IACA;AAAA,UACE,GAAG;AAAA,UACH;AAAA,UACA,GAAG;AAAA,UACH,GAAG;AAAA,UACH;AAAA,UACA,GAAG;AAAA,UACH;AAAA,UACA,GAAG;AAAA,QACL;AACJ,eAAO;AAAA,cAEH,aACK,iBAAiB,gBAAgB,IAAI,CAAC,YAAY,EAAC,MAAM,GAAG,UAAU,MAAM,CAAC,IAAI,MAAM,MAAK,EAAE,CAAC,EAC/F,gBAAgB,cAAc,KAAK,EACnC,iBAAiB,GAAG,WAAW,MAAM,CAAC;AAAA;AAAA,cAEzC,aAAa,UAAU,CAAC;AAAA,cACxB,aAAa,sCAAsC,qBAAqB,CAAC;AAAA,kCACrD,OAAO,gBAAgB,YAAY,CAAC;AAAA,cACxD,UAAU,IAAI,CAAC,MAAM,MAAM,YAAY,CAAC,YAAY,UAAU,CAAC,EAAE,KAAK,OAAO,GAAG,EAAE,KAAK,IAAI,CAAC;AAAA,cAC5FA,WAAU,KAAK,IAAI,CAAC;AAAA,cACpB,OAAO,YAAY,cAAc,KAAK,CAAC;AAAA;AAAA,MAE/C;AACA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,eAAe,UAAU,mBAAmB,YAAY,IAAI,MAAM,MAAM,EAAC;AAAA,QAC7F,YAAY,MAAM;AAGhB,gBAAM,sBACF,gBAAgB,OAAO,CAAC,WAAW,eAAe,aAAa,IAAI,MAAM,CAAC,EACrE;AAAA,YACG,CAAC,YACI,EAAC,uBAAuB,MAAM,eAAe,aAAa,IAAI,MAAM,GAAG,YAAY,EAAC;AAAA,UAAE;AACvG,8BAAoB,KAAK,EAAC,uBAAuB,MAAM,WAAU,CAAC;AAClE,gBAAM,kBACF,YAAY,IAAI,CAAC,MAAM,MAAM,CAAC,GAAG,2BAA2B,IAAI,CAAC,CAAC,EAC7D,OAAO,CAAC,KAAK,yBAAyB,IAAI,OAAO,oBAAoB,GAAG,mBAAmB;AACpG,0BAAgB,KAAK,GAAG,2BAA2B,WAAW,CAAC;AAC/D,iBAAQ;AAAA,YACN,SAAS,CAAC,EAAC,MAAM,aAAa,SAAQ,CAAC;AAAA,YACvC,eAAe,EAAC,GAAG,KAAK;AAAA,cAAK,aAAa;AAAA;AAAA,YAAuB,EAAC;AAAA,YAClE;AAAA,UACF;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEG,IAAM,SAAS,CAAC,SAAyB,eAAuC;AACrF,YAAM,iBAAiB,IAAI,eAAe,QAAQ,QAAQ,WAAW,QAAQ;AAC7E,YAAM,cAAc,eAAe;AACnC,YAAM,cAAc,QAAQ,OAAO,IAAI,CAAC,OAAO,MAAM,MAAM,IAAI;AAC/D,cAAQ,QAAQ,wBAAwB,aAAa,QAAQ,OAAO,CAAC,EAAE,UAAU,gBAAgB,WAAW,CAAC;AAAA,IAC/G;AAEO,IAAM,wBAAwB,CAAC,eAA0D;AAC9F,YAAM,WAAY,WAAW,SAAoB,QAAQ,QAAQ,EAAE;AACnE,aAAO,4BAA4B,EAAC,SAAQ,CAAC;AAAA,IAC/C;AAAA;AAAA;;;AC/SA,IAUMC,kBAiBA,kBAYAC,uBAIA,yBAyDO;AApGb;AAAA;AAAA;AAGA;AAEA;AAGA;AAEA,IAAMD,mBAAiB,CAAC,WAAwC;AAC9D,UAAI,CAAC,UAAU,OAAO,WAAW,GAAG;AAClC,cAAM,IAAI,MAAM,0BAA0B;AAAA,MAC5C;AACA,YAAM,aAAa,OAAO,CAAC,EAAE;AAC7B,YAAM,QAAQ,MAAM,KAAK,OAAO,CAAC,EAAE,iBAAiB,GAAG,MAAM;AAE7D,UAAI,aAAa,MAAM,SAAS,WAAW,SAAS,IAAI,MAAM,SAAS,WAAW;AAClF,UAAI,kBAAkB,WAAW,SAAS,MAAM,SAAS,IAAI,WAAW,SAAS,MAAM;AACvF,aAAO,aAAa,MAAM,UAAU,kBAAkB,WAAW,QAAQ,EAAE,YAAY,EAAE,iBAAiB;AACxG,YAAI,MAAM,UAAU,MAAM,WAAW,eAAe,KAAK,MAAM,UAAU,MAAM,KAC3E,WAAW,eAAe,MAAM,GAAG;AACrC,gBAAM,IAAI,MAAM,oDAAoD;AAAA,QACtE;AAAA,MACF;AAAA,IACF;AAEA,IAAM,mBAAmB,CAAC,QAA2B,WAAwC;AAC3F,YAAM,OAAO,OAAO,SAAS,OAAO;AACpC,YAAM,QAAkB,CAAC;AACzB,eAAS,IAAI,GAAG,IAAI,MAAM,EAAE,GAAG;AAC7B,cAAM,KAAK,OAAO,CAAC,CAAC;AAAA,MACtB;AACA,eAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,EAAE,GAAG;AACtC,cAAM,KAAK,OAAO,CAAC,MAAM,IAAI,OAAO,IAAI,IAAI,IAAI,OAAO,CAAC,CAAC;AAAA,MAC3D;AACA,aAAO;AAAA,IACT;AAEA,IAAMC,wBAAuB,CAAC,YAA+B,UACxD,WAAW,SAAS,MAAM,SAAU,iBAAiB,YAAY,KAAK,IAAI,iBAAiB,OAAO,UAAU;AAGjH,IAAM,0BAA0B,CAAC,WAA+C;AAC9E,YAAM,aAAa,OAAO,CAAC,EAAE;AAC7B,YAAM,QAAQ,MAAM,KAAK,OAAO,CAAC,EAAE,iBAAiB,GAAG,MAAM;AAC7D,YAAM,cAAwBA,sBAAqB,YAAY,KAAK;AACpE,YAAM,WAAW,OAAO,CAAC,EAAE;AAC3B,YAAM,aAAa,4BAA6B,IAAI;AACpD,YAAM,aAAa,KAAK,KAAK,UAAU,KAAK,WAAW,IAAI,UAAU;AAErE,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,QAAQ,cAAc,SAAS,UAAU,WAAW,QAAQ,UAAU;AAC5E,cAAM,SAAS,eAAe,UAAU,UAAU,YAAY,QAAQ,UAAU;AAChF,YAAI;AACJ,YAAI,2BAA4B;AAC9B,gBAAM,mBAAmB,CAAC,QAAgB,GAAW,WAAW,OAAO;AAAA,6BAChD,CAAC,MAAM,OAAO,gBAAgB,kBAAkB,CAAC,GAAG,CAAC;AAAA,sBAC5D,CAAC,MAAM,MAAM,2BAA2B,gBAAgB,CAAC,IAAI,MAAM,CAAC;AAAA,qBACrE,CAAC,YAAY,CAAC;AAAA,yBACV,CAAC,YAAY,CAAC;AAAA,YAC3B,MAAM,IAAI,CAAC,OAAO,QAAQ,IAAI,MAAM,YAAY,QAAQ,CAAC,EAAE,CAAC,aAAa,CAAC;AAAA;AAEhF,uBAAa;AAAA,0CACuB,UAAU;AAAA;AAAA,UAE1C,iBAAiB,QAAQ,GAAG,KAAK,CAAC;AAAA,UAClC,iBAAiB,QAAQ,GAAG,KAAK,CAAC;AAAA,UAClC,iBAAiB,QAAQ,GAAG,KAAK,CAAC;AAAA,UAClC,iBAAiB,QAAQ,GAAG,KAAK,CAAC;AAAA,UAClC,OAAO,YAAY,cAAc,MAAM,CAAC;AAAA;AAAA,QAE9C,OAAO;AACL,uBAAa;AAAA,8BACW,OAAO,gBAAgB,YAAY,CAAC;AAAA,4BACtC,MAAM,2BAA2B,iBAAiB,MAAM,CAAC;AAAA,UAC3E,OAAO,YAAY,cAAc,MAAM,YAAY,aAAa,CAAC,CAAC;AAAA;AAAA,QAExE;AACA,eAAO;AAAA,MACL,aAAa,gBAAgB,YAAY,KAAK,EAAE,iBAAiB,OAAO,MAAM,CAAC;AAAA,MAC/E,aAAa,UAAU,CAAC;AAAA,MACxB,aAAa,sCAAsC,mBAAmB,CAAC;AAAA,MACvE,UAAU;AAAA,MACd;AAEA,YAAM,kBACF,CAAC,EAAC,uBAAuB,MAAM,WAAU,GAAG,GAAG,2BAA2B,YAAY,WAAW,CAAC;AACtG,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,GAAG,YAAY,MAAM,IAAI,mBAAmB,CAAC,MAAM,EAAC;AAAA,QACxE;AAAA,QACA,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,UAC3D,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa;AAAA;AAAA,UAAuB,EAAC;AAAA,UAClE;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEO,IAAM,SAAS,CAAC,YAAkC;AACvD,MAAAD,iBAAe,QAAQ,MAAM;AAC7B,cAAQ,QAAQ,wBAAwB,QAAQ,MAAM,GAAG,EAAC,QAAQ,CAAC,CAAC,EAAC,CAAC;AAAA,IACxE;AAAA;AAAA;;;ACvGA,IAaM,2BAiDOE;AA9Db;AAAA;AAAA;AAGA;AAEA;AAGA;AACA;AAIA,IAAM,4BAA4B,CAAC,iBAAqD;AACtF,YAAM,WAAW,aAAa,CAAC,EAAE;AACjC,YAAM,aAAa,UAAU,KAAK,aAAa,CAAC,EAAE,IAAI;AACtD,YAAM,aAAa,UAAU,KAAK,aAAa,CAAC,EAAE,IAAI;AAEtD,YAAM,UAAU,aAAa,MAAM;AACnC,YAAM,kBAAkB,CAAC,iBAAuC;AAC9D,cAAM,IAAI,cAAc,KAAK,UAAU,CAAC,CAAC,GAAG,CAAC;AAC7C,cAAM,OAAO,cAAc,QAAQ,UAAU,CAAC,CAAC,GAAG,CAAC;AACnD,cAAM,IAAI,eAAe,KAAK,UAAU,CAAC,CAAC,GAAG,CAAC;AAE9C,cAAM,WAA8B,CAAC,EAAC,MAAM,mBAAmB,MAAM,MAAK,GAAG,EAAC,MAAM,aAAa,MAAM,MAAK,CAAC;AAE7G,cAAM,oBAAoB,CAAC,MAAe;AAAA,gBAC9B,CAAC,oCAAoC,CAAC;AAAA,gBACtC,CAAC,MAAM,KAAK,YAAY,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC;AACnE,cAAM,oBAAoB,UACtB;AAAA,mBACW,KAAK,YAAY,uCAAuC,CAAC,MACpE,GAAG,kBAAkB,CAAC,CAAC,GAAG,kBAAkB,CAAC,CAAC,GAAG,kBAAkB,CAAC,CAAC,GAAG,kBAAkB,CAAC,CAAC;AAAA,mBACjF,EAAE,KAAK,KAAK;AAE3B,eAAO,GAAG,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,GAAG,MAAM,CAAC,CAAC;AAAA;AAAA,MAEtE,aAAa,0BAA0B,QAAQ,CAAC,CAAC;AAAA;AAAA,MAEvD,aAAa,UAAU,cAAc,CAAC;AAAA,QACpC,aAAa,sCAAsC,0BAA0B,CAAC;AAAA;AAAA,gBAEtE,EAAE,YAAY,YAAY,CAAC;AAAA,QACnC,iBAAiB;AAAA;AAAA,QAEjB,EAAE,YAAY,cAAoB,mBAAmB,MAAM,CAAC,CAAC;AAAA;AAAA,MAEnE;AAEA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,GAAG,OAAO,IAAI,mBAAmB,CAAC,QAAQ,MAAM,EAAC;AAAA,QACrE;AAAA,QACA,YAAY,CAAC,YAAY;AAAA,UACvB,SAAS,CAAC,EAAC,MAAM,OAAO,CAAC,EAAE,MAAM,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,UAC9D,iBACI,CAAC,EAAC,uBAAuB,MAAM,KAAK,KAAK,aAAa,CAAC,EAAC,GAAG,EAAC,uBAAuB,MAAM,WAAU,CAAC;AAAA,UACxG,eAAe,EAAC,GAAG,KAAK,KAAK,aAAa,iBAAiB,CAAC,EAAC;AAAA,QAC/D;AAAA,MACF;AAAA,IACF;AAEO,IAAMA,YAAW,CAAC,YAAkC;AACzD,UAAI,QAAQ,OAAO,SAAS,KAAK,UAAU,KAAK,QAAQ,OAAO,CAAC,EAAE,IAAI,MAAM,GAAG;AAC7E,QAAM,SAAS,OAAO;AAAA,MACxB,OAAO;AACL,gBAAQ,QAAQ,0BAA0B,QAAQ,MAAM,CAAC;AAAA,MAC3D;AAAA,IACF;AAAA;AAAA;;;ACpEA,IAeMC,kBAMA,yBAsGO,uBAGA;AA9Hb;AAAA;AAAA;AAGA;AAEA;AACA;AAGA;AAMA,IAAMA,mBAAiB,CAAC,WAAwC;AAC9D,UAAI,CAAC,UAAU,OAAO,WAAW,GAAG;AAClC,cAAM,IAAI,MAAM,2BAA2B;AAAA,MAC7C;AAAA,IACF;AAEA,IAAM,0BAA0B,CAAC,QAA+B,eAA8C;AAC5G,YAAM,aAAa,OAAO,CAAC,EAAE;AAC7B,YAAM,eAAe,OAAO,CAAC,EAAE;AAE/B,YAAM,YAAY,WAAW;AAC7B,YAAM,OAAO,UAAU,cAAc,WAAW,MAAM,SAAS;AAE/D,YAAM,cAAc,WAAW,MAAM,CAAC;AACtC,kBAAY,OAAO,MAAM,GAAG,GAAG,YAAY;AAE3C,YAAM,eAAe,WAAW,IAAI;AACpC,YAAM,aAAa,OAAO,CAAC,EAAE,4BAA6B,IAAI;AAC9D,YAAM,aAAa,KAAK,KAAK,UAAU,KAAK,WAAW,IAAI,UAAU;AAErE,YAAM,kBAAoC;AAAA,QACxC,EAAC,uBAAuB,MAAM,WAAU;AAAA,QAAG,EAAC,qBAAsB,MAAM,aAAY;AAAA,QACpF,EAAC,uBAAuB,MAAM,KAAI;AAAA,QAAG,GAAG,2BAA2B,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,EAAE,MAAM,WAAW;AAAA,MAChH;AAEA,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,OAAO,cAAc,QAAQ,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,QAAQ,UAAU;AACxF,cAAM,UAAU,cAAc,gBAAgB,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,MAAM;AACvF,cAAM,SAAS,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,YAAY,QAAQ,UAAU;AAE1F,cAAM,kBAAkB,CAAC,MAA6B;AACpD,gBAAM,cAAc,aAAa;AACjC,cAAI,UAAU,qBAAqB,CAAC,OAAO,QAAQ,KAAK,OAAO;AAC/D,mBAAS,IAAI,GAAG,IAAI,aAAa,KAAK;AACpC,uBAAW,GAAG,cAAc,IAAI,iBAAiB,CAAC,IAAI,CAAC,MAAM,iBAAiB,CAAC,EAAE,MAC7E,YAAY,SAAS,IAAI,gBAAgB,CAAC,oBAAoB,CAAC,MAAM,gBAAgB,CAAC,EAAE;AAAA,UAC9F;AACA,qBAAW;AAAA,mBACE,CAAC,MAAM,QAAQ,aAAa,iBAAiB,CAAC,EAAE,CAAC;AAAA,mBACjD,CAAC;AAAA,iBACH,CAAC,SAAS,CAAC;AAAA;AAAA,2BAED,CAAC,MAAM,KAAK,KAAK,OAAO;AAAA;AAE7C,mBAAS,IAAI,GAAG,IAAI,GAAG,IAAI,WAAW,KAAK;AACzC,gBAAI,MAAM,MAAM;AACd,yBAAW,GAAG,YAAY,IAAI,cAAc,CAAC,IAAI,CAAC,MAAM,cAAc,CAAC,EAAE,aAAa,CAAC;AACvF,mBAAK;AAAA,YACP,OAAO;AACL,yBAAW,GAAG,YAAY,IAAI,cAAc,CAAC,IAAI,CAAC,MAAM,cAAc,CAAC,EAAE,MACrE,YAAY,SAAS,IAAI,gBAAgB,CAAC,IAAI,CAAC,MAAM,gBAAgB,CAAC,EAAE;AAC5E;AAAA,YACF;AAAA,UACF;AACA,iBAAO;AAAA,QACT;AACA,YAAI;AACJ,YAAI,OAAO,CAAC,EAAE,2BAA4B;AACxC,gBAAM,mBAAmB,CAAC,QAAgB,GAAW,WAAW,OAAO;AAAA,6BAChD,CAAC,MAAM,OAAO,gBAAgB,kBAAkB,CAAC,GAAG,CAAC;AAAA,YACtE,gBAAgB,CAAC,CAAC;AAAA,sBACR,CAAC,MAAM,KAAK,gBAAgB,cAAc,CAAC,EAAE,CAAC;AAAA,qBAC/C,CAAC,YAAY,CAAC;AAAA,yBACV,CAAC,YAAY,CAAC;AAAA,YAC3B,MAAM,IAAI,CAAC,OAAO,QAAQ,IAAI,KAAK,YAAY,QAAQ,CAAC,EAAE,CAAC,aAAa,CAAC;AAAA;AAE/E,uBAAa;AAAA,0CACuB,UAAU;AAAA;AAAA,UAE1C,iBAAiB,SAAS,GAAG,KAAK,CAAC;AAAA,UACnC,iBAAiB,SAAS,GAAG,KAAK,CAAC;AAAA,UACnC,iBAAiB,SAAS,GAAG,KAAK,CAAC;AAAA,UACnC,iBAAiB,SAAS,GAAG,KAAK,CAAC;AAAA,UACnC,OAAO,YAAY,cAAc,OAAO,CAAC;AAAA;AAAA,QAE/C,OAAO;AACL,uBAAa;AAAA,4BACS,OAAO,gBAAgB,YAAY,CAAC;AAAA,QACxD,gBAAgB,EAAE,CAAC;AAAA,oBACP,KAAK,aAAa,aAAa,CAAC;AAAA,QAC5C,OAAO,YAAY,cAAc,OAAO,CAAC;AAAA;AAAA,QAE7C;AACA,eAAO;AAAA,QAEH,aAAa,gBAAgB,cAAc,KAAK,EAC3C,gBAAgB,gBAAgB,KAAK,EACrC,gBAAgB,QAAQ,KAAK,EAC7B,iBAAiB,MAAM,SAAS,MAAM,CAAC;AAAA,QAC5C,aAAa,UAAU,CAAC;AAAA,UACtB,aAAa,sCAAsC,qBAAqB,CAAC;AAAA,UACzE,UAAU;AAAA;AAAA,MAElB;AACA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,WAAW,UAAU,mBAAmB,CAAC,QAAQ,MAAM,EAAC;AAAA,QAC5E,YAAY,OAAO;AAAA,UACjB,SAAS;AAAA,YACP,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ;AAAA,UAClD;AAAA,UACA,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa;AAAA;AAAA,UAAuB,EAAC;AAAA,UAClE;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEO,IAAM,wBAAwB,CAAC,eAClC,4BAA4B,EAAC,MAAM,WAAW,KAAc,CAAC;AAE1D,IAAM,SAAS,CAAC,SAAyB,eAAuC;AACrF,YAAM,SAAS,QAAQ;AACvB,MAAAA,iBAAe,MAAM;AACrB,cAAQ,QAAQ,wBAAwB,QAAQ,QAAQ,UAAU,CAAC;AAAA,IACrE;AAAA;AAAA;;;AClIA,IAeMC,kBAeA,iCA+DO,+BAGA;AAhGb;AAAA;AAAA;AAGA;AAEA;AACA;AAGA;AAMA,IAAMA,mBAAiB,CAAC,WAAwC;AAC9D,UAAI,CAAC,UAAU,OAAO,WAAW,GAAG;AAClC,cAAM,IAAI,MAAM,mCAAmC;AAAA,MACrD;AAEA,UAAI,OAAO,CAAC,EAAE,KAAK,SAAS,GAAG;AAC7B,cAAM,IAAI,MAAM,2DAA2D;AAAA,MAC7E;AAEA,UAAI,OAAO,CAAC,EAAE,KAAK,WAAW,OAAO,CAAC,EAAE,KAAK,QAAQ;AACnD,cAAM,IAAI,MAAM;AAAA,4DACwC;AAAA,MAC1D;AAAA,IACF;AAEA,IAAM,kCACF,CAAC,QAA+B,eAAsD;AACpF,YAAM,aAAa,OAAO,CAAC,EAAE;AAC7B,YAAM,sBAAsB,OAAO,CAAC,EAAE;AACtC,YAAM,YAAY,WAAW;AAE7B,YAAM,eAAe,OAAO,CAAC,EAAE;AAC/B,YAAM,kBAAkB,OAAO,CAAC,EAAE;AAClC,YAAM,OAAO,UAAU,cAAc,WAAW,MAAM,SAAS;AAC/D,YAAM,eAAe,WAAW,IAAI;AAEpC,YAAM,cAAc,aAAa,MAAM,CAAC;AACxC,YAAM,aAAa,UAAU,KAAK,WAAW;AAE7C,YAAM,QAAQ,cAAc,SAAS,qBAAqB,SAAS;AACnE,YAAM,UAAU,cAAc,gBAAgB,iBAAiB,aAAa,MAAM;AAClF,YAAM,SAAS,eAAe,UAAU,qBAAqB,YAAY,MAAM;AAG/E,YAAM,kBAAoC;AAAA,QACxC,EAAC,uBAAuB,MAAM,WAAU;AAAA,QAAG,EAAC,qBAAsB,MAAM,aAAY;AAAA,QACpF,EAAC,uBAAuB,MAAM,KAAI;AAAA,MACpC;AACA,sBAAgB,KAAK,GAAG,2BAA2B,YAAY,cAAc,WAAW,CAAC;AACzF,YAAM,oBAAwD,CAAC,QAAQ,MAAM;AAK7E,YAAM,kBAAkB,CAAC,iBAA+B;AAAA,QAEpD,aAAa,gBAAgB,cAAc,KAAK,EAC3C,gBAAgB,gBAAgB,KAAK,EACrC,gBAAgB,QAAQ,KAAK,EAC7B,iBAAiB,OAAO,SAAS,MAAM,CAAC;AAAA,QAC/C,aAAa,UAAU,CAAC;AAAA,QACxB,aAAa,sCAAsC,qBAAqB,CAAC;AAAA;AAAA,4BAErD,OAAO,gBAAgB,YAAY,CAAC;AAAA;AAAA,kBAE9C,QAAQ,YAAY,YAAY,CAAC;AAAA;AAAA;AAAA;AAAA,2BAIxB,MAAM,KAAK,OAAO;AAAA,QACrC,MAAM,WAAW,gBAAgB,iBAAiB,UAAU,CAAC;AAAA,oBACjD,MAAM,aAAa,cAAc,CAAC;AAAA;AAAA,QAE9C,OAAO,YAAY,cAAc,OAAO,CAAC;AAAA;AAG3C,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,kBAAiB;AAAA,QAC/B,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,UAC3D,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa;AAAA;AAAA,UAAuB,EAAC;AAAA,UAClE;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEG,IAAM,gCAAgC,CAAC,eAC1C,4BAA4B,EAAC,MAAM,WAAW,KAAc,CAAC;AAE1D,IAAM,iBAAiB,CAAC,SAAyB,eAA+C;AACrG,YAAM,SAAS,QAAQ;AACvB,MAAAA,iBAAe,MAAM;AACrB,cAAQ,QAAQ,gCAAgC,QAAQ,QAAQ,UAAU,CAAC;AAAA,IAC7E;AAAA;AAAA;;;ACpGA,IAWMC,kBA0BA,uBAwFO,qBAQA;AArIb;AAAA;AAAA;AAGA;AAEA;AAIA;AAEA,IAAMA,mBAAiB,CAAC,WAAwC;AAC9D,UAAI,CAAC,QAAQ;AACX,cAAM,IAAI,MAAM,kBAAkB;AAAA,MACpC;AACA,UAAI,OAAO,SAAS,KAAK,OAAO,SAAS,GAAG;AAC1C,cAAM,IAAI,MAAM,sBAAsB;AAAA,MACxC;AAGA,UAAI,OAAO,WAAW,KAAK,OAAO,CAAC,EAAE,KAAK,SAAS,GAAG;AACpD,cAAM,IAAI,MAAM,0BAA0B;AAAA,MAC5C;AAEA,UAAK,OAAO,CAAC,EAAE,aAAa,OAAO,CAAC,EAAE,YACjC,OAAO,WAAW,KAAK,OAAO,CAAC,EAAE,aAAa,OAAO,CAAC,EAAE,UAAW;AACtE,cAAM,IAAI,MAAM,4BAA4B;AAAA,MAC9C;AAAA,IACF;AASA,IAAM,wBAAwB,CAAC,QAA+B,eAA4C;AACxG,YAAM,SAAS,OAAO,CAAC,EAAE,KAAK,MAAM;AACpC,YAAM,SAAS,OAAO,CAAC,EAAE,KAAK,MAAM;AACpC,YAAM,CAAC,GAAG,GAAG,CAAC,IAAI,SAAS;AAAA,QACvB;AAAA,QAAQ,WAAW;AAAA,QAAQ;AAAA,QAAQ,WAAW;AAAA,QAAQ,OAAO,WAAW,IAAI,OAAO,CAAC,EAAE,OAAO;AAAA,MAAS;AAC1G,YAAM,cAAc,CAAC,GAAG,CAAC;AACzB,UAAI,CAAC,aAAa;AAChB,cAAM,IAAI,MAAM,qCAAsC;AAAA,MACxD;AACA,YAAM,aAAa,UAAU,KAAK,WAAW;AAC7C,YAAM,kBAAoC;AAAA,QACxC,EAAC,uBAAuB,MAAM,WAAU;AAAA,QAAG,EAAC,uBAAuB,MAAM,EAAC;AAAA,QAAG,EAAC,uBAAuB,MAAM,EAAC;AAAA,QAC5G,EAAC,uBAAuB,MAAM,EAAC;AAAA,QAAG,EAAC,qBAAsB,MAAM,WAAW,MAAK;AAAA,QAC/E,EAAC,qBAAsB,MAAM,WAAW,KAAI;AAAA,MAC9C;AACA,YAAM,oBAAwD,CAAC,QAAQ,MAAM;AAC7E,UAAI,OAAO,WAAW,GAAG;AACvB,wBAAgB,KAAK,GAAG,2BAA2B,OAAO,CAAC,EAAE,IAAI,CAAC;AAClE,0BAAkB,KAAK,MAAM;AAAA,MAC/B;AACA,sBAAgB,KAAK,GAAG,2BAA2B,WAAW,CAAC;AAE/D,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,YAAI,OAAO;AACX,YAAI,WAAW,UAAU,WAAW,QAAQ;AAC1C,iBAAO;AAAA,QACT,WAAW,WAAW,UAAU,CAAC,WAAW,QAAQ;AAClD,iBAAO;AAAA,QACT,WAAW,CAAC,WAAW,UAAU,WAAW,QAAQ;AAClD,iBAAO;AAAA,QACT,WAAW,CAAC,WAAW,UAAU,CAAC,WAAW,QAAQ;AACnD,iBAAO;AAAA,QACT;AAEA,cAAM,iBAAiB,WAAW,UAAU,IAAI,KAAK;AACrD,cAAM,IAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,IAAI;AAC/D,cAAM,IAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,IAAI;AAC/D,cAAM,WAAW,EAAE,KAAK;AACxB,YAAI,IAAwB;AAC5B,cAAM,YAAY,CAAC,GAAG,CAAC;AACvB,YAAI,OAAO,WAAW,GAAG;AACvB,cAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,MAAM;AAChE,oBAAU,KAAK,CAAC;AAAA,QAClB;AACA,cAAM,SAAS,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,YAAY,MAAM;AAC9E,kBAAU,KAAK,MAAM;AACrB,cAAM,WAA8B;AAAA,UAClC,EAAC,MAAM,eAAe,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,KAAK,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,KAAK,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,KAAK,MAAM,MAAK;AAAA,UAC/G,EAAC,MAAM,SAAS,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,QAAQ,MAAM,MAAK;AAAA,QAC1D;AACA,eAAO;AAAA,IACP,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,GAAG,SAAS,CAAC;AAAA;AAAA,IAEtE,aAAa,UAAU,CAAC;AAAA,MACtB,aAAa,sCAAsC,sBAAsB,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,kBAK9D,QAAQ;AAAA;AAAA,QAElB,IAAI;AAAA;AAAA;AAAA,MAGN,cAAc;AAAA,OACb,MAAM;AACP,cAAI,KAAK,MAAM;AACb,mBAAO,iBAAiB,EAAE,2BAA2B,cAAc,MAAM,CAAC,cACtE,QAAQ,qBAAqB,EAAE,YAAY,SAAS,CAAC;AAAA,UAC3D;AACA,iBAAO;AAAA,QACT,GAAG,CAAC;AAAA;AAAA;AAAA,MAGN;AAEA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,GAAG,WAAW,QAAQ,IAAI,kBAAiB;AAAA,QAC/D,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,UAC3D,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa;AAAA;AAAA,UAAuB,EAAC;AAAA,UAClE;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEO,IAAM,sBAAsB,CAAC,eAAwD;AAC1F,YAAM,SAAS,WAAW;AAC1B,YAAM,SAAS,WAAW;AAC1B,YAAM,QAAQ,WAAW;AACzB,YAAM,OAAO,WAAW;AACxB,aAAO,EAAC,QAAQ,QAAQ,OAAO,MAAM,UAAU,GAAG,WAAW,MAAM,IAAI,WAAW,MAAM,IAAI,WAAW,UAAU,CAAC,GAAE;AAAA,IACtH;AAEO,IAAM,OAAO,CAAC,SAAyB,eAAqC;AACjF,MAAAA,iBAAe,QAAQ,MAAM;AAC7B,cAAQ,QAAQ,sBAAsB,QAAQ,QAAQ,UAAU,CAAC;AAAA,IACnE;AAAA;AAAA;;;ACxIA,IAeM,+BAwGA,aAwHA,mCAoDO;AAnSb;AAAA;AAAA;AAGA;AAEA;AAGA;AAOA,IAAM,gCACF,CAAC,QAA+B,eAAoD;AAClF,YAAM,SAAS,OAAO,CAAC,EAAE;AACzB,YAAM,cAAc;AACpB,YAAM,OAAO;AACb,YAAM,YAAY,UAAU,gBAAgB,QAAQ,IAAI;AACxD,YAAM,WAAW,UAAU,kBAAkB,QAAQ,IAAI;AACzD,YAAM,aAAa,iBAAiB,QAAQ;AAC5C,YAAM,iBAAiB,WAAW;AAClC,YAAM,aAAa,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,GAAG,cAAc;AACxD,YAAM,oBAAwD,CAAC,QAAQ,QAAQ,MAAM;AACrF,YAAM,kBACF,CAAC,EAAC,uBAAuB,MAAM,SAAQ,GAAG,EAAC,uBAAuB,MAAM,eAAc,CAAC;AAC3F,sBAAgB,KAAK,GAAG,2BAA2B,YAAY,UAAU,CAAC;AAE1E,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,IAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,WAAW,QAAQ,UAAU;AAC9E,cAAM,QAAQ,cAAc,SAAS,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,IAAI;AACvE,cAAM,OAAO,cAAc,QAAQ,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,IAAI;AACrE,cAAM,SAAS,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,WAAW,QAAQ,UAAU;AACzF,cAAM,YAAY,CAAC,GAAG,OAAO,MAAM,MAAM;AACzC,cAAM,WAAW,EAAE,KAAK;AACxB,cAAM,UAAU,eAAe,IAAI,QAAQ,MAAM,UAAU;AAC3D,cAAM,gBAAgB;AAEtB,cAAM,WAA8B,CAAC,EAAC,MAAM,YAAY,MAAM,MAAK,GAAG,EAAC,MAAM,kBAAkB,MAAM,MAAK,CAAC;AAC3G,eAAO;AAAA;AAAA;AAAA,2CAG4B,OAAO,KAAK,aAAa;AAAA,0BAC1C,aAAa;AAAA,IACnC,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,GAAG,SAAS,CAAC;AAAA,IACtE,aAAa,UAAU,aAAa,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAOrB,OAAO;AAAA;AAAA,4BAEC,OAAO,IAAI,EAAE,IAAI,SAAS,WAAW,GAAG,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAahD,UAAU,sBAAsB,UAAU,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,gBAKhD,OAAO;AAAA;AAAA,yBAEE,OAAO,IAAI,EAAE,IAAI,SAAS,WAAW,GAAG,CAAC,OAAO,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,4BAcpD,UAAU,sBAAsB,UAAU,CAAC;AAAA;AAAA;AAAA;AAAA,mFAIY,WAAW,OAAO;AAAA,yCAC5D,MAAM,YAAY,SAAS,CAAC;AAAA,6BACxC,KAAK,YAAY,SAAS,CAAC;AAAA;AAAA,oBAEpC,EAAE,IAAI,SAAS,WAAW,GAAG,CAAC,MAAM,QAAQ,IAAI,OAAO,qBAAqB,QAAQ,IAC5F,OAAO;AAAA,QACX,OAAO,IAAI,SAAS,WAAW,KAAK,OAAO,CAAC;AAAA;AAAA;AAAA,MAG9C;AACA,aAAO;AAAA,QACL,GAAG,EAAC,MAAM,wBAAuB;AAAA;AAAA,QAEjC,aAAa,EAAC,MAAM,GAAG,WAAW,OAAO,IAAI,UAAU,IAAI,kBAAiB;AAAA,QAC5E,YAAY,OAAO;AAAA,UACjB,SAAS;AAAA,YACP,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ;AAAA,UAClD;AAAA,UACA,eAAe,EAAC,GAAG,UAAS;AAAA,UAC5B;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEJ,IAAM,cACF,CAAC,SAAyB,OAAmB,OAAmB,MAAkB,GAAW,GAAW,GACvG,YAAoB;AACnB,YAAM,aAAa,iBAAiB,CAAC;AACrC,YAAM,KAAK;AAGX,YAAM,aAAa,eAAe,IAAI,UAAU,QAAQ,UAAU;AAClE,YAAM,cAAc,eAAe,IAAI,QAAQ,MAAM,UAAU;AAC/D,YAAM,iBAAiB,CAAC,MAAc,SAAiB,GAAG,UAAU,IAAI,IAAI,KAAK,IAAI;AACrF,YAAM,cAAc,IAAI,IAAI;AAC5B,YAAM,SAAS,KAAK,KAAK,IAAI,EAAE;AAE/B,YAAM,wBAA4D,CAAC,MAAM;AACzE,YAAM,sBAAwC;AAAA,QAC5C,EAAC,uBAAuB,MAAM,OAAM;AAAA,QAAG,EAAC,uBAAuB,MAAM,EAAC;AAAA,QACtE,EAAC,uBAAuB,MAAM,KAAK,MAAM,IAAI,UAAU,EAAC;AAAA,QACxD,EAAC,uBAAuB,MAAM,KAAK,MAAM,IAAI,IAAI,UAAU,EAAC;AAAA,MAC9D;AAEA,YAAM,sBAAsB,CAAC,iBAA+B;AAC1D,cAAM,cAAc,cAAc,SAAS,MAAM,UAAU,MAAM,MAAM,UAAU;AACjF,eAAO;AAAA,IACX,aAAa,iBAAiB,WAAW,CAAC;AAAA,kEACoB,UAAU;AAAA;AAAA;AAAA;AAAA,IAIxE,aAAa,UAAU,EAAE,CAAC;AAAA,4CACc,EAAE;AAAA,+CACC,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAQjC,WAAW,OAAO,UAAU,CAAC;AAAA,uBACtB,WAAW,OAAO,UAAU,CAAC;AAAA;AAAA,sBAE9B,WAAW;AAAA;AAAA;AAAA;AAAA,2BAIN,eAAe,OAAO,YAAY,CAAC;AAAA;AAAA,MAExD;AAEA,YAAM,aAAa,QAAQ;AAAA,QACvB;AAAA,UACE,MAAM;AAAA,UACN,aAAa,EAAC,MAAM,GAAG,UAAU,IAAI,mBAAmB,sBAAqB;AAAA,UAC7E,YAAY,OAAO;AAAA,YACjB,SAAS;AAAA,cACP,EAAC,MAAM,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,wBAAwB;AAAA,YAChD;AAAA,YACA,eAAe,EAAC,GAAG,IAAI,IAAI,WAAU;AAAA,YACrC,iBAAiB;AAAA,UACnB;AAAA,UACA,iBAAiB;AAAA,QACnB;AAAA,QACA,EAAC,QAAQ,CAAC,KAAK,GAAG,SAAS,CAAC,EAAE,EAAC;AAAA,MAAC,EAAE,CAAC;AAEvC,YAAM,kBAAoC;AAAA,QACxC,EAAC,uBAAuB,MAAM,YAAW;AAAA,QAAG,EAAC,uBAAuB,MAAM,EAAC;AAAA,QAC3E,EAAC,uBAAuB,MAAM,KAAK,MAAM,IAAI,UAAU,EAAC;AAAA,QACxD,EAAC,uBAAuB,MAAM,KAAK,MAAM,KAAK,IAAI,UAAU,EAAC;AAAA,MAC/D;AACA,YAAM,oBAAwD,CAAC,QAAQ,QAAQ,MAAM;AACrF,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,cAAc,cAAc,SAAS,MAAM,UAAU,MAAM,MAAM,UAAU;AACjF,cAAM,aAAa,cAAc,QAAQ,KAAK,UAAU,KAAK,MAAM,UAAU;AAC7E,eAAO;AAAA,2DAC4C,UAAU;AAAA,2DACV,YAAY,KAAK,OAAO;AAAA,0DACzB,WAAW,KAAK,OAAO;AAAA,kEACf,UAAU;AAAA;AAAA;AAAA;AAAA,IAIxE,aAAa,UAAU,CAAC;AAAA,MACtB,aAAa,sCAAsC,wBAAwB,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,gBAKlE,WAAW,OAAO,UAAU,CAAC;AAAA,uBACtB,WAAW,OAAO,UAAU,CAAC;AAAA,mCACjB,EAAE;AAAA,gEAC2B,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,+DAMH,OAAO;AAAA,qCACjC,WAAW;AAAA,yBACvB,WAAW;AAAA;AAAA,2BAET,eAAe,gBAAgB,cAAc,CAAC;AAAA;AAAA,MAEnE;AACA,aAAO,QAAQ;AAAA,QACX;AAAA,UACE,MAAM;AAAA;AAAA,UAEN,aAAa,EAAC,MAAM,GAAG,UAAU,IAAI,OAAO,IAAI,kBAAiB;AAAA,UACjE,YAAY,OAAO;AAAA,YACjB,SAAS;AAAA,cACP,EAAC,MAAM,CAAC,GAAG,GAAG,CAAC,GAAG,wBAAwB;AAAA,YAC5C;AAAA,YACA,eAAe,EAAC,GAAG,KAAK;AAAA,cAAK,cAAc;AAAA;AAAA,YAAuB,EAAC;AAAA,YACnE;AAAA,UACF;AAAA,UACA;AAAA,QACF;AAAA,QACA,EAAC,QAAQ,CAAC,YAAY,OAAO,IAAI,GAAG,SAAS,CAAC,EAAE,EAAC;AAAA,MAAC,EAAE,CAAC;AAAA,IAC3D;AAEJ,IAAM,oCACF,CAAC,SAAyB,QAA+B,eAAuC;AAC9F,YAAM,SAAS,OAAO,CAAC,EAAE;AACzB,YAAM,cAAc;AACpB,YAAM,IAAI,OAAO,CAAC;AAClB,YAAM,IAAI,OAAO,OAAO,SAAS,CAAC;AAClC,YAAM,IAAI,UAAU,kBAAkB,QAAQ,CAAC,IAAI;AACnD,YAAM,aAAa,iBAAiB,CAAC;AACrC,YAAM,aAAa,UAAU,KAAK,WAAW,IAAI;AACjD,YAAM,kBACF,CAAC,EAAC,uBAAuB,MAAM,EAAC,GAAG,EAAC,uBAAuB,MAAM,KAAK,MAAM,IAAI,UAAU,EAAC,CAAC;AAChG,YAAM,oBAAwD,CAAC,QAAQ,MAAM;AAE7E,YAAM,oBAAoB,YAAY,SAAS,OAAO,CAAC,GAAG,OAAO,CAAC,GAAG,OAAO,CAAC,GAAG,GAAG,GAAG,GAAG,WAAW,OAAO;AAC3G,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,WAAW,4BAA4B,OAAO,CAAC,EAAE,QAAQ;AAC/D,cAAM,YAAY,eAAe,IAAI,UAAU,QAAQ,UAAU;AACjE,cAAM,gBAAgB,eAAe,IAAI,WAAW,MAAM,UAAU,IAAI,QAAQ;AAEhF,cAAM,cAAc,cAAc,SAAS,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,MAAM,UAAU;AACzF,cAAM,eAAe,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,aAAa,UAAU;AAEzF,eAAO;AAAA,2DAC4C,YAAY,KAAK,OAAO;AAAA,gEACnB,SAAS;AAAA,kEACP,aAAa,KAAK,OAAO;AAAA;AAAA;AAAA;AAAA,IAIvF,aAAa,UAAU,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kDAMsB,aAAa,eAAe,aAAa;AAAA;AAAA,MAErF;AACA,cAAQ;AAAA,QACJ;AAAA,UACE,MAAM;AAAA,UACN,aAAa,EAAC,MAAM,GAAG,UAAU,IAAI,kBAAiB;AAAA,UACtD,YAAY,OAAO;AAAA,YACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,YAC3D,eAAe,EAAC,GAAG,KAAK;AAAA,cAAK,aAAa;AAAA;AAAA,YAAuB,EAAC;AAAA,YAClE;AAAA,UACF;AAAA,UACA;AAAA,QACF;AAAA,QACA,EAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,iBAAiB,EAAC;AAAA,MAAC;AAAA,IAC9C;AAEG,IAAM,eAAe,CAAC,SAAyB,eAA6C;AACjG,UAAI,WAAW,WAAW,QAAQ;AAChC,0CAAkC,SAAS,QAAQ,QAAQ,UAAU;AAAA,MACvE,OAAO;AACL,gBAAQ,QAAQ,8BAA8B,QAAQ,QAAQ,UAAU,CAAC;AAAA,MAC3E;AAAA,IACF;AAAA;AAAA;;;ACzSA,IAgBMC,kBAMA,4BA6GO;AAnIb;AAAA;AAAA;AAGA;AAEA;AAGA;AAQA,IAAMA,mBAAiB,CAAC,WAAwC;AAC9D,UAAI,CAAC,UAAU,OAAO,SAAS,GAAG;AAChC,cAAM,IAAI,MAAM,uCAAuC;AAAA,MACzD;AAAA,IACF;AAEA,IAAM,6BACF,CAAC,QAA+B,YAAiC,gBAAqC;AACpG,YAAM,aAAa,WAAW;AAE9B,YAAM,SAAS,OAAO,CAAC,EAAE;AACzB,YAAM,QAAQ,OAAO,CAAC;AACtB,YAAM,OAAO,CAAC,cAAc,OAAO,CAAC;AAEpC,YAAM,cAAc;AACpB,YAAM,OAAO,UAAU,cAAc,WAAW,MAAM,OAAO,MAAM;AACnE,YAAM,YAAY,UAAU,gBAAgB,QAAQ,IAAI;AACxD,YAAM,WAAW,UAAU,kBAAkB,QAAQ,IAAI;AAEzD,YAAM,YAAY,UAAU,KAAK,MAAM,IAAI;AAC3C,YAAM,WAAW,OAAO,UAAU,KAAK,KAAK,IAAI,IAAI;AACpD,UAAI,cAAc,YAAa,QAAQ,aAAa,UAAW;AAC7D,cAAM,IAAI,MAAM,+BAA+B,QAAQ;AAAA;AAAA,2BAEpC,SAAS,qBAAqB,QAAQ,EAAE;AAAA,MAC7D;AAEA,YAAM,mBAA6B,CAAC;AACpC,eAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,EAAE,GAAG;AACtC,YAAI,IAAI,MAAM;AACZ,2BAAiB,KAAK,OAAO,CAAC,CAAC;AAAA,QACjC,OAAO;AACL,2BAAiB,KAAK,CAAC;AAAA,QACzB;AAAA,MACF;AACA,YAAM,aAAa,iBAAiB,QAAQ;AAC5C,YAAM,oBAAwD,CAAC,QAAQ,MAAM;AAC7E,YAAM,kBAAoC;AAAA,QACxC,EAAC,uBAAuB,MAAM,UAAS;AAAA,QAAG,EAAC,qBAAsB,MAAM,SAAQ;AAAA,QAC/E,EAAC,uBAAuB,MAAM,KAAK,MAAM,WAAW,UAAU,EAAC;AAAA,QAC/D,EAAC,qBAAsB,MAAM,WAAW,QAAO;AAAA,MACjD;AACA,UAAI,MAAM;AACR,0BAAkB,KAAK,MAAM;AAAA,MAC/B;AACA,YAAM,oBAAoB,cAAc;AACxC,YAAM,kBAAkB,cAAc;AAEtC,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,WAAW,4BAA4B,OAAO,CAAC,EAAE,QAAQ;AAC/D,cAAM,YAAY;AAAA,UAChB,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,MAAM,UAAU;AAAA,UACjE,cAAc,SAAS,MAAM,UAAU,MAAM,MAAM,UAAU;AAAA,QAC/D;AACA,YAAI,MAAM;AACR,oBAAU,KAAK,cAAc,QAAQ,KAAK,UAAU,KAAK,MAAM,UAAU,CAAC;AAAA,QAC5E;AACA,kBAAU,KAAK,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,aAAa,UAAU,CAAC;AACpF,YAAI,mBAAmB;AACrB,oBAAU,KAAK,eAAe,mCAAoC,gBAAgB,CAAC;AAAA,QACrF;AACA,YAAI,iBAAiB;AACnB,oBAAU,KAAK,eAAe,iCAAkC,gBAAgB,CAAC;AAAA,QACnF;AAEA,cAAM,WAA8B;AAAA,UAClC,EAAC,MAAM,cAAc,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,aAAa,MAAM,MAAK;AAAA,UAClE,EAAC,MAAM,wBAAwB,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,WAAW,MAAM,MAAK;AAAA,QAC5E;AACA,eAAO;AAAA,IACX,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,GAAG,SAAS,CAAC;AAAA,IACtE,aAAa,UAAU,CAAC;AAAA,MACtB,aAAa,sCAAsC,qBAAqB,CAAC;AAAA;AAAA,wBAEvD,WAAW,OAAO,UAAU,CAAC;AAAA,+BACtB,WAAW,OAAO,UAAU,CAAC;AAAA;AAAA;AAAA,oBAGxC,UAAU,UAAU,YAAY,eAAe,CAAC;AAAA;AAAA;AAAA;AAAA,iBAInD,UAAU,eAAe,UAAU,CAAC;AAAA,oCACjB,UAAU,sBAAsB,UAAU,CAAC,yBACnE,aAAa,KAAK,eAAe;AAAA;AAAA;AAAA,uBAGtB,UAAU,UAAU,YAAY,eAAe,CAAC;AAAA,uBAChD,UAAU,UAAU,YAAY,UAAU,CAAC;AAAA,6BACrC,UAAU,CAAC,EAAE,KAAK,KAAK,cAAc,aAAa,KAAK,QAAQ;AAAA,UAClF,OAAO,KAAK,UAAU,UAAU,YAAY,SAAS,CAAC,KAAK,EAAE;AAAA;AAAA;AAAA;AAAA,MAIjE,oBAAoB,wCAAwC,EAAE;AAAA,MAC9D,kBAAkB,6CAA6C,EAAE;AAAA;AAAA,MAEjE;AACA,YAAM,UAAU,CAAC,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAClE,UAAI,mBAAmB;AACrB,gBAAQ,KAAK,EAAC,MAAM,kBAAkB,wBAAwB,CAAC;AAAA,MACjE;AACA,UAAI,iBAAiB;AACnB,gBAAQ,KAAK,EAAC,MAAM,kBAAkB,wBAAwB,CAAC;AAAA,MACjE;AAEA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,GAAG,UAAU,IAAI,WAAW,IAAI,UAAU,IAAI,kBAAiB;AAAA,QACnF,YAAY,OACP,EAAC,SAAS,eAAe,EAAC,GAAG,KAAK;AAAA,UAAK,YAAY;AAAA;AAAA,QAAuB,EAAC,GAAG,gBAAe;AAAA,QAClG;AAAA,MACF;AAAA,IACF;AAEG,IAAM,YAAY,CAAC,SAAyB,eAA0C;AAC3F,MAAAA,iBAAe,QAAQ,MAAM;AAC7B,cAAQ,QAAQ,2BAA2B,QAAQ,QAAQ,YAAY,QAAQ,WAAW,CAAC;AAAA,IAC7F;AAAA;AAAA;;;ACtIA,IAoBMC,kBA+BO,8BAmPA,aAQA;AA9Sb;AAAA;AAAA;AAGA;AAEA;AACA;AAGA;AAWA,IAAMA,mBAAiB,CAAC,QAA+B,eAA4C;AACjG,UAAI,OAAO,SAAS,KAAK,OAAO,SAAS,GAAG;AAC1C,cAAM,IAAI,MAAM,oCAAoC;AAAA,MACtD;AACA,YAAM,IAAI,OAAO,CAAC;AAClB,YAAM,QAAQ,EAAE,KAAK;AACrB,UAAI,EAAE,KAAK,QAAQ,CAAC,MAAM,WAAW,GAAG;AACtC,cAAM,IAAI,MAAM,wDAAwD;AAAA,MAC1E;AACA,YAAM,gBAAgB,KAAK,OAAO,WAAW,IAAI,WAAW,YAAY,KAAK,WAAW,SAAS;AACjG,YAAM,WAAW,WAAW,YAAY,IAAI,WAAW;AACvD,YAAM,IAAI,OAAO,CAAC;AAClB,UAAI,CAAC,UAAU,SAAS,EAAE,MAAM,CAAC,WAAW,GAAG,eAAe,QAAQ,CAAC,GAAG;AACxE,cAAM,IAAI,MAAM,6EAA6E;AAAA,MAC/F;AACA,YAAM,SAAS,OAAO,CAAC;AACvB,YAAM,cAAc,OAAO;AAC3B,UAAI,UAAU,KAAK,WAAW,MAAM,WAAW,IAAI,eAAe;AAChE,cAAM,IAAI,MAAM,0BAA0B;AAAA,MAC5C;AACA,UAAI,OAAO,WAAW,GAAG;AACvB,cAAM,aAAa,OAAO,CAAC;AAC3B,cAAM,kBAAkB,WAAW;AACnC,cAAM,yBACF,WAAW,OAAO,IAAK,WAAW,IAAI,gBAAiB,WAAW,IAAI,KAAK,OAAO,gBAAgB,KAAK,CAAC;AAC5G,YAAI,UAAU,KAAK,eAAe,MAAM,wBAAwB;AAC9D,gBAAM,IAAI,MAAM,8BAA8B;AAAA,QAChD;AAAA,MACF;AAAA,IACF;AAEO,IAAM,+BACT,CAAC,QAA+B,YAC/B,0BAAoD,mCAAwD;AAC3G,YAAM,aAAa,OAAO,CAAC,EAAE;AAC7B,YAAM,QAAQ,WAAW;AACzB,YAAM,gBAAgB,KAAK,OAAO,WAAW,IAAI,WAAW,YAAY,KAAK,WAAW,SAAS;AACjG,YAAM,YAAY,WAAW,QAAQ,CAAC;AACtC,YAAM,WAAW,WAAW;AAC5B,YAAM,YAAY,WAAW;AAC7B,YAAM,YAAY,WAAW,MAAM,GAAG,QAAQ,CAAC;AAC/C,YAAM,YAAY,UAAU,KAAK,SAAS;AAC1C,YAAM,WAAW,WAAW,YAAY,IAAI,WAAW;AACvD,YAAM,kBAAkB,WAAW;AACnC,YAAM,WAAW,OAAO,CAAC,EAAE;AAC3B,YAAM,eAAe,iBAAiB,SAAS;AAC/C,YAAM,cAAc,iBAAiB,WAAW,CAAC;AACjD,YAAM,cAAc,iBAAiB,eAAe;AACpD,YAAM,cAAc,qBAAqB,QAAQ;AACjD,YAAM,sBAAsB,YAAY,gBAAgB;AACxD,YAAM,wBAAwB,KAAK,MAAM,iCAAiC,mBAAmB;AAC7F,YAAM,0BAA0B,iBAAiB,yBAAyB,CAAC,KAAK,wBAAwB;AACxG,YAAM,aAAc,CAAC,2BAA2B,yBAAyB,IAAK,iBAAiB,SAAS,IAClG,yBAAyB,KAAM,iBAAiB,SAAS,KAAK,IAAU,IACA;AAC9E,YAAM,cAAc,UAAU,OAAO,CAAC,WAAW,SAAS,CAAC;AAC3D,YAAM,aAAa,UAAU,KAAK,WAAW,IAAI,aAAa;AAE9D,YAAM,kBAAoC,0BACtC,CAAC,IACD,CAAC,EAAC,uBAAuB,MAAM,WAAU,GAAG,EAAC,uBAAuB,MAAM,WAAW,UAAS,CAAC;AACnG,YAAM,iBAAiB,CAAC,WAAW,WAAW,WAAW,WAAW;AACpE,YAAM,SAAS,UAAU,aAAa,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM;AAC5D,aAAO,OAAO,IAAI,GAAG,kBAAkB,WAAW;AAClD,sBAAgB,KAAK,GAAG,2BAA2B,cAAc,CAAC;AAClE,sBAAgB,KAAK,GAAG,2BAA2B,MAAM,CAAC;AAC1D,sBAAgB,KAAK,GAAG,2BAA2B,OAAO,CAAC,EAAE,IAAI,CAAC;AAClE,UAAI,OAAO,WAAW,GAAG;AACvB,wBAAgB,KAAK,GAAG,2BAA2B,UAAU,aAAa,OAAO,CAAC,EAAE,IAAI,CAAC,CAAC;AAAA,MAC5F;AACA,YAAM,kBAAkB,CAAC,WAAW,WAAW,YAAY,UAAU;AACrE,sBAAgB,KAAK,GAAG,2BAA2B,eAAe,CAAC;AACnE,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,YAAY,eAAe;AACjC,cAAM,IAAI,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,WAAW,WAAW;AACvE,cAAM,IAAI,cAAc,sBAAsB,OAAO,QAAQ,WAAW;AACxE,cAAM,SAAS,cAAc,UAAU,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,MAAM;AAChF,cAAM,iBAAiB,CAAC,GAAG,GAAG,MAAM;AACpC,cAAM,aACF,OAAO,WAAW,IAAI,cAAc,gCAAgC,OAAO,CAAC,EAAE,KAAK,MAAM,IAAI;AACjG,YAAI,YAAY;AACd,yBAAe,KAAK,UAAU;AAAA,QAChC;AACA,cAAM,aAAa,gBAAgB;AACnC,cAAM,SAAS,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,YAAY,UAAU;AAClF,cAAM,WAA8B,CAAC,EAAC,MAAM,eAAe,MAAM,MAAK,GAAG,EAAC,MAAM,cAAc,MAAM,MAAK,CAAC;AAC1G,cAAMC,YAAW,4BAA4B,OAAO,CAAC,EAAE,QAAQ;AAE/D,cAAM,eAAe,MAAM;AACzB,kBAAQ,aAAa;AAAA,YACnB,KAAK;AACH,qBAAO,SAASA,SAAQ;AAAA,YAC1B,KAAK;AACH,qBAAO,UAAUA,SAAQ;AAAA,YAC3B,KAAK;AACH,qBAAO,UAAUA,SAAQ;AAAA,YAC3B;AACE,oBAAM,IAAI,MAAM,GAAG,WAAW,8BAA8B;AAAA,UAChE;AAAA,QACF,GAAG;AAEH,cAAM,kBAAkB;AAAA,yCACS,eAAe,aAAa,WAAW;AAAA,YACpE,EAAE,WAAW,aAAa,KAAK,MAAM,CAAC;AAAA,yBACzB,EAAE,aAAa,WAAW,CAAC;AAAA,qCACf,WAAW;AAAA,iCACf,gBAAgB,IAAI,WAAW,kBAAkB;AAAA;AAAA;AAAA;AAAA,uCAI3C,WAAW,IACtC,MAAM,KAAK,EAAC,QAAQ,EAAC,GAAG,CAAC,GAAG,MAAM,GAAGA,SAAQ,kBAAkB,CAAC,OAAOA,SAAQ,kBAAkB,CAAC,IAAI,EACjG,KAAK,IAAI,CAAC;AAAA,0CACe,MAAM;AACtC,cAAI,gBAAgB,GAAG;AACrB,mBAAO,GAAG,WAAW,IACjB,MAAM,KAAK,EAAC,QAAQ,EAAC,GAAG,CAAC,GAAG,MAAM,uBAAuB,CAAC,yBAAyB,EAAE,KAAK,IAAI,CAAC;AAAA,UACrG,OAAO;AACL,mBAAO,yBAAyB,WAAW,IAAI,MAAM,CAAC,EAAE,KAAK,YAAY,EAAE,KAAK,GAAG,CAAC;AAAA,UACtF;AAAA,QACF,GAAG,CAAC;AAAA;AAAA,uCAE2B,0BAA0B,YAAY,YAAY;AAAA,gBACzE,EAAE,WAAW,aAAa,YAAY,GAAG,0BAA0B,MAAM,SAAS,YAAY,MAAM,CAAC;AAAA,gBACrG,EAAE,WAAW,aAAa,YAAY,GAAG,aAAa,CAAC;AAAA,mCACpC,EAAE,gBAAgB,WAAW,CAAC;AAAA,4BACrC,WAAW;AAAA,yCACE,IAAI,WAAW;AAAA,8BAC1B,EAAE,YAAY,cAAc,CAAC;AAAA;AAAA;AAAA,gBAG3C,0BAA0B,kDAAkD,kBAAkB,GAClG,aAAa,IAAI,QAAQ,EAAE,OAC3B,MACK;AAAA,UACG,EAAC,QAAQ,IAAI,YAAW;AAAA,UACxB,CAAC,GAAG,MAAM,GACN,gBAAgB,IAAI,UAAU,CAAC,4BAA4B,CAAC,MACxC,cAAc,CAAC,2BAA2B,CAAC,IAAI;AAAA,QAAE,EAC5E,KAAK,KAAK,CAAC;AAAA;AAAA,6BAEC,IAAI,WAAW;AAAA;AAAA;AAGpC,cAAM,uBAAuB,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA,gCAKlB,WAAW,YAAY,kBAAkB,CAAC;AAAA,eAExB;AAE1C,eAAO,0BAA0B;AAAA,iDACQ,OAAO,KAAK,KAAK,KAAK,YAAY,aAAa;AAAA,UACtF,aAAa,iBAAiB,GAAG,gBAAgB,MAAM,CAAC;AAAA,UACxD,aAAa,UAAU;AAAA,UACvB;AAAA,UAAe;AAAA,UAAG;AAAA,QACpB,CAAC,CAAC;AAAA,2BACiB,EAAE,KAAK,OAAO;AAAA;AAAA;AAAA;AAAA,YAI7B,EAAE,WAAW,aAAa,KAAK,OAAO,CAAC;AAAA;AAAA,qCAEd,UAAU;AAAA,sDACO,UAAU;AAAA,gBAEnB,aAAa;AAAA,mDACP,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yCAMvB,WAAW,YAAY,uBAAuB,CAAC,gCAC9B,EAAE;AAAA,6BAC/B,EAAE,KAAK,OAAO;AAAA,cAC7B,EAAE,WAAW,aAAa,KAAK,6BAA6B,CAAC;AAAA;AAAA,+DAEZ,aAAa;AAAA,0BAClD,OAAO,YAAY,cAAc,CAAC;AAAA;AAAA,+BAE7BA,SAAQ,IAAI,aAAa,6BAA6B,CAAG;AAAA,cAC1E,EAAE,WAAW,aAAa,KAAK,OAAO,CAAC;AAAA,6CACR,WAAW,YAAY,WAAW;AAAA,yDACtB,SAAS;AAAA,cACpD,eAAe;AAAA;AAAA;AAAA;AAAA,kCAIK,OAAO,KAAK,OAAO;AAAA,cACvC,OAAO,WAAW,kBAAkB,KAAK,OAAO,CAAC;AAAA,cACjD,OAAO,WAAW,kBAAkB,aAAa,GAAG,KAAK,CAAC;AAAA,cAC1D,OAAO,WAAW,kBAAkB,aAAa,GAAG,GAAG,CAAC;AAAA,kCACpC,OAAO,gBAAgB,gBAAgB,CAAC;AAAA,wCAClC,SAAS;AAAA,kCACf,OAAO,KAAK,KAAK,MAAM,OAAO,KAAK,KAAK;AAAA;AAAA,0CAEhC,aAAa;AAAA;AAAA,6CAEV,SAAS;AAAA;AAAA,gBAEtC,OAAO,YAAY,iBAAiB,cAAc,CAAC;AAAA,iCAClC,YAAY,UAAU;AAAA;AAAA;AAAA,aAId;AAAA,UAC/B,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,GAAG,gBAAgB,MAAM,CAAC;AAAA,UACnF,aAAa,UAAU,CAAC;AAAA,YACtB,aAAa,sCAAsC,sBAAsB,CAAC;AAAA,qCACjD,OAAO,KAAK,KAAK,KAAK,YAAY;AAAA,iCACtC,OAAO,gBAAgB,YAAY,CAAC;AAAA,sBAC/C,OAAO,WAAW,kBAAkB,aAAa,CAAC,CAAC;AAAA,sBACnD,OAAO,WAAW,kBAAkB,aAAa,CAAC,CAAC;AAAA,2BAC9C,EAAE,KAAK,OAAO;AAAA;AAAA;AAAA;AAAA,YAKI,aAAa;AAAA,8CACZ,UAAU,QAAQ,aAAa;AAAA;AAAA,uCAEtC,WAAW,YAAY,kBAAkB,CAAC;AAAA,2EAEvB,EAAE;AAAA,oCACxB,gBAAgB,UAAU;AAAA,2BACnC,EAAE,KAAK,OAAO;AAAA,qCACJ,UAAU;AAAA,cACjC,EAAE,WAAW,aAAa,KAAK,SAAS,UAAU,MAAM,CAAC;AAAA;AAAA,+CAExB,aAAa;AAAA;AAAA,4BAEhC,OAAO,YAAY,aAAa,CAAC;AAAA;AAAA,iCAE5BA,SAAQ,IAAI,aAAa,uDAAuD,CAAG;AAAA,gBACpG,EAAE,WAAW,aAAa,KAAK,OAAO,CAAC;AAAA;AAAA,gBAEvC,eAAe;AAAA;AAAA,gBAEf,oBAAoB;AAAA,sDACkB,WAAW;AAAA;AAAA;AAAA,cAIpB,aAAa;AAAA,kBACxC,oBAAoB;AAAA,mBAEoB,EAAE;AAAA;AAAA,wCAEpB,YAAY;AAAA,gBACpC,OAAO,WAAW,kBAAkB,aAAa,GAAG,GAAG,YAAY,YAAY,CAAC;AAAA,gBAChF,OAAO,aAAa,kBAAkB,kBAAkB,CAAC;AAAA;AAAA;AAAA,MAGnE;AACA,aAAO;AAAA,QACL,MAAM,0BAA0B,yBAAyB;AAAA,QACzD,aAAa;AAAA,UACX,MAAM,GAAG,WAAW,QAAQ,IAAI,SAAS,IAAI,QAAQ,IAAI,OAAO,MAAM;AAAA,UACtE,mBAAmB,MAAM,OAAO,MAAM,EAAE,KAAK,MAAM;AAAA,QACrD;AAAA,QACA,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,SAAQ,CAAC;AAAA,UACvC,MAAM,0BAA0B,yBAAyB;AAAA,UACzD,eAAe,0BAA0B,EAAC,GAAG,GAAG,GAAG,KAAK,KAAK,YAAY,UAAU,GAAG,GAAG,UAAS,IACzD,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa;AAAA;AAAA,UAAuB,EAAC;AAAA,UAC5F;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEG,IAAM,cAAc,CAAC,SAAyB,eAA4C;AAC/F,MAAAD,iBAAe,QAAQ,QAAQ,UAAU;AACzC,YAAM,2BAAqD,QAAQ,4BAA4B;AAC/F,YAAM,iCAAiC,QAAQ,kCAAkC;AACjF,cAAQ,QAAQ;AAAA,QACZ,QAAQ;AAAA,QAAQ;AAAA,QAAY;AAAA,QAA0B;AAAA,MAA8B,CAAC;AAAA,IAC3F;AAEO,IAAM,6BAA6B,CAAC,eACvC,4BAA4B,UAAsE;AAAA;AAAA;;;AC/StG,IAaM,UAGAE,kBAiOO,mCAGPC,2BAEA,kBA0CA,gCA2BO;AA3Tb;AAAA;AAAA;AAGA;AAEA;AACA;AACA;AAEA;AACA;AACA;AAEA,IAAM,WAAW,CAAC,QAA+B,MAC5C,OAAO,SAAS,KAAO,OAAO,CAAC,EAAE,KAAK,SAAS,KAAO,UAAU,KAAK,OAAO,CAAC,EAAE,IAAI,IAAK,IAAI,OAAO,CAAC,IAAI;AAE7G,IAAMD,mBAAiB,CAAC,QAA+B,eAAoD;AACzG,YAAM,QAAQ,OAAO,CAAC;AACtB,YAAM,MAAM,SAAS,QAAQ,CAAC;AAC9B,YAAM,QAAQ,SAAS,QAAQ,CAAC;AAChC,YAAM,OAAO,SAAS,QAAQ,CAAC;AAC/B,YAAM,iBAAiB,SAAS,QAAQ,CAAC;AACzC,YAAM,uBAAuB,SAAS,QAAQ,CAAC;AAC/C,YAAM,UAAU,SAAS,QAAQ,CAAC;AAClC,YAAM,YAAY,SAAS,QAAQ,CAAC;AAoCpC,UAAI,MAAM,KAAK,WAAW,KAAK,MAAM,KAAK,WAAW,GAAG;AACtD,cAAM,IAAI,MAAM,mDAAmD;AAAA,MACrE;AAEA,YAAM,eAAe;AACrB,YAAM,YAAY,MAAM,KAAK,CAAC;AAC9B,YAAM,iBAAiB,MAAM,KAAK,CAAC;AACnC,YAAM,aAAa,MAAM,KAAK,WAAW,IAAK,eAAe,MAAM,KAAK,CAAC,IAAI,IAAI,MAAM,KAAK,CAAC,IAChD,WAAW,WAAW,MAAM,KAAK,CAAC;AAC/E,UAAI,mBAAmB;AAEvB,UAAI,qBAAqB;AACzB,UAAI,oBAAoB;AACxB,YAAM,WAAW,KAAK,MAAM,aAAa,WAAW,QAAQ;AAC5D,UAAI,WAAW,WAAW;AACxB,YAAI,QAAQ,KAAK,WAAW,GAAG;AAC7B,gBAAM,IAAI,MAAM,mDAAmD;AAAA,QACrE;AACA,YAAI,QAAQ,KAAK,CAAC,MAAM,aAAa,QAAQ,KAAK,CAAC,MAAM,WAAW,YAAY,QAAQ,KAAK,CAAC,MAAM,UAAU;AAC5G,gBAAM,IAAI,MAAM,iFAAiF;AAAA,QACnG;AACA,YAAI,UAAU,KAAK,CAAC,MAAM,aAAa,UAAU,KAAK,CAAC,MAAM,WAAW,YACpE,UAAU,KAAK,CAAC,MAAM,UAAU;AAClC,gBAAM,IAAI,MAAM,mFAAmF;AAAA,QACrG;AACA,YAAI,QAAQ,KAAK,CAAC,MAAM,UAAU,KAAK,CAAC,GAAG;AACzC,gBAAM,IAAI,MAAM,gFAAgF;AAAA,QAClG;AACA,YAAI,UAAU,KAAK,WAAW,GAAG;AAC/B,gBAAM,IAAI,MAAM,qDAAqD;AAAA,QACvE;AACA,6BAAqB,QAAQ,KAAK,CAAC;AACnC,4BAAoB,QAAQ,KAAK,CAAC;AAAA,MACpC,WAAW,WAAW,WAAW;AAC/B,cAAM,IAAI,MAAM,wEAAwE;AAAA,MAC1F;AAEA,UAAI;AACJ,UAAI,KAAK;AACP,YAAI,MAAM,KAAK,WAAW,GAAG;AAC3B,gBAAM,IAAI,MAAM,kEAAkE;AAAA,QACpF;AACA,YAAI,IAAI,KAAK,SAAS,KAAK,IAAI,KAAK,SAAS,GAAG;AAC9C,gBAAM,IAAI,MAAM,uDAAuD;AAAA,QACzE;AACA,YAAI,MAAM,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,GAAG;AACjC,gBAAM,IAAI,MAAM,4DAA4D;AAAA,QAC9E;AAEA,YAAI,IAAI,KAAK,WAAW,GAAG;AACzB,cAAI,IAAI,KAAK,CAAC,MAAM,MAAM,KAAK,CAAC,GAAG;AACjC,kBAAM,IAAI,MAAM,6DAA6D;AAAA,UAC/E;AACA;AACA,6BAAmB,IAAI,KAAK,CAAC;AAAA,QAC/B,WAAW,IAAI,KAAK,WAAW,GAAG;AAChC,cAAI,IAAI,KAAK,CAAC,MAAM,WAAW,YAAY,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM,UAAU;AACxF,kBAAM,IAAI,MAAM,4FAA4F;AAAA,UAC9G;AACA,cAAI,OAAO;AACT,kBAAM,IAAI,MAAM,yDAAyD;AAAA,UAC3E;AACA;AACA,6BAAmB,IAAI,KAAK,CAAC;AAAA,QAC/B,OAAO;AACL,cAAI,IAAI,KAAK,CAAC,MAAM,WAAW,YAAY,IAAI,KAAK,CAAC,MAAM,UAAU;AACnE,kBAAM,IAAI,MAAM,wFAAwF;AAAA,UAC1G;AAEA;AACA,6BAAmB,IAAI,KAAK,CAAC;AAAA,QAC/B;AAAA,MACF,OAAO;AACL,YAAI,MAAM,KAAK,WAAW,KAAK,MAAM,KAAK,WAAW,GAAG;AACtD,gBAAM,IAAI,MAAM,uEAAuE;AAAA,QACzF;AACA,YAAI,MAAM,KAAK,WAAW,MAAM,MAAM,KAAK,CAAC,MAAM,WAAW,YAAY,MAAM,KAAK,CAAC,MAAM,IAAI;AAC7F,gBAAM,IAAI,MAAM,8FAA8F;AAAA,QAChH;AAEA;AAAA,MACF;AAEA,UAAI,MAAM;AACR,YAAI,KAAK,KAAK,WAAW,GAAG;AAC1B,gBAAM,IAAI,MAAM,8CAA8C;AAAA,QAChE;AAEA,YAAI,OAAO;AACT,cAAI,MAAM,KAAK,WAAW,KAAK,MAAM,KAAK,CAAC,MAAM,GAAG;AAClD,kBAAM,IAAI,MAAM,oCAAoC;AAAA,UACtD;AAAA,QACF;AAAA,MACF;AAEA,UAAI;AACJ,UAAI,gBAAgB;AAClB;AACA,cAAM,WAAW,eAAe;AAChC,YAAI,SAAS,WAAW,GAAG;AACzB,cAAI,SAAS,CAAC,MAAM,WAAW;AAC7B;AAAA,UACF,WAAW,SAAS,CAAC,MAAM,IAAI,YAAY,GAAG;AAC5C;AAAA,UACF;AAAA,QACF,WAAW,SAAS,WAAW,KAAK,SAAS,CAAC,MAAM,aAAa,SAAS,CAAC,MAAM,kBAAkB;AACjG;AAAA,QACF;AACA,YAAI,kCAA4C;AAC9C,gBAAM,IAAI,MAAM,0FAA0F;AAAA,QAC5G;AACA,cAAM,IAAI,MAAM,oBAAoB;AAAA,MACtC;AAEA,UAAI,eAAe;AACnB,UAAI,cAAc;AAClB,UAAI,OAAO;AACT,YAAI,MAAM,KAAK,WAAW,KAAK,MAAM,KAAK,WAAW,GAAG;AACtD,gBAAM,IAAI,MAAM,qDAAqD;AAAA,QACvE;AAEA,YAAI,MAAM,KAAK,CAAC,MAAM,MAAM,KAAK,CAAC,GAAG;AACnC,gBAAM,IAAI,MAAM,8DAA8D;AAAA,QAChF;AAEA,YAAI,MAAM,KAAK,WAAW,GAAG;AAC3B,cAAI,qBAAqB,MAAM,KAAK,CAAC,GAAG;AACtC,kBAAM,IAAI,MAAM,wEAAwE;AAAA,UAC1F;AACA,wBAAc,MAAM,KAAK,CAAC;AAAA,QAC5B,OAAO;AACL,cAAI,qBAAqB,MAAM,KAAK,CAAC,GAAG;AACtC,kBAAM,IAAI,MAAM,kFAAkF;AAAA,UACpG;AACA,wBAAc,MAAM,KAAK,CAAC,IAAI,MAAM,KAAK,CAAC;AAC1C,yBAAe;AAAA,QACjB;AAAA,MACF;AAEA,YAAM,sBAAsB,qBAAqB;AACjD,YAAM,sBAAsB;AAE5B,UAAI,gBAAgB;AAClB,cAAM,IAAI,MAAM,mCAAmC;AAAA,MACrD;AAEA,UAAI,sBAAsB;AACxB,YAAI,qBAAqB,KAAK,WAAW,GAAG;AAC1C,gBAAM,IAAI,MAAM,iEAAiE;AAAA,QACnF;AACA,YAAK,qBAAqB,KAAK,CAAC,MAAM,aAAa,qBAAqB,KAAK,CAAC,MAAM,KAChF,qBAAqB,KAAK,CAAC,MAAM,WAAW,YAAY,qBAAqB,KAAK,CAAC,MAAM,kBACzF,qBAAqB,KAAK,CAAC,MAAM,qBAAqB;AACxD,gBAAM,IAAI,MAAM,2FAA2F;AAAA,QAC7G;AAAA,MACF;AAEA,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,iBAAiB;AAAA,QACjB;AAAA,QACA;AAAA,QACA;AAAA,QACA,WAAW,KAAK,MAAM,cAAc,WAAW,QAAQ;AAAA,QACvD,UAAU,WAAW;AAAA,QACrB,kBAAkB;AAAA,QAClB,wBAAwB;AAAA,QACxB,iBAAiB,WAAW;AAAA,QAC5B;AAAA,QACA,OAAO,WAAW;AAAA,QAClB;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEO,IAAM,oCAAoC,CAAC,eAC9C,4BAA4B,EAAC,GAAG,WAAU,CAAC;AAE/C,IAAMC,4BAAgD,4BAA4B,EAAC,MAAM,CAAC,GAAG,GAAG,GAAG,CAAC,EAAC,CAAC;AAEtG,IAAM,mBACF,CAAC,SAAyB,KAAiB,MAAkB,WAAmB,gBAC/E,YAAoB,eAAuB;AAC1C,YAAM,cAAc,CAAC,WAAW,gBAAgB,UAAU;AAC1D,YAAM,aAAa,UAAU,KAAK,WAAW;AAC7C,YAAM,kBAAoC;AAAA,QACxC,EAAC,uBAAuB,MAAM,WAAU;AAAA,QAAG,EAAC,uBAAuB,MAAM,WAAU;AAAA,QACnF,EAAC,uBAAuB,MAAM,WAAU;AAAA,MAC1C;AAEA,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,SAAS,eAAe,iBAAiB,IAAI,UAAU,WAAW;AACxE,cAAM,WAAW,cAAc,OAAO,IAAI,UAAU,WAAW;AAC/D,cAAM,YAAY,cAAc,QAAQ,KAAK,UAAU,WAAW;AAElE,cAAM,WAA8B;AAAA,UAClC,EAAC,MAAM,eAAe,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,eAAe,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,eAAe,MAAM,MAAK;AAAA,QAC3G;AACA,eAAO;AAAA,IACX,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,UAAU,WAAW,MAAM,CAAC;AAAA,IACrF,aAAa,UAAU,CAAC;AAAA,MACtB,aAAa,sCAAsC,sBAAsB,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,MAK1E;AAEA,aAAO,QAAQ;AAAA,QACX;AAAA,UACE,MAAM;AAAA,UACN,aAAa,EAAC,mBAAmB,CAAC,QAAQ,MAAM,EAAC;AAAA,UACjD,YAAY,OAAO;AAAA,YACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,IAAI,UAAU,6BAAgC,CAAC;AAAA,YACvF,eAAe,EAAC,GAAG,KAAK;AAAA,cAAK,aAAa;AAAA;AAAA,YAAuB,EAAC;AAAA,YAClE;AAAA,UACF;AAAA,UACA;AAAA,QACF;AAAA,QACA,EAAC,QAAQ,CAAC,KAAK,IAAI,GAAG,SAAS,CAAC,EAAE,EAAC;AAAA,MAAC,EAAE,CAAC;AAAA,IAC7C;AAEJ,IAAM,iCACF,CAAC,SAAyB,WAAmB,UAAkB,gBAAwB,UACtF,OAAmB,MAAmB,eAAwB;AAG7D,UAAI,gBAAgB;AACpB,UAAI,CAAC,MAAM;AACT,YAAI,MAAM,KAAK,WAAW,GAAG;AAC3B,0BAAgB,MAAM,QAAQ,CAAC,WAAW,gBAAgB,UAAU,QAAQ,CAAC;AAAA,QAC/E;AACA,eAAO,QAAQ;AAAA,UACX,2BAA2B,eAAeA,0BAAyB,IAAI;AAAA,UACvE,EAAC,QAAQ,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,EAAC;AAAA,QAAC,EAAE,CAAC;AAAA,MACjD,OAAO;AACL,YAAI,mBAAmB,GAAG;AACxB,gBAAM,IAAI,MAAM,mFAAmF;AAAA,QACrG,OAAO;AACL,0BACI,iBAAiB,SAAS,OAAO,MAAM,WAAW,gBAAgB,WAAW,UAAU,UAAW;AACtG,0BAAgB,cAAc,QAAQ,CAAC,WAAW,gBAAgB,UAAU,QAAQ,CAAC;AACrF,iBAAO,QAAQ;AAAA,YACX,2BAA2B,eAAeA,0BAAyB,IAAI;AAAA,YACvE,EAAC,QAAQ,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,EAAC;AAAA,UAAC,EAAE,CAAC;AAAA,QACjD;AAAA,MACF;AAAA,IACF;AAEG,IAAM,qBAAqB,CAAC,SAAyB,eAAqC;AAC/F,YAAM,SAASD,iBAAe,QAAQ,QAAQ,UAAU;AACxD,YAAM,QAAQ,QAAQ,OAAO,CAAC;AAC9B,YAAM,MAAM,SAAS,QAAQ,QAAQ,CAAC;AACtC,YAAM,QAAQ,SAAS,QAAQ,QAAQ,CAAC;AACxC,YAAM,OAAO,SAAS,QAAQ,QAAQ,CAAC;AACvC,YAAM,iBAAiB,SAAS,QAAQ,QAAQ,CAAC;AACjD,YAAM,uBAAuB,SAAS,QAAQ,QAAQ,CAAC;AACvD,YAAM,UAAU,SAAS,QAAQ,QAAQ,CAAC;AAC1C,YAAM,YAAY,SAAS,QAAQ,QAAQ,CAAC;AAC5C,UAAI,MAAM,KAAK,WAAW,GAAG;AAC3B,cAAM,IAAI,MAAM,+BAA+B;AAAA,MACjD;AAEA,UAAI,KAAK,KAAK,WAAW,GAAG;AAC1B,cAAM,IAAI,MAAM,8BAA8B;AAAA,MAChD;AAGA,YAAM,SAAS,OAAO,SAAS,IAAI,KAAK,WAAW,KAAK,MAAM,KAAK,WAAW;AAE9E,YAAM,IAAI;AAAA,QACN;AAAA,QAAS,OAAO;AAAA,QAAW,OAAO;AAAA,QAAU,OAAO;AAAA,QAAgB,OAAO;AAAA,QAAU;AAAA,QAAO;AAAA,QAAM;AAAA,MAAC;AAEtG,UAAI,QAAQ;AACV,eAAO;AAAA,UACH;AAAA,UAAS;AAAA,UAAG;AAAA,UAAK;AAAA,UAAO;AAAA,UAAgB;AAAA,UAAW;AAAA,UAAS;AAAA,UAAW;AAAA,UAAsB;AAAA,UAC7F;AAAA,QAAU;AAAA,MAChB;AACA,UAAI,CAAC,OAAO,CAAC,OAAO;AAClB,cAAM,IAAI,MAAM,gCAAgC;AAAA,MAClD;AACA,YAAM,IAAI;AAAA,QACN;AAAA,QAAS,OAAO;AAAA,QAAW,OAAO;AAAA,QAAU,OAAO;AAAA,QAAkB,OAAO;AAAA,QAAU;AAAA,QAAK;AAAA,QAC3F,OAAO;AAAA,MAAU;AAErB,YAAM,IAAI;AAAA,QACN;AAAA,QAAS,OAAO;AAAA,QAAW,OAAO;AAAA,QAAU,OAAO;AAAA,QAAkB,OAAO;AAAA,QAAW;AAAA,QAAO;AAAA,QAC9F,IAAI,OAAO;AAAA,MAAU;AAEzB;AAAA,QACI;AAAA,QAAS;AAAA,QAAG;AAAA,QAAG;AAAA,QAAG;AAAA,QAAgB;AAAA,QAAW;AAAA,QAAS;AAAA,QAAW;AAAA,QAAsB;AAAA,QAAQ;AAAA,MAAU;AAAA,IAC/G;AAAA;AAAA;;;ACrWA,IAiBME,kBAmBA,gBA0BA,eA2BA,YAuBA,YAuBA,eAeA,sBAiDA,+BA0BO;AAjOb;AAAA;AAAA;AAGA;AAEA;AAGA;AASA,IAAMA,mBAAiB,CAAC,WAAwC;AAC9D,UAAI,CAAC,UAAU,OAAO,SAAS,GAAG;AAChC,cAAM,IAAI,MAAM,gBAAgB;AAAA,MAClC;AACA,UAAI,OAAO,CAAC,EAAE,8BAA+B,OAAO,CAAC,EAAE,+BAA+B;AACpF,cAAM,IAAI,MAAM,sCAAsC;AAAA,MACxD;AAEA,UAAI,OAAO,UAAU,GAAG;AACtB,YAAI,YAAY,OAAO,CAAC,EAAE,KAAK,SAAS,MAAM,OAAO,CAAC,EAAE,KAAK,CAAC;AAC9D,YAAI,OAAO,WAAW,GAAG;AACvB,sBAAY,OAAO,CAAC,EAAE,KAAK,CAAC,IAAI,MAAM,OAAO,CAAC,EAAE,KAAK,CAAC;AAAA,QACxD;AACA,YAAI,CAAC,WAAW;AACd,gBAAM,IAAI,MAAM,6EAA6E;AAAA,QAC/F;AAAA,MACF;AAAA,IACF;AAEA,IAAM,iBAAiB,CAAC,QAAuB,WAAmB,eAA+B;AAC/F,UAAI,QAAQ;AACZ,eAAS,IAAI,YAAY,GAAG,KAAK,GAAG,EAAE,GAAG;AACvC,iBAAS;AAAA,sBACS,OAAO,WAAW,WAAW,CAAC,CAAC,OAAO,aAAa,iBAAiB,GAAG,UAAU,CAAC;AAAA;AAAA;AAAA;AAAA,2BAI7E,aAAa,oBAAoB,GAAG,SAAS,CAAC;AAAA;AAAA;AAAA,gCAGzC,aAAa,sBAAsB,GAAG,SAAS,CAAC;AAAA;AAAA,MAE9E;AAEA,aAAO;AAAA,oBACW,OAAO,KAAK,KAAK;AAAA;AAAA;AAAA;AAAA,cAIvB,KAAK;AAAA;AAAA;AAAA;AAAA,IAInB;AAEA,IAAM,gBAAgB,CAAC,QAAuB,WAAmB,eAA+B;AAC9F,UAAI,QAAQ;AACZ,eAAS,IAAI,YAAY,GAAG,KAAK,GAAG,EAAE,GAAG;AACvC,iBAAS;AAAA,0BACa,OAAO,WAAW,WAAW,CAAC,CAAC,OAAO,aAAa,iBAAiB,GAAG,UAAU,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,yCAKnE,aAAa,oBAAoB,GAAG,SAAS,CAAC;AAAA;AAAA,gCAEvD,aAAa,oBAAoB,GAAG,SAAS,CAAC;AAAA;AAAA;AAAA;AAAA,oCAI1C,aAAa,sBAAsB,GAAG,SAAS,CAAC;AAAA;AAAA,MAElF;AAEA,aAAO;AAAA;AAAA;AAAA,gBAGO,KAAK;AAAA;AAAA;AAAA,IAGrB;AAEA,IAAM,aAAa,CAAC,QAAuB,WAAmB,eAA+B;AAC3F,UAAI,QAAQ;AACZ,eAAS,IAAI,YAAY,GAAG,KAAK,GAAG,EAAE,GAAG;AACvC,iBAAS;AAAA,0BACa,OAAO,WAAW,WAAW,CAAC,CAAC,OAAO,aAAa,iBAAiB,GAAG,UAAU,CAAC;AAAA;AAAA;AAAA;AAAA,+BAI7E,aAAa,oBAAoB,GAAG,SAAS,CAAC;AAAA,4BACjD,aAAa,oBAAoB,GAAG,SAAS,CAAC;AAAA;AAAA,oCAEtC,aAAa,sBAAsB,GAAG,SAAS,CAAC;AAAA;AAAA,MAElF;AAEA,aAAO;AAAA;AAAA;AAAA,gBAGO,KAAK;AAAA;AAAA;AAAA,IAGrB;AAEA,IAAM,aAAa,CAAC,QAAuB,WAAmB,eAA+B;AAC3F,UAAI,QAAQ;AACZ,eAAS,IAAI,YAAY,GAAG,KAAK,GAAG,EAAE,GAAG;AACvC,iBAAS;AAAA,0BACa,OAAO,WAAW,WAAW,CAAC,CAAC,OAAO,aAAa,iBAAiB,GAAG,UAAU,CAAC;AAAA;AAAA,6BAE/E,aAAa,oBAAoB,GAAG,SAAS,CAAC;AAAA;AAAA,+BAE5C,aAAa,oBAAoB,GAAG,SAAS,CAAC;AAAA,6BAChD,aAAa,oBAAoB,GAAG,SAAS,CAAC;AAAA;AAAA,oCAEvC,aAAa,sBAAsB,GAAG,SAAS,CAAC;AAAA;AAAA,MAElF;AAEA,aAAO;AAAA;AAAA;AAAA,gBAGO,KAAK;AAAA;AAAA;AAAA,IAGrB;AAEA,IAAM,gBAAgB,CAAC,QAAuB,WAAmB,eAAsC;AACrG,cAAQ,WAAW,MAAM;AAAA,QACvB,KAAK;AACH,iBAAO,eAAe,QAAQ,WAAW,WAAW,KAAK,MAAM;AAAA,QACjE,KAAK;AACH,iBAAO,cAAc,QAAQ,WAAW,WAAW,KAAK,MAAM;AAAA,QAChE,KAAK;AACH,iBAAO,WAAW,QAAQ,WAAW,WAAW,KAAK,MAAM;AAAA,QAC7D,KAAK;AACH,iBAAO,WAAW,QAAQ,WAAW,WAAW,KAAK,MAAM;AAAA,QAC7D;AACE,gBAAM,IAAI,MAAM,cAAc;AAAA,MAClC;AAAA,IACF;AAEA,IAAM,uBAAuB,CAAC,QAA+B,eAA2C;AACtG,YAAM,cAAc,UAAU,SAAS,OAAO,CAAC,EAAE,KAAK,MAAM,GAAG,WAAW,IAAI;AAC9E,YAAM,YAAY,OAAO,CAAC,EAAE;AAC5B,YAAM,aAAa,UAAU,KAAK,WAAW;AAC7C,YAAM,kBACF,CAAC,EAAC,uBAAuB,MAAM,WAAU,GAAG,EAAC,qBAAsB,MAAM,WAAW,KAAI,CAAC;AAC7F,UAAI,WAAW,SAAS,GAAG;AACzB,wBAAgB,KAAK,EAAC,MAAM,OAAO,CAAC,EAAE,UAAU,MAAM,WAAW,MAAK,CAAC;AAAA,MACzE;AAEA,sBAAgB,KAAK,GAAG,2BAA2B,OAAO,CAAC,EAAE,MAAM,WAAW,CAAC;AAC/E,YAAM,oBAAwD,CAAC,MAAM;AAErE,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,SAAS,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,YAAY,MAAM;AAC9E,cAAM,QAAQ,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,UAAU,MAAM;AACrE,cAAM,WAAW,MAAM,KAAK;AAC5B,cAAM,aAAa,cAAc,QAAQ,UAAU,QAAQ,UAAU;AACrE,cAAM,WACF,CAAC,EAAC,MAAM,eAAe,MAAM,MAAK,GAAG,EAAC,MAAM,QAAQ,MAAM,OAAO,QAAQ,WAAW,KAAK,OAAM,CAAC;AACpG,YAAI,WAAW,SAAS,GAAG;AACzB,mBAAS,KAAK,EAAC,MAAM,kBAAkB,MAAM,SAAkC,CAAC;AAAA,QAClF;AAEA,eAAO;AAAA,cACG,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,OAAO,MAAM,CAAC;AAAA,cACvE,aAAa,UAAU,CAAC;AAAA,cACxB,aAAa,sCAAsC,sBAAsB,CAAC;AAAA;AAAA,4BAE5D,OAAO,gBAAgB,YAAY,CAAC;AAAA;AAAA,0BAEtC,QAAQ;AAAA,cACpB,UAAU;AAAA;AAAA;AAAA,MAGtB;AAEA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,GAAG,WAAW,IAAI,IAAI,kBAAiB;AAAA,QAC3D,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,UAC3D,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,UAAU,KAAK,WAAW,IAAI;AAAA;AAAA,UAAuB,EAAC;AAAA,UACnF;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEA,IAAM,gCAAgC,CAAC,QAA+B,eAA6C;AACjH,UAAI,OAAO,SAAS,GAAG;AACrB,cAAM,eAAe,OAAO,CAAC,EAAE,iBAAiB;AAChD,cAAM,QAAS,OAAO,UAAU,KAAK,OAAO,CAAC,EAAE,OAAQ,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAC,IAAI;AAExF,cAAM,YAAY,OAAO,CAAC,EAAE,KAAK;AACjC,cAAM,aAAa,IAAI,WAAW,IAAI,SAAS,EAAE,KAAK,CAAC;AACvD,YAAI,OAAO,UAAU,GAAG;AACtB,gBAAM,OAAO,OAAO,CAAC,EAAE,iBAAiB;AACxC,mBAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,uBAAW,OAAO,KAAK,CAAC,CAAC,CAAC,IAAI,OAAO,aAAa,CAAC,CAAC;AACpD,uBAAW,OAAO,KAAK,CAAC,CAAC,IAAI,SAAS,IAAI,OAAO,aAAa,IAAI,KAAK,MAAM,CAAC;AAAA,UAChF;AAAA,QACF,OAAO;AACL,uBAAa,QAAQ,CAAC,GAAG,MAAM,WAAW,OAAO,CAAC,CAAC,IAAK,OAAO,CAAC,CAAE;AAAA,QACpE;AAEA,cAAM,OAAiB,CAAC;AACxB,mBAAW,QAAQ,OAAK,KAAK,KAAK,CAAC,CAAC;AAEpC,eAAO,EAAC,MAAM,WAAW,MAAM,OAAO,KAAI;AAAA,MAC5C,OAAO;AACL,eAAO;AAAA,MACT;AAAA,IACF;AAEO,IAAM,MAAM,CAAC,SAAyB,eAAoC;AAC/E,MAAAA,iBAAe,QAAQ,MAAM;AAC7B,YAAM,oBAAoB,8BAA8B,QAAQ,QAAQ,UAAU;AAClF,cAAQ,QAAQ,qBAAqB,QAAQ,QAAQ,iBAAiB,GAAG,EAAC,QAAQ,CAAC,CAAC,EAAC,CAAC;AAAA,IACxF;AAAA;AAAA;;;ACrOA,IAmBMC,kBAMA,yCA4BA,sBA2DA,qBAsJA,+BAGA,0CAGA,sCAGA,2BAaA,8BAiCO,4BAYA,aAKP,sBAWO,kCAKA,mBAUP,0BA6BO,SAKA,wBAgBA,8BAKA;AA/Zb;AAAA;AAAA;AAGA;AAEA;AAEA;AAIA;AAQA,IAAMA,mBAAiB,CAAC,WAAwC;AAC9D,UAAIC,KAAI,OAAO,yBAAyB,CAAC,UAAU,OAAO,WAAW,IAAI;AACvE,cAAM,IAAI,MAAM,4BAA4B;AAAA,MAC9C;AAAA,IACF;AAEA,IAAM,0CAA0C,CAC5C,OAAmB,YAA2B,qBAAyD;AACzG,YAAM,iBAAiB,WAAW,WAAW;AAC7C,YAAM,2BAA2B,MAAM,KAAK,MAAM;AAClD,UAAI,gBAAgB;AAClB,iCAAyB,OAAO,GAAG,GAAG,yBAAyB,IAAI,CAAE;AAAA,MACvE;AACA,YAAM,eAAe,OAAO,eAAe,KAAK,YAAY,WAAW;AACvE,YAAM,cAAc,WAAW,YAAY,MAAM;AACjD,YAAM,UAAU,WAAW,QAAQ,MAAM;AACzC,YAAM,YAAsB,eAAgB,WAAiC,UAAU,MAAM,IAAI,CAAC;AAClG,YAAM,OAAO,WAAW,KAAK,MAAM;AACnC,mBAAa,qBAAqB,kBAAkB,0BAA0B,aAAa,SAAS,WAAW,IAAI;AAEnH,YAAM,4BAA4B,aAAa;AAAA,QAC3C;AAAA,QAAkB;AAAA,QAA0B;AAAA,QAAS;AAAA,QAAW;AAAA,QAAa;AAAA,QAAM,WAAW;AAAA,MAAO;AAEzG,YAAM,gBAAgB,OAAO,OAAO,CAAC,GAAG,UAAU;AAClD,UAAI,cAAc;AAChB,eAAO,OAAO,eAAe,EAAC,aAAa,SAAS,MAAM,WAAW,UAAU,WAAW,SAAQ,CAAC;AAAA,MACrG,OAAO;AACL,eAAO,OAAO,eAAe,EAAC,aAAa,SAAS,MAAM,UAAU,WAAW,SAAQ,CAAC;AAAA,MAC1F;AACA,YAAM,2BAA2B,0BAA0B,MAAM;AACjE,+BAAyB,KAAK,yBAAyB,OAAO,GAAG,CAAC,EAAE,CAAC,CAAC;AACtE,aAAO,CAAC,eAAe,iBAAiB,2BAA2B,yBAAyB;AAAA,IAC9F;AAEA,IAAM,uBAAuB,CACzB,aACA,eAAgG;AAClG,YAAM,iBAAiB,WAAW,WAAW;AAC7C,YAAM,aAAa,UAAU,KAAK,WAAW;AAC7C,YAAM,aAAa,UAAU,KAAK,WAAW,WAAW;AACxD,YAAM,kBACF,CAAC,EAAC,uBAAuB,MAAM,WAAU,GAAG,EAAC,uBAAuB,MAAM,WAAU,CAAC;AACzF,YAAM,WAA8B,CAAC,EAAC,MAAM,cAAc,MAAM,MAAK,GAAG,EAAC,MAAM,cAAc,MAAM,MAAK,CAAC;AACzG,UAAI,WAAW,YAAY,UAAU,GAAG;AACtC,cAAM,KAAK,WAAW,YAAY,WAAW,YAAY,SAAS,CAAC;AACnE,cAAM,KAAK,WAAW,QAAQ,WAAW,QAAQ,SAAS,CAAC;AAC3D,cAAM,UAAU,WAAW,KAAK,WAAW,KAAK,SAAS,IAAI,CAAC;AAC9D,cAAM,QAAQ,WAAW,KAAK,WAAW,KAAK,SAAS,CAAC;AACxD,cAAM,oBAAoB,CAAC,EAAE,UAAU;AACvC,wBAAgB;AAAA,UACZ,EAAC,uBAAuB,MAAM,GAAE;AAAA,UAChC,EAAC,uBAAuB,MAAM,GAAE;AAAA,UAChC,EAAC,uBAAuB,MAAM,QAAO;AAAA,UACrC,EAAC,uBAAuB,MAAM,MAAK;AAAA,QACvC;AACA,iBAAS;AAAA,UACL,EAAC,MAAM,MAAM,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,MAAM,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,WAAW,MAAM,MAAK;AAAA,UACnF,EAAC,MAAM,SAAS,MAAM,MAAK;AAAA,QAAC;AAEhC,YAAI,oBAAoB;AACxB,YAAI,WAAW,YAAY,WAAW,GAAG;AACvC,gBAAM,KAAK,WAAW,YAAY,WAAW,YAAY,SAAS,CAAC;AACnE,gBAAM,KAAK,WAAW,QAAQ,WAAW,QAAQ,SAAS,CAAC;AAC3D,gBAAM,UAAU,WAAW,KAAK,WAAW,KAAK,SAAS,IAAI,CAAC;AAC9D,gBAAM,QAAQ,WAAW,KAAK,WAAW,KAAK,SAAS,CAAC;AACxD,8BAAoB,CAAC,EAAE,UAAU;AACjC,0BAAgB;AAAA,YACZ,EAAC,uBAAuB,MAAM,GAAE;AAAA,YAAG,EAAC,uBAAuB,MAAM,GAAE;AAAA,YAAG,EAAC,uBAAuB,MAAM,QAAO;AAAA,YAC3G,EAAC,uBAAuB,MAAM,MAAK;AAAA,UAAC;AAExC,mBAAS;AAAA,YACL,EAAC,MAAM,MAAM,MAAM,MAAK;AAAA,YAAG,EAAC,MAAM,MAAM,MAAM,MAAK;AAAA,YAAG,EAAC,MAAM,WAAW,MAAM,MAAK;AAAA,YACnF,EAAC,MAAM,SAAS,MAAM,MAAK;AAAA,UAAC;AAAA,QAClC;AACA,eAAO,CAAC,iBAAiB,UAAU,MAAM,mBAAmB,iBAAiB;AAAA,MAC/E,OAAO;AACL,YAAI,gBAAgB;AAClB,gBAAM,IAAI,MAAM,uEAAuE;AAAA,QACzF;AACA,cAAM,gBAAgB,UAAU,eAAe,WAAW,WAAW;AACrE,wBAAgB;AAAA,UACZ,EAAC,uBAAuB,MAAM,cAAa;AAAA,UAAG,EAAC,uBAAuB,MAAM,WAAW,KAAI;AAAA,UAC3F,EAAC,uBAAuB,MAAM,WAAW,QAAO;AAAA,QAAC;AACrD,iBAAS;AAAA,UACL,EAAC,MAAM,iBAAiB,MAAM,OAAO,QAAQ,cAAc,OAAM;AAAA,UACjE,EAAC,MAAM,QAAQ,MAAM,OAAO,QAAQ,WAAW,KAAK,OAAM;AAAA,UAC1D,EAAC,MAAM,WAAW,MAAM,OAAO,QAAQ,WAAW,QAAQ,OAAM;AAAA,QAAC;AAErE,cAAM,UAAU,WAAW,KAAK,OAAO,CAAC,KAAK,QAAQ,MAAM,GAAG;AAC9D,eAAO,CAAC,iBAAiB,UAAU,CAAC,CAAC,SAAS,OAAO,KAAK;AAAA,MAC5D;AAAA,IACF;AAEA,IAAM,sBAAsB,CACxB,cAA4B,GAAkB,MAAc,iBAAyB,YACrF,KAAa,KAAa,OAAe,UAA6B,SAAkB,mBACxF,sBAAuC;AACzC,YAAM,iBAAiB,WAAW,WAAW;AAC7C,YAAM,WAAW,EAAE,KAAK;AACxB,YAAM,SAAS,eAAe,UAAU,EAAE,KAAK,QAAQ,eAAe;AAEtE,UAAI,WAAW,YAAY,UAAU,GAAG;AACtC,YAAI,QAAQ;AACZ,YAAI,QAAQ;AACZ,YAAI,WAAW;AACf,cAAM,UAAU,QAAQ,iBAAiB,IAAI;AAC7C,YAAI,mBAAmB;AACrB,kBAAQ;AAAA;AAAA,6BAEe,OAAO,eAAe,OAAO;AAAA,iCACzB,OAAO,qBAAqB,OAAO;AAAA,4CACxB,OAAO;AAAA;AAAA;AAAA;AAAA,kCAIjB,EAAE,gBAAgB,UAAU,CAAC;AAAA,oBAC3C,GAAG;AAAA;AAAA,QAEnB,OAAO;AACL,kBAAQ;AAAA;AAAA,6BAEe,OAAO,eAAe,OAAO;AAAA,kCACxB,EAAE,gBAAgB,UAAU,CAAC;AAAA,oBAC3C,GAAG;AAAA;AAAA,QAEnB;AAEA,YAAI,WAAW,YAAY,WAAW,GAAG;AACvC,gBAAM,UAAU,QAAQ,iBAAiB,IAAI;AAC7C,cAAI,mBAAmB;AACrB,oBAAQ;AAAA;AAAA,6BAEa,OAAO,eAAe,OAAO;AAAA,iCACzB,OAAO,qBAAqB,OAAO,yBAAyB,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA,UAK9F,OAAO;AACL,oBAAQ;AAAA;AAAA,6BAEa,OAAO,eAAe,OAAO;AAAA;AAAA,UAEpD;AACA,qBAAW;AAAA;AAAA;AAAA,QAGb;AAEA,cAAM,cAAc;AAAA,cACV,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,GAAG,MAAM,CAAC;AAAA;AAAA,cAEnE,aAAa,UAAU,CAAC;AAAA,gBACtB,aAAa,sCAAsC,qBAAqB,CAAC;AAAA;AAAA,8BAE3D,OAAO,gBAAgB,YAAY,CAAC;AAAA,+BACnC,OAAO,gBAAgB,YAAY,CAAC;AAAA;AAAA,4BAEvC,QAAQ,IAAI,KAAK;AAAA;AAAA,gBAE7B,KAAK;AAAA,gBACL,KAAK;AAAA,gBACL,QAAQ;AAAA,gBACR,GAAG;AAAA;AAAA;AAAA;AAIf,eAAO;AAAA,MACT,OAAO;AACL,YAAI,gBAAgB;AAClB,gBAAM,IAAI,MAAM,uEAAuE;AAAA,QACzF;AACA,cAAM,cAAc,WAAW,YAAY;AAC3C,cAAM,WAAW,WAAW,KAAK;AACjC,YAAI,UAAU;AACd,YAAI,SAAS;AACX,oBAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gCAQgB,EAAE,gBAAgB,UAAU,CAAC;AAAA,kBAC3C,GAAG;AAAA;AAAA,QAEjB,OAAO;AACL,oBAAU;AAAA;AAAA,8BAEc,EAAE,gBAAgB,UAAU,CAAC;AAAA,gBAC3C,GAAG;AAAA;AAAA,QAEf;AACA,cAAM,cAAc;AAAA,cACV,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,GAAG,MAAM,CAAC;AAAA;AAAA,cAEnE,aAAa,UAAU,CAAC;AAAA,gBACtB,aAAa,sCAAsC,qBAAqB,CAAC;AAAA,8BAC3D,OAAO,gBAAgB,YAAY,CAAC;AAAA,+BACnC,OAAO,gBAAgB,YAAY,CAAC;AAAA;AAAA,wCAE3B,WAAW;AAAA;AAAA,4BAEvB,QAAQ,IAAI,KAAK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uCAMN,cAAc,CAAC;AAAA,0CACZ,aAAa,0BAA0B,KAAK,WAAW,CAAC;AAAA,2CACvD,aAAa,0BAA0B,KAAK,WAAW,CAAC;AAAA;AAAA,0BAEzE,cAAc,CAAC;AAAA;AAAA;AAAA,+BAGV,OAAO,WAAW,UAAU,IAAI;AAAA,+CAEvD,aAAa,oBAAoB,OAAO,OAAO,WAAW,KAAK,WAAW,CAAC;AAAA,oCAC/C,OAAO,WAAW,QAAQ,aAAa,iBAAiB,UAAU,QAAQ,CAAC;AAAA,oBAC3F,OAAO;AAAA;AAAA,gBAEX,GAAG;AAAA;AAAA;AAAA;AAIf,eAAO;AAAA,MACT;AAAA,IACF;AAcA,IAAM,gCAAgC,CAAC,eAClC,GAAG,WAAW,MAAM,IAAI,WAAW,QAAQ,IAAI,WAAW,OAAO,IAAI,WAAW,YAAY,MAAM;AAEvG,IAAM,2CAA2C,CAAC,eAC7C,GAAG,8BAA8B,UAAU,CAAC,IAAI,WAAW,eAAe;AAE/E,IAAM,uCAAuC,CAAC,eACzC,GAAG,8BAA8B,UAAU,CAAC,IAAI,WAAW,YAAY,IAAI,WAAW,SAAS;AAEpG,IAAM,4BAA4B,CAAC,gBAA+D;AAAA,MAChG,QAAQ,WAAW;AAAA,MACnB,SAAS,CAAC,UAAU,SAAS,cAAc,YAAY,EAAE,WAAW,QAAkB;AAAA,MACtF,UAAU,WAAW;AAAA,MACrB,aAAa,WAAW;AAAA,MACxB,SAAS,WAAW;AAAA,MACpB,MAAM,WAAW;AAAA,IACnB;AAMA,IAAM,+BACF,CAAC,MAAc,OAAmB,kBAA2B,eAAmD;AAC9G,YAAM,CAAC,oBAAoB,WAAW,IAClC,wCAAwC,OAAO,YAAY,gBAAgB;AAC/E,YAAM,IAAI,cAAc,KAAK,MAAM,UAAU,MAAM,KAAK,MAAM;AAC9D,YAAM,WAAW,EAAE,KAAK;AAExB,YAAM,MAAM;AACZ,UAAI,MAAM;AACV,UAAI,mBAAmB,iBAAiB;AACtC,eAAO,YAAY,QAAQ;AAAA,MAC7B,OAAO;AACL,eAAO,YAAY,QAAQ;AAAA,MAC7B;AACA,YAAM,CAAC,iBAAiB,UAAU,SAAS,mBAAmB,iBAAiB,IAC3E,qBAAqB,aAAa,kBAAkB;AACxD,sBAAgB,KAAK,GAAG,2BAA2B,MAAM,MAAM,WAAW,CAAC;AAC3E,YAAM,oBAAwD,CAAC,MAAM;AACrE,aAAO;AAAA,QACL;AAAA,QACA,aACI,EAAC,MAAM,GAAG,WAAW,QAAQ,IAAI,OAAO,IAAI,iBAAiB,IAAI,iBAAiB,IAAI,kBAAiB;AAAA,QAC3G,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,MAAM,SAAQ,CAAC;AAAA,UACvD,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,UAAU,KAAK,WAAW,IAAI;AAAA;AAAA,UAAuB,EAAC;AAAA,UACnF;AAAA,QACF;AAAA,QACA,iBAAiB,kBAAgB;AAAA,UAC7B;AAAA,UAAc;AAAA,UAAG,MAAM,KAAK;AAAA,UAAQ,YAAY;AAAA,UAAQ;AAAA,UAAoB;AAAA,UAAK;AAAA,UAAK;AAAA,UAAK;AAAA,UAC3F;AAAA,UAAS;AAAA,UAAmB;AAAA,QAAiB;AAAA,MACnD;AAAA,IACF;AAEG,IAAM,6BAA6B,CAAC,eAA+D;AACxG,YAAM,kBAAmB,WAAW,sBAAiC,IAAI,QAAQ;AAEjF,YAAM,OAAO,0BAA0B,UAAU;AAEjD,UAAI,KAAK,aAAa,GAAG;AACvB,cAAM,IAAI,MAAM,wEAAwE;AAAA,MAC1F;AACA,YAAM,wBAAwB,EAAC,iBAAiB,GAAG,MAAM,UAAU,GAAE;AACrE,aAAO,EAAC,GAAG,uBAAuB,UAAU,yCAAyC,qBAAqB,EAAC;AAAA,IAC7G;AAEO,IAAM,cAAc,CAAC,SAAyB,eAA4C;AAC/F,MAAAD,iBAAe,QAAQ,MAAM;AAC7B,cAAQ,QAAQ,6BAA6B,eAAe,QAAQ,OAAO,CAAC,GAAG,OAAO,UAAU,CAAC;AAAA,IACnG;AAEA,IAAM,uBAAuB;AAAA,MAC3B,SAAS;AAAA,MACT,UAAU;AAAA,MACV,iBAAiB;AAAA,MACjB,aAAa,CAAC;AAAA,MACd,SAAS,CAAC;AAAA,MACV,MAAM,CAAC;AAAA,MACP,cAAc;AAAA,MACd,WAAW,CAAC;AAAA,IACd;AAEO,IAAM,mCAAmC,CAAC,eAA+D;AAC9G,YAAM,SAAS,WAAW;AAC1B,aAAO,EAAC,QAAQ,GAAG,sBAAsB,UAAU,OAAM;AAAA,IAC3D;AAEO,IAAM,oBAAoB,CAAC,SAAyB,eAA4C;AACrG,MAAAA,iBAAe,QAAQ,MAAM;AAC7B,cAAQ,QAAQ,6BAA6B,qBAAqB,QAAQ,OAAO,CAAC,GAAG,MAAM,UAAU,CAAC;AAAA,IACxG;AAOA,IAAM,2BACF,CAAC,MAAc,OAAmB,kBAA2B,eAA+C;AAC1G,YAAM,CAAC,oBAAoB,WAAW,IAClC,wCAAwC,OAAO,YAAY,gBAAgB;AAC/E,YAAM,MAAM;AAAA;AAAA;AAGZ,YAAM,MAAM;AACZ,YAAM,IAAI,cAAc,KAAK,MAAM,UAAU,MAAM,KAAK,MAAM;AAC9D,YAAM,oBAAwD,CAAC,MAAM;AACrE,YAAM,CAAC,iBAAiB,UAAU,SAAS,mBAAmB,iBAAiB,IAC3E,qBAAqB,aAAa,kBAAkB;AACxD,sBAAgB,KAAK,GAAG,2BAA2B,MAAM,MAAM,WAAW,CAAC;AAC3E,aAAO;AAAA,QACL;AAAA,QACA,aACI,EAAC,MAAM,GAAG,WAAW,QAAQ,IAAI,OAAO,IAAI,iBAAiB,IAAI,iBAAiB,IAAI,kBAAiB;AAAA,QAC3G,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,MAAM,SAAQ,CAAC;AAAA,UACvD,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,UAAU,KAAK,WAAW,IAAI;AAAA;AAAA,UAAuB,EAAC;AAAA,UACnF;AAAA,QACF;AAAA,QACA,iBAAiB,kBAAgB;AAAA,UAC7B;AAAA,UAAc;AAAA,UAAG,MAAM,KAAK;AAAA,UAAQ,YAAY;AAAA,UAAQ;AAAA,UAAoB;AAAA,UAAK;AAAA,UAChF,MAAM,gCAAiC,SAAS;AAAA,UAAM;AAAA,UAAU;AAAA,UAAS;AAAA,UAC1E;AAAA,QAAiB;AAAA,MACvB;AAAA,IACF;AAEG,IAAM,UAAU,CAAC,SAAyB,eAAwC;AACvF,MAAAA,iBAAe,QAAQ,MAAM;AAC7B,cAAQ,QAAQ,yBAAyB,WAAW,QAAQ,OAAO,CAAC,GAAG,OAAO,UAAU,CAAC;AAAA,IAC3F;AAEO,IAAM,yBAAyB,CAAC,eAA2D;AAChG,YAAM,eAAe,WAAW;AAChC,YAAM,YAAY,WAAW;AAE7B,YAAM,OAAO,0BAA0B,UAAU;AAEjD,UAAI,iBAAiB,GAAG;AACtB,cAAM,IAAI,MAAM,6DAA6D;AAAA,MAC/E;AACA,UAAI,KAAK,aAAa,GAAG;AACvB,cAAM,IAAI,MAAM,oEAAoE;AAAA,MACtF;AACA,YAAM,oBAAoB,EAAC,cAAc,WAAW,GAAG,MAAM,UAAU,GAAE;AACzE,aAAO,EAAC,GAAG,mBAAmB,UAAU,qCAAqC,iBAAiB,EAAC;AAAA,IACjG;AAEO,IAAM,+BAA+B,CAAC,eAA2D;AACtG,YAAM,SAAS,WAAW;AAC1B,aAAO,EAAC,QAAQ,GAAG,sBAAsB,UAAU,OAAM;AAAA,IAC3D;AAEO,IAAM,gBAAgB,CAAC,SAAyB,eAAwC;AAC7F,MAAAA,iBAAe,QAAQ,MAAM;AAC7B,cAAQ,QAAQ,yBAAyB,iBAAiB,QAAQ,OAAO,CAAC,GAAG,MAAM,UAAU,CAAC;AAAA,IAChG;AAAA;AAAA;;;AClaA,IAUM,uBAUA,wBAoCO;AAxDb;AAAA;AAAA;AAGA;AAEA;AAGA;AAEA,IAAM,wBAAwB,CAAC,OAAe,OAAe,UAAwB;AACnF,YAAM,iBAAiB,UAAU;AACjC,YAAM,8BAA8B,QAAQ,SAAS,QAAQ;AAC7D,YAAM,8BAA8B,QAAQ,SAAS,QAAQ;AAE7D,UAAI,kBAAkB,+BAA+B,6BAA6B;AAChF,cAAM,IAAI,MAAM,2CAA4C;AAAA,MAC9D;AAAA,IACF;AAEA,IAAM,yBAAyB,CAAC,OAAe,OAAe,OAAe,aAAoC;AAC/G,YAAM,cAAc,KAAK,IAAI,KAAK,MAAM,QAAQ,SAAS,KAAK,CAAC;AAC/D,YAAM,cAAwB,CAAC,WAAW;AAC1C,YAAM,aAAa;AACnB,YAAM,kBAAoC;AAAA,QACxC,EAAC,uBAAuB,MAAM,WAAU;AAAA,QAAG,EAAC,MAAM,UAAU,MAAM,MAAK;AAAA,QAAG,EAAC,MAAM,UAAU,MAAM,MAAK;AAAA,QACtG,GAAG,2BAA2B,WAAW;AAAA,MAC3C;AAEA,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,SAAS,eAAe,UAAU,UAAU,YAAY,MAAM;AACpE,cAAM,WAAW,OAAO,KAAK;AAC7B,cAAM,WAA8B;AAAA,UAClC,EAAC,MAAM,cAAc,MAAM,MAAK;AAAA,UAAG,EAAC,MAAM,SAAS,MAAM,SAAkC;AAAA,UAC3F,EAAC,MAAM,SAAS,MAAM,SAAkC;AAAA,QAC1D;AACA,eAAO;AAAA,UACD,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,MAAM,CAAC;AAAA,UAChE,aAAa,UAAU,CAAC;AAAA,UACxB,aAAa,sCAAsC,qBAAqB,CAAC;AAAA,gDACnC,QAAQ;AAAA;AAAA,MAEtD;AAEA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,GAAG,QAAQ,GAAE;AAAA,QACjC;AAAA,QACA,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,SAAQ,CAAC;AAAA,UACvC,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa;AAAA;AAAA,UAAuB,EAAC;AAAA,UAClE;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEO,IAAM,QAAQ,CAAC,YAAkC;AACtD,UAAI,QAAQ;AACZ,UAAI,QAAQ;AACZ,UAAI,QAAQ;AACZ,UAAI,QAAQ,OAAO,CAAC,EAAE,4BAA6B;AACjD,gBAAQ,QAAQ,OAAO,CAAC,EAAE,cAAc,EAAE,CAAC;AAC3C,gBAAQ,QAAQ,OAAO,CAAC,EAAE,cAAc,EAAE,CAAC;AAC3C,gBAAQ,QAAQ,OAAO,CAAC,EAAE,cAAc,EAAE,CAAC;AAAA,MAC7C,WAAW,QAAQ,OAAO,CAAC,EAAE,4BAA6B;AACxD,gBAAQ,QAAQ,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAC;AAC7C,gBAAQ,QAAQ,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAC;AAC7C,gBAAQ,QAAQ,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAC;AAAA,MAC/C;AACA,UAAIE,KAAI,OAAO,sBAAsB;AACnC,8BAAsB,OAAO,OAAO,KAAK;AAAA,MAC3C;AAEA,cAAQ,QAAQ,uBAAuB,OAAO,OAAO,OAAO,QAAQ,OAAO,CAAC,EAAE,QAAQ,GAAG,EAAC,QAAQ,CAAC,EAAC,CAAC;AAAA,IACvG;AAAA;AAAA;;;AC1EA,IAiCM,gBAuBA,cASAC,kBA6CA,4CAkDA,6BAkCA,WAaA,iBAwBA,mBAyBA,2CAuBA,wCAkCA,mBAWA,2BAQA,uBAsDA,sBA6EA,wBAwEA,yBAoHA,qCAOO,QAiBA;AAnqBb;AAAA;AAAA;AAIA;AAEA;AACA;AAGA;AAuBA,IAAM,iBAAiB,CAAC,QAAkB,eAAuC;AAC/E,aAAO,MAAM,CAAC,UAAU,QAAQ,MAAM,MAAM;AAClB,cAAM,IAAI,MAAM,oDAAoD;AAAA,MACtE,EAAE;AAE1B,UAAI,OAAO,SAAS,GAAG;AACrB,YAAI,WAAW,SAAS,UAAU;AAChC,cAAI,EAAE,OAAO,WAAW,KAAK,OAAO,WAAW,KAAM,OAAO,WAAW,KAAK,OAAO,CAAC,MAAM,KAAK,OAAO,CAAC,MAAM,KACtG,OAAO,WAAW,KAAK,OAAO,CAAC,MAAM,KAAK,OAAO,CAAC,MAAM,KACxD,OAAO,WAAW,KAAK,OAAO,CAAC,MAAM,KAAK,OAAO,CAAC,MAAM,IAAK;AAClE,kBAAM,IAAI;AAAA,cACN;AAAA;AAAA,YACwF;AAAA,UAC9F;AAAA,QACF,WAAW,WAAW,SAAS,SAAS;AACtC,cAAI,EAAE,OAAO,WAAW,KAAM,OAAO,WAAW,KAAK,OAAO,CAAC,MAAM,KAAK,OAAO,CAAC,MAAM,KAC/E,OAAO,WAAW,KAAK,OAAO,CAAC,MAAM,KAAK,OAAO,CAAC,MAAM,IAAK;AAClE,kBAAM,IAAI,MAAM,+DAA+D;AAAA,UACjF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,IAAM,eAAe,CAAC,QAA2B,MAAyB,SAA2B;AACnG,WAAK,MAAM,CAAC,UAAU,SAAS,KAAK,QAAQ,SAAS,MAAM;AACnC,cAAM,IAAI,MAAM,qEAAqE;AAAA,MACvF,EAAE;AACxB,YAAM,YAAY,IAAI,MAAM,IAAI,EAAE,KAAK,CAAG;AAC1C,WAAK,QAAQ,CAAC,OAAO,UAAU,UAAU,KAAK,IAAI,OAAO,KAAK,CAAC;AAC/D,aAAO;AAAA,IACT;AAEA,IAAMA,mBACF,CAAC,QAA+B,YAA8B,cAAsB,QACnF,OAAiB,QAAwB;AACxC,YAAM,CAAC,eAAe,kBAAkB,eAAe,IAClD,eAAe,KAAM,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,IAAK,OAAO,SAAS,IAAK,IAAI,IAAI,EAAE;AAC3E,YAAM,OAAO,OAAO,CAAC,EAAE,KAAK;AAC5B,UAAI,gBAAgB,KAAK,OAAO,SAAS,iBAAiB,OAAO,aAAa,EAAE,KAAK,SAAS,GAAG;AAC/F,eAAO,aAAa,EAAE,gBAAgB,EAAE,QAAQ,CAAC,UAAU,IAAI,KAAK,KAAK,CAAC;AAAA,MAC5E,WAAW,WAAW,4BAA4B,sBAAsB;AACtE,cAAM,IAAI,MAAM,2FAA2F;AAAA,MAC7G;AAEA,UAAI,mBAAmB,KAAK,OAAO,SAAS,oBAAoB,OAAO,gBAAgB,EAAE,KAAK,SAAS,GAAG;AACxG,eAAO,gBAAgB,EAAE,gBAAgB,EAAE,QAAQ,CAAC,UAAU,OAAO,KAAK,KAAK,CAAC;AAChF,YAAI,OAAO,WAAW,MACjB,OAAO,WAAW,SAAS,gBAAgB,MAAM,OAAO,WAAW,WAAW,KAAK,UAAU;AAChG,gBAAM,IAAI;AAAA,YACN;AAAA,UAA6F;AAAA,QACnG;AACA,uBAAe,QAAQ,UAAU;AACjC,YAAI,WAAW,KAAK,SAAS,GAAG;AAC9B,uBAAa,QAAQ,WAAW,MAAM,IAAI,EAAE,QAAQ,CAAC,OAAO,UAAU,OAAO,KAAK,IAAI,KAAK;AAAA,QAC7F;AAAA,MACF;AACA,UAAI,kBAAkB,KAAK,OAAO,SAAS,iBAAiB;AAC1D,eAAO,eAAe,EAAE,iBAAiB,EAAE,QAAQ,CAAC,UAAU,MAAM,KAAK,OAAO,KAAK,CAAC,CAAC;AACvF,YAAI,MAAM,WAAW,QAAS,gBAAgB,MAAM,MAAM,WAAW,WAAW,KAAK,QAAS;AAC5F,gBAAM,IAAI,MAAM,4FAA4F;AAAA,QAC9G;AAAA,MACF;AAEA,UAAI,WAAW,KAAK,SAAS,GAAG;AAC9B,YAAI,OAAO,WAAW,WAAW,KAAK,QAAQ;AAC5C,gBAAM,IAAI,MAAM,0FAA0F;AAAA,QAC5G;AACA,YAAI,MAAM,WAAW,WAAW,KAAK,QAAQ;AAC3C,gBAAM,IAAI;AAAA,YACN;AAAA,UAA8F;AAAA,QACpG;AAAA,MACF;AACA,UAAI,OAAO,WAAW,eAAe,OAAO,UAAU,eAAe,OAAO,SAAS,KAAK,MAAM,SAAS,MAAM;AAC7G,cAAM,IAAI,MAAM,yDAAyD;AAAA,MAC3E;AAAA,IACF;AAEJ,IAAM,6CACF,CAAC,wBAAiD,UAC9C;AAAA,2DACmD,KAAK,SAC3D,MAAM;AACD,cAAQ,wBAAwB;AAAA,QAC9B,KAAK;AACH,iBAAO,UAAU,KAAK,gBAAgB,KAAK;AAAA,QAC7C,KAAK;AACH,iBAAO;AAAA,8BACS,KAAK,uBAAuB,KAAK;AAAA;AAAA;AAAA;AAAA,QAInD,KAAK;AACH,iBAAO,WAAW,KAAK,uBAAuB,KAAK;AAAA,QACrD,KAAK;AACH,iBAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kCAMa,KAAK;AAAA;AAAA,0BAEb,KAAK,6DAA6D,KAAK;AAAA;AAAA;AAAA,QAGrF,KAAK;AACH,iBAAO;AAAA,6BACQ,KAAK,gBAAgB,KAAK;AAAA,2BAC5B,KAAK,gBAAgB,KAAK,yBAAyB,KAAK;AAAA,0BACzD,KAAK;AAAA;AAAA,mCAEI,KAAK,yBAAyB,KAAK;AAAA;AAAA,QAE1D,KAAK;AACH,iBAAO,uBAAuB,KAAK,YAAY,KAAK;AAAA,uCAC3B,KAAK;AAAA,mCACT,KAAK;AAAA;AAAA,sCAEF,KAAK,uBAAuB,KAAK;AAAA,QAC3D,KAAK;AACH,iBAAO,YAAY,KAAK,uBAAuB,KAAK;AAAA,QACtD;AACE,gBAAM,IAAI,MAAM,6BAA6B,sBAAsB,mBAAmB;AAAA,MAC1F;AAAA,IACF,GAAG,IACP;AAEJ,IAAM,8BAA8B,CAAC,aAA0B,cAAsB,UACjF,6CAA6C,KAAK,4BAA4B,KAAK,QAAQ,MAAM;AAC/F,cAAQ,aAAa;AAAA,QACnB,KAAK;AACH,iBAAO;AAAA,QAKT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QACT,KAAK;AACH,iBAAO;AAAA,QAKT,KAAK;AAAA,QACL;AACE,cAAI,eAAe,IAAI;AACrB,mBAAO;AAAA,UAMT;AACA,gBAAM,IAAI,MAAM,gBAAgB,WAAW,mBAAmB;AAAA,MAClE;AAAA,IACF,GAAG,IACH;AAEJ,IAAM,YAAY,CAAC,KAAwB,MAAyB,SAA2B;AAC7F,YAAM,SAAS,IAAI,MAAM,IAAI,EAAE,KAAK,CAAC,EAAE,OAAO,IAAI,MAAM,IAAI,EAAE,KAAK,CAAC,CAAC;AACrE,YAAM,WAAW,IAAI,WAAW,IAAI,SAAS,IAAI,MAAM;AACvD,UAAI,KAAK,SAAS,GAAG;AACnB,aAAK,QAAQ,CAAC,GAAG,MAAM;AACrB,iBAAO,CAAC,IAAI,SAAS,CAAC;AACtB,iBAAO,IAAI,IAAI,IAAI,SAAS,KAAK,SAAS,CAAC;AAAA,QAC7C,CAAC;AACD,eAAO;AAAA,MACT;AACA,aAAO;AAAA,IACT;AAEA,IAAM,kBACF,CAAC,YAA+B,QAA2B,OAA0B,SACrE;AACV,UAAI,cAAwB,CAAC;AAC7B,UAAI,MAAM,SAAS,GAAG;AACpB,YAAI,KAAK,SAAS,GAAG;AACnB,qBAAW,QAAQ,CAAC,MAAM,YAAY,KAAK,CAAC,CAAC;AAC7C,cAAI,KAAK,IAAI,GAAG,IAAI,IAAI,WAAW,QAAQ;AACzC,kBAAM,IAAI,MAAM,sBAAsB;AAAA,UACxC;AACA,eAAK,QAAQ,CAAC,GAAG,MAAM,YAAY,CAAC,IAAI,MAAM,CAAC,CAAC;AAAA,QAClD,OAAO;AACL,gBAAM,QAAQ,CAAC,MAAM,YAAY,KAAK,CAAC,CAAC;AAAA,QAC1C;AAAA,MACF,OAAO;AACL,YAAI,OAAO,WAAW,GAAG;AACvB,gBAAM,IAAI,MAAM,yCAAyC;AAAA,QAC3D,OAAO;AACL,wBAAc,WAAW,IAAI,CAAC,OAAO,UAAU,KAAK,MAAM,QAAQ,OAAO,KAAK,CAAC,CAAC;AAAA,QAClF;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAER,IAAM,oBAAoB,CAAC,YAA+B,QAAkB,eAAiC;AAC3G,YAAM,iBAAiB,MAAM;AAC3B,gBAAQ,WAAW,uBAAuB;AAAA,UACxC,KAAK;AACH,mBAAO,WAAW,KAAK,SAAS,IAAI,KAAK,IAAI,GAAG,WAAW,KAAK,IAAI,OAAK,OAAO,CAAC,CAAC,GAAG,OAAO,SAAS,IACjE,KAAK,IAAI,GAAG,QAAQ,OAAO,SAAS;AAAA,UAC1E,KAAK;AACH,mBAAO,WAAW,KAAK,SAAS,IAAI,KAAK,IAAI,GAAG,WAAW,KAAK,IAAI,OAAK,OAAO,CAAC,CAAC,GAAG,OAAO,SAAS,IACjE,KAAK,IAAI,GAAG,QAAQ,OAAO,SAAS;AAAA,UAC1E;AACE,kBAAM,IAAI,MAAM,4BAA4B,WAAW,qBAAqB,mBAAmB;AAAA,QACnG;AAAA,MACF,GAAG;AACH,aAAO,KAAK,GAAK,GAAG,OAAO,MAAM;AACjC,YAAM,sBAAsB,WAAW,MAAM;AAC7C,UAAI,WAAW,KAAK,SAAS,GAAG;AAC9B,mBAAW,KAAK,QAAQ,CAAC,MAAM,OAAO,CAAC,IAAI,aAAa;AACxD,mBAAW,KAAK,QAAQ,CAAC,MAAM,oBAAoB,CAAC,IAAI,KAAK,MAAM,WAAW,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC;AAAA,MAC/F,OAAO;AACL,eAAO,KAAK,eAAe,GAAG,OAAO,MAAM;AAC3C,4BAAoB,QAAQ,CAAC,GAAG,MAAM,oBAAoB,CAAC,IAAI,KAAK,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC;AAAA,MAC1F;AACA,aAAO;AAAA,IACT;AAEA,IAAM,4CACF,CAAC,QAAuB,YAA+B,aAAgC,cACtF,cAA8B;AAAA,mEACgC,OAAO,KAAK,OAAO,cAC9E,OAAO,KAAK,KAAK,KAAK,YAAY,MAAM;AAAA,oCACZ,OAAO,KAAK,KAAK,KAAK,YAAY,MAAM;AAAA,gCAC5C,YAAY,MAAM;AAAA,6BACrB,OAAO,WAAW,kBAAkB,GAAG,CAAC;AAAA,sBAC/C,aAAa,mBAAmB,KAAK,YAAY,CAAC;AAAA,wBAChD,aAAa,gBAAgB,KAAK,SAAS,CAAC;AAAA,uBAC7C,aAAa,gBAAgB,OAAO,WAAW,MAAM,IAAI,SAAS,CAAC;AAAA;AAAA,kCAExD,OAAO,KAAK,KAAK;AAAA;AAAA,gCAEnB,aAAa,wBAAwB,KAAK,WAAW,MAAM,CAAC;AAAA,iCAC3D,aAAa,yBAAyB,KAAK,YAAY,MAAM,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQ/F,IAAM,yCACF,CAAC,OAAsB,QAAuB,YAA+B,aAC5E,cAAsB,WAAmB,qBAAsC;AAAA,gEACpB,OAAO,KAAK,OAAO,QAAQ,MAAM,KAAK,OAAO;AAAA,2BAClF,MAAM,KAAK,OAAO;AAAA,gCACb,YAAY,MAAM;AAAA,6BACrB,OAAO,WAAW,kBAAkB,GAAG,CAAC;AAAA;AAAA,sBAE/C,aAAa,mBAAmB,KAAK,YAAY,CAAC;AAAA;AAAA;AAAA;AAAA,0BAI9C,aAAa,gBAAgB,KAAK,SAAS,CAAC;AAAA,yBAC7C,aAAa,gBAAgB,OAAO,WAAW,MAAM,IAAI,SAAS,CAAC;AAAA,gCAC5D,aAAa,wBAAwB,KAAK,WAAW,MAAM,CAAC;AAAA,iCAC3D,aAAa,yBAAyB,KAAK,YAAY,MAAM,CAAC;AAAA;AAAA;AAAA,iBAG9E,gBAAgB,4CAA4C,OAAO,KAAK,KAAK;AAAA;AAAA;AAAA,wCAGtD,OAAO,KAAK,KAAK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UAS/C,MAAM,WAAW,iBAAiB,KAAK,cAAc,CAAC;AAAA;AAAA;AAAA;AAIhE,IAAM,oBAAoB,CAAC,OAAsB,eAA0C;AAAA,0CACjD,MAAM,KAAK,OAAO;AAAA,gCAC5B,WAAW,MAAM;AAAA,4BACrB,MAAM,WAAW,iBAAiB,GAAG,CAAC;AAAA,gDAClB,aAAa,wBAAwB,KAAK,WAAW,MAAM,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAO5G,IAAM,4BACF,CAAC,OAAsB,YAAoB,UAAkB,gBACzD,MAAM,OAAO,cAAc;AAAA,MAC7B,MAAM,WAAW,iBAAiB,YAAY,SAAS,CAAC;AAAA,MACxD,MAAM,WAAW,iBAAiB,UAAU,OAAO,CAAC;AAAA,IAEvB;AAEnC,IAAM,wBACF,CAAC,OAAsB,QAAuB,YAA+B,kBAC5E,uBAAuC;AACtC,YAAM,SAAS;AACf,YAAM,CAAC,UAAU,WAAW,UAAU,UAAU,IAC5C,WAAW,WAAW,IAAI,CAAC,IAAI,GAAG,GAAG,EAAE,IAAK,SAAS,CAAC,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;AACnF,YAAM,QAAQ,MAAM,KAAK;AACzB,aAAO;AAAA,wEAC2D,KAAK;AAAA,2BAClD,MAAM,KAAK,OAAO;AAAA,QACrC,MAAM,WAAW,iBAAiB,WAAW,mBAAmB,WAAW,SAAS,CAAC,QAAQ,CAAC;AAAA,QAC9F,MAAM,WAAW,iBAAiB,UAAU,mBAAmB,WAAW,QAAQ,CAAC,QAAQ,CAAC;AAAA,QAC5F,0BAA0B,OAAO,YAAY,UAAU,CAAC,CAAC;AAAA,eAClD,MAAM,aAAa,eAAe,CAAC;AAAA;AAAA;AAAA,+CAGH,OAAO,KAAK,OAAO,QAAQ,KAAK;AAAA;AAAA,gBAE/D,KAAK,sBAAsB,SAAS;AAAA,gBACpC,KAAK,sBAAsB,QAAQ;AAAA,QAEzC,mBACI,yBAAyB,WAAW,SAAS,CAAC,8BAA8B,WAAW,QAAQ,CAAC;AAAA,iBAC7F,kBAAkB;AAAA,WAErB,EAAE;AAAA,8BACc,WAAW,SAAS,CAAC;AAAA,8BACrB,WAAW,QAAQ,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,2BAKvB,WAAW,SAAS,IAAI,uBAAuB,UAAU,OAAO,GAAG;AAAA,0BACpE,WAAW,SAAS,IAAI,uBAAuB,QAAQ,OAAO,GAAG;AAAA,iBAC1E,KAAK;AAAA,iBACL,KAAK;AAAA,iBACL,KAAK;AAAA,iBACL,KAAK;AAAA,iBACL,KAAK,gBAAgB,KAAK;AAAA,iBAC1B,KAAK,UAAU,KAAK;AAAA,iBACpB,KAAK,gBAAgB,KAAK;AAAA,iBAC1B,KAAK,UAAU,KAAK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAWjC;AAEJ,IAAM,uBACF,CAAC,OAAsB,QAAuB,YAA+B,aAC5E,QAA2B,KAAwB,aAAqB,kBACxE,oBAA4B,mBAAoC;AAC/D,YAAM,OAAO,WAAW,WAAW;AACnC,YAAM,SAAS;AACf,YAAM,CAAC,WAAW,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC;AACrE,YAAM,QAAQ,MAAM,KAAK;AACzB,YAAM,mCAAmC,CAAC,QAAwB;AAChE,cAAM,YAAY,QAAQ,YAAY,QAAQ;AAC9C,eAAO;AAAA,WACJ,SAAS,qCAAqC,MAAM,KAAK,OAAO,qBAC/D,OAAO,KAAK,OAAO,QAAQ,KAAK;AAAA,6BACf,OAAO,WAAW,kBAAkB,GAAG,CAAC;AAAA,2BAC1C,KAAK,+DAA+D,OAAO,GAAG,CAAC;AAAA,UAChG,YAAY,GAAG,CAAC,KAAK,WAAW,GAAG,CAAC,KAAK,IAAI,GAAG,CAAC,KAAK,IAAI,GAAG,CAAC,MAAM,WAAW,MAAM;AAAA,gCAC/D,KAAK;AAAA;AAAA;AAAA,cAGvB,gBAAgB,0CAA0C,WAAW,GAAG,CAAC;AAAA,mBACpE,kBAAkB;AAAA;AAAA,0BAEX,KAAK,gBAAgB,KAAK;AAAA;AAAA,gBAEpC,SAAS,KAAK,KAAK,oBAAoB,KAAK;AAAA,gBAC5C,SAAS,WAAW,SAAS,OAAO,WAAW,GAAG,CAAC;AAAA,eACpD,MAAM;AACX,cAAI,gBAAgB;AAClB,mBAAO;AAAA;AAAA,UAET,WAAW,kBAAkB;AAC3B,mBAAO,UAAU,kBAAkB;AAAA,UACrC,OAAO;AACL,mBAAO,GAAG,SAAS,iBAAiB,SAAS,KAAK,WAAW,GAAG,CAAC;AAAA,UACnE;AAAA,QACF,GAAG,CAAC;AAAA;AAAA,kCAEsB,MAAM,KAAK,OAAO;AAAA,YACxC,MAAM,WAAW,sBAAsB,KAAK,OAAO,SAAS,GAAG,CAAC;AAAA,0BAEhE,QAAQ,YAAY,MAAM,aAAa,oBAAoB,IACvC,2DAA2D;AAAA;AAAA;AAAA;AAAA,MAIrF;AAEA,aAAO;AAAA,MACP,iCAAiC,SAAS,CAAC;AAAA,MAC3C,iCAAiC,QAAQ,CAAC;AAAA,qCACX,KAAK,cAAc,KAAK;AAAA;AAAA,wBAErC,KAAK,gBAAgB,KAAK;AAAA,wBAC1B,KAAK;AAAA,wBACL,KAAK;AAAA,uBACN,KAAK;AAAA,oBACR,WAAW,wBAAwB,WAAW,yBACxD,WAAW,yBAAyB,WAAW;AAAA,oBACrC,WAAW,mBAAmB,WAAW;AAAA,oBACzC,WAAW,2BAA2B,WAAW;AAAA,oBACjD,WAAW,yBAAyB,WAAW,0BACzD,WAAW,0BAA0B,WAAW;AAAA;AAAA;AAAA;AAAA,qCAIrB,KAAK,sBAAsB,KAAK,YAAY,KAAK;AAAA,oBAClE,KAAK;AAAA;AAAA;AAAA;AAAA,4CAImB,OAAO,KAAK,OAAO,QAAQ,KAAK;AAAA,yBACnD,MAAM,KAAK,OAAO;AAAA;AAAA;AAAA;AAAA,IAIvC;AAEJ,IAAM,yBACF,CAAC,OAAsB,QAAuB,YAA+B,kBAC5E,uBAAuC;AACtC,YAAM,SAAS;AACf,YAAM,CAAC,UAAU,UAAU,WAAW,UAAU,UAAU,IACtD,WAAW,WAAW,IAAI,CAAC,IAAI,GAAG,GAAG,GAAG,EAAE,IAAK,SAAS,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC;AAC5F,YAAM,QAAQ,MAAM,KAAK;AACzB,aAAO;AAAA,wFAC2E,KAAK;AAAA,2BAClE,MAAM,KAAK,OAAO;AAAA,QACrC,MAAM,WAAW,iBAAiB,UAAU,qBAAqB,WAAW,QAAQ,CAAC,QAAQ,CAAC;AAAA,QAC9F,MAAM,WAAW,iBAAiB,WAAW,sBAAsB,WAAW,SAAS,CAAC,QAAQ,CAAC;AAAA,QACjG,MAAM,WAAW,iBAAiB,UAAU,qBAAqB,WAAW,QAAQ,CAAC,QAAQ,CAAC;AAAA,QAC9F,0BAA0B,OAAO,YAAY,UAAU,CAAC,CAAC;AAAA,eAClD,MAAM,aAAa,eAAe,CAAC;AAAA;AAAA;AAAA,gDAGF,OAAO,KAAK,OAAO,QAAQ,KAAK;AAAA;AAAA,kBAE9D,KAAK,sBAAsB,QAAQ;AAAA,mBAClC,KAAK,sBAAsB,SAAS;AAAA,kBACrC,KAAK,sBAAsB,QAAQ;AAAA,QAE3C,mBAAmB,6BAA6B,WAAW,QAAQ,CAAC,oCAC7C,WAAW,SAAS,CAAC,kCAAkC,WAAW,QAAQ,CAAC;AAAA,eAC7F,kBAAkB;AAAA,aAEJ,EAAE;AAAA;AAAA,gCAEC,WAAW,QAAQ,CAAC;AAAA,oCAChB,WAAW,SAAS,CAAC;AAAA,kCACvB,WAAW,QAAQ,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,2BAO3B,WAAW,SAAS,IAAI,uBAAuB,UAAU,OAAO,GAAG;AAAA,0BACpE,WAAW,SAAS,IAAI,uBAAuB,QAAQ,OAAO,GAAG;AAAA;AAAA,kBAEzE,KAAK;AAAA,kBACL,KAAK;AAAA,kBACL,KAAK;AAAA,kBACL,KAAK;AAAA,kBACL,KAAK;AAAA,kBACL,KAAK;AAAA,kBACL,KAAK;AAAA,kBACL,KAAK;AAAA,iBACN,KAAK,kBAAkB,KAAK;AAAA,iBAC5B,KAAK,UAAU,KAAK;AAAA,iBACpB,KAAK,mBAAmB,KAAK;AAAA,iBAC7B,KAAK,UAAU,KAAK;AAAA,iBACpB,KAAK,kBAAkB,KAAK;AAAA,iBAC5B,KAAK,UAAU,KAAK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAgBjC;AAEJ,IAAM,0BACF,CAAC,aAAyB,YAA8B,cAAsB,aAC7E,OAA0B,aAA6C;AACtE,YAAM,aAAa,YAAY;AAC/B,YAAM,MAAM,UAAU,UAAU,WAAW,MAAM,WAAW,MAAM;AAElE,UAAI,cAAc,gBAAgB,YAAY,aAAa,OAAO,WAAW,IAAI;AACjF,UAAI,SAAS,YAAY,MAAM;AAC/B,UAAI,YAAY,WAAW,GAAG;AAC5B,iBAAS,WAAW,IAAI,CAAC,OAAO,UAAU,UAAU,IAAI,IAAM,YAAY,KAAK,IAAI,KAAK;AACxF,YAAI,WAAW,0BAA0B,WAAW;AAClD,wBAAc,kBAAkB,YAAY,QAAQ,UAAU;AAAA,QAChE;AAAA,MACF;AACA,YAAM,SAAS,eAAe,UAAU,YAAY,UAAU,YAAY,MAAM;AAChF,YAAM,QAAQ,cAAc,SAAS,YAAY,UAAU,WAAW,MAAM;AAC5E,YAAM,aAAa,UAAU,KAAK,WAAW;AAC7C,YAAM,UAAU,WAAW,WAAW,YAAY,UAAU,WAAW,MAAM,CAAC,GAAG,MAAM,MAAM,YAAY,CAAC,CAAC;AAC3G,YAAM,mBAAmB,WAAW,4BAA4B;AAChE,YAAM,qBAAqB,WAAW;AACtC,YAAM,WAAW,MAAM,KAAK;AAC5B,YAAM,kBAAkB,CAAC,iBAA+B;AAAA,QACtD,UAAU,KAAK;AAAA,QACf,2CAA2C,WAAW,yBAAyB,QAAQ,CAAC;AAAA,SACvF,MAAM;AACP,gBAAQ,WAAW,MAAM;AAAA,UACvB,KAAK;AACH,mBAAO;AAAA,gBACH,kBAAkB,OAAO,UAAU,CAAC;AAAA,gBACpC,4BAA4B,WAAW,aAAa,cAAc,QAAQ,CAAC;AAAA,gBAE3E;AAAA,cACI;AAAA,cAAO;AAAA,cAAQ;AAAA,cAAY;AAAA,cAAa,OAAO;AAAA,cAAQ,IAAI;AAAA,cAAQ;AAAA,YAAgB,CAAC;AAAA;AAAA,UAE9F,KAAK;AACH,mBAAO;AAAA,gBACH,0CAA0C,QAAQ,YAAY,aAAa,OAAO,QAAQ,IAAI,MAAM,CAAC;AAAA,iBACpG,MAAM;AACT,kBAAI,WAAW,WAAW,KAAK,WAAW,WAAW,GAAG;AACtD,uBAAO,GAAG,sBAAsB,OAAO,QAAQ,YAAY,kBAAkB,kBAAkB,CAAC;AAAA,cAClG,WAAW,WAAW,WAAW,KAAK,WAAW,WAAW,GAAG;AAC7D,uBAAO,GAAG,uBAAuB,OAAO,QAAQ,YAAY,kBAAkB,kBAAkB,CAAC;AAAA,cACnG,OAAO;AACL,sBAAM,MAAM,kFAAkF;AAAA,cAChG;AAAA,YACF,GAAG,CAAC;AAAA;AAAA,UAEN,KAAK;AACH,mBAAO;AAAA,eACJ,MAAM;AACP,kBAAI,WAAW,WAAW,KAAK,WAAW,WAAW,GAAG;AACtD,uBAAO,GACH;AAAA,kBACI;AAAA,kBAAO;AAAA,kBAAQ;AAAA,kBAAY;AAAA,kBAAa;AAAA,kBAAQ;AAAA,kBAAK,WAAW;AAAA,kBAAa;AAAA,kBAC7E,WAAW;AAAA,kBAAoB,WAAW;AAAA,gBAAc,CAAC;AAAA,cACnE,OAAO;AACL,sBAAM,MAAM,2EAA2E;AAAA,cACzF;AAAA,YACF,GAAG,CAAC;AAAA;AAAA,UAEN;AACE,kBAAM,MAAM,qBAAqB;AAAA,QACrC;AAAA,MACF,GAAG,CAAC;AAAA,OACH;AAAA,QAEG,aAAa,gBAAgB,eAAe,KAAK,EAC5C,gBAAgB,UAAU,OAAO,OAAO,MAAM,EAC9C,gBAAgB,OAAO,OAAO,IAAI,MAAM,EACxC,iBAAiB,OAAO,MAAM,CAAC;AAAA,QACtC,aAAa,UAAU,CAAC;AAAA,UACtB,aAAa,sCAAsC,sBAAsB,CAAC;AAAA,UAC1E,UAAU,4CAA4C;AAAA,+BACjC,OAAO,gBAAgB,YAAY,CAAC;AAAA,6BACtC,MAAM,KAAK,OAAO;AAAA,WACpC,MAAM;AACT,gBAAQ,WAAW,MAAM;AAAA,UACvB,KAAK;AACH,mBAAO;AAAA;AAAA,yCAEsB,MAAM,aAAa,eAAe,CAAC;AAAA;AAAA,yCAEnC,WAAW,kBAAkB;AAAA;AAAA,UAE5D,KAAK;AACH,mBAAO,wBACF,WAAW,WAAW,KAAK,WAAW,WAAW,IAAK,0BACA,wBAAwB;AAAA,UACrF,KAAK;AACH,mBAAO;AAAA,UACT;AACE,kBAAM,MAAM,4BAA4B,WAAW,IAAI,EAAE;AAAA,QAC7D;AAAA,MACF,GAAG,CAAC;AAAA,CACT;AAAA;AAGK,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa;AAAA,UACX,MAAM,GAAG,WAAW,QAAQ,IAAI,YAAY,IAAI,OAAO,SAAS,IAAI,SAAS,EAAE,IAC3E,MAAM,SAAS,IAAI,QAAQ,EAAE,IAAI,IAAI,SAAS,IAAI,MAAM,EAAE,IAAI,OAAO,IAAI,UAAU;AAAA,UACvF,mBAAmB,CAAC,MAAM;AAAA,QAC5B;AAAA,QACA;AAAA,QACA,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,YAAY,SAAQ,CAAC;AAAA,UAC7D,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa;AAAA;AAAA,UAAuB,EAAC;AAAA,UAClE,iBAAiB;AAAA,YACf,EAAC,uBAAuB,MAAM,WAAU;AAAA,YAAG,EAAC,qBAAsB,MAAM,OAAM;AAAA,YAC9E,EAAC,qBAAsB,MAAM,IAAG;AAAA,YAAG,GAAG,2BAA2B,YAAY,WAAW;AAAA,UAC1F;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEJ,IAAM,sCAAsC,CAAC,YAAoC;AAC/E,YAAM,mBAAmB,QAAQ;AACjC,YAAM,qBAAqB,IAAI,YAAY,kBAAkB,iBAAiB,YAAY,CAAC;AAC3F,YAAM,eAAe,mBAAmB,CAAC;AACzC,aAAO;AAAA,IACT;AAEO,IAAM,SAAS,CAAC,SAAyB,eAAuC;AACrF,YAAM,SAAmB,CAAC;AAC1B,YAAM,QAAkB,CAAC;AACzB,YAAM,MAAgB,CAAC;AAKvB,YAAM,eAAe,oCAAoC,OAAO;AAChE,UAAI,WAAW,cAAc,GAAG;AAC9B,cAAM,MAAM,6DAA6D;AAAA,MAC3E;AACA,MAAAA,iBAAe,QAAQ,QAAQ,YAAY,cAAc,QAAQ,OAAO,GAAG;AAC3E,cAAQ;AAAA,QACJ,wBAAwB,QAAQ,OAAO,CAAC,GAAG,YAAY,cAAc,QAAQ,OAAO,GAAG;AAAA,QAAG,EAAC,QAAQ,CAAC,CAAC,EAAC;AAAA,MAAC;AAAA,IAC7G;AAEO,IAAM,wBAAwB,CAAC,eAA0D;AAC9F,YAAM,YAAY,WAAW;AAC7B,YAAM,OAAO,WAAW;AACxB,YAAM,0BACF,WAAW;AACf,YAAM,cAAc,WAAW;AAC/B,YAAM,iBAAiB,WAAW,mBAA6B;AAC/D,YAAM,qBAAqB,WAAW;AACtC,YAAM,wBAA+C,WAAW;AAChE,YAAM,OAAa,WAAW;AAE9B,YAAM,cAA4B,WAAW,gBAAgB,KAAK,WAAW,WAAW;AACxF,aAAO,4BAA4B;AAAA,QACjC;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH;AAAA;AAAA;;;AC1rBA,IAkBMC,kBAqDA,kCA+FO;AAtKb;AAAA;AAAA;AAGA;AAEA;AACA;AAGA;AASA,IAAMA,mBAAiB,CAAC,QAA+B,eAAgD;AACrG,YAAM,CAAC,OAAO,aAAa,UAAU,QAAQ,IAAI;AACjD,YAAM,EAAC,UAAU,mBAAkB,IAAI;AAEvC,UAAI,MAAM,KAAK,WAAW,KAAK,MAAM,KAAK,WAAW,GAAG;AACtD,cAAM,IAAI,MAAM,wDAAwD,MAAM,KAAK,MAAM,EAAE;AAAA,MAC7F;AACA,UAAI,CAAC,UAAU,SAAS,YAAY,MAAM,CAAC,CAAC,KAAK,CAAC,UAAU,SAAS,YAAY,MAAM,CAAC,CAAC,CAAC,KACtF,YAAY,KAAK,WAAW,GAAG;AACjC,cAAM,IAAI,MAAM,uEAAuE,YAAY,KAAK,MAAM,EAAE;AAAA,MAClH;AACA,UAAI,SAAS,KAAK,WAAW,GAAG;AAC9B,cAAM,IAAI,MAAM,2DAA2D,SAAS,KAAK,MAAM,EAAE;AAAA,MACnG;AACA,UAAI,SAAS,KAAK,WAAW,GAAG;AAC9B,cAAM,IAAI,MAAM,2DAA2D,SAAS,KAAK,MAAM,EAAE;AAAA,MACnG;AACA,UAAI,CAAC,UAAU,SAAS,SAAS,MAAM,SAAS,IAAI,GAAG;AACrD,cAAM,IAAI,MAAM,wEAA4E;AAAA,MAC9F;AAEA,UAAI,qBAAqB,KAAK,aAAa,GAAG;AAC5C,cAAM,IAAI,MAAM,iEAAiE;AAAA,MACnF;AAEA,YAAM,YAAY,MAAM,KAAK,CAAC;AAC9B,YAAM,iBAAiB,MAAM,KAAK,MAAM,KAAK,SAAS,CAAC;AACvD,YAAM,oBAAoB,SAAS,KAAK,CAAC;AACzC,YAAM,aAAa,UAAU,kBAAkB,MAAM,MAAM,CAAC,IAAI;AAChE,YAAM,WAAW,uBAAuB,IAAI,SAAS,KAAK,CAAC,IAAI,IAAI,aAAa;AAChF,UAAI,qBAAqB,UAAU;AACjC,cAAM,IAAI,MAAM,8DAA8D;AAAA,MAChF;AAEA,UAAI,YAAY,KAAK,WAAW,GAAG;AACjC,YAAI,cAAc,YAAY,KAAK,CAAC,GAAG;AACrC,gBAAM,IAAI,MAAM,sEAAsE,YAAY,KAAK,CAAC,CAAC,EAAE;AAAA,QAC7G;AACA,YAAI,mBAAmB,YAAY,KAAK,CAAC,GAAG;AAC1C,gBAAM,IAAI,MAAM,2EAA2E,YAAY,KAAK,CAAC,CAAC,EAAE;AAAA,QAClH;AAAA,MACF;AAEA,UAAI,WAAW,MAAM,SAAS,KAAK,CAAC,KAAK,qBAAqB,MAAM,SAAS,KAAK,CAAC,GAAG;AACpF,cAAM,IAAI,MAAM,kGACZ,SAAS,KAAK,CAAC,CAAC,EAAE;AAAA,MACxB;AAEA,UAAI,iBAAiB,mBAAmB;AACtC,cAAM,IAAI,MAAM,gFAAgF;AAAA,MAClG;AAAA,IACF;AAEA,IAAM,mCACF,CAAC,QAA+B,eAAuD;AACrF,YAAM,EAAC,aAAa,UAAU,oBAAoB,MAAK,IAAI;AAC3D,YAAM,YAAY,OAAO,CAAC,EAAE,KAAK,CAAC;AAClC,YAAM,cAAc,UAAU,kBAAkB,OAAO,CAAC,EAAE,MAAM,CAAC;AACjE,YAAM,iBAAiB,OAAO,CAAC,EAAE,KAAK,OAAO,CAAC,EAAE,KAAK,SAAS,CAAC;AAC/D,YAAM,aAAa,cAAc;AACjC,YAAM,yBAAyB,OAAO,CAAC,EAAE,KAAK,CAAC;AAC/C,YAAM,WAAW,uBAAuB,IAAI,yBAAyB,IAAI,aAAa;AAKtF,YAAM,cACF,IAAI,MAAc,WAAW,gBAAgB,aAAa,UAAU,WAAW,sBAAsB;AACzG,YAAM,gBAAgB,UAAU,eAAe,WAAW;AAE1D,YAAM,kBAAoC;AAAA,QACxC,EAAC,qBAAsB,MAAM,MAAK;AAAA,QAClC,EAAC,uBAAuB,MAAM,YAAW;AAAA,QACzC,EAAC,uBAAuB,MAAM,cAAa;AAAA;AAAA;AAAA,QAI3C,GAAI,OAAO,CAAC,EAAE,KAAK,WAAW,IACtB,IAAI,MAAsB,EAAC,uBAAuB,MAAM,CAAC,aAAa,YAAY,UAAU,CAAC,EAAC,CAAC,IAC/F,CAAC;AAAA,QACT,GAAI,OAAO,CAAC,EAAE,KAAK,WAAW,IACtB,IAAI;AAAA,UACA,EAAC,uBAAuB,MAAM,CAAC,aAAa,UAAU,iBAAiB,UAAU,CAAC,EAAC;AAAA,QAAC,IACxF,CAAC;AAAA,QAET,GAAG,2BAA2B,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,EAAE,IAAI;AAAA,MAC9G;AAEA,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,QAAQ,cAAc,SAAS,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,MAAM;AAC9E,cAAM,cAAc,cAAc,gBAAgB,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,MAAM;AAC3F,cAAM,WAAW,cAAc,aAAa,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,MAAM;AACrF,cAAM,WAAW,cAAc,aAAa,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,MAAM;AACrF,cAAM,SAAS,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,MAAM;AAEjF,qBAAa,iBAAiB;AAAA,UAC5B,EAAC,MAAM,SAAS,MAAM,MAAK;AAAA,UAC3B,EAAC,MAAM,gBAAgB,MAAM,OAAO,QAAQ,YAAY,OAAM;AAAA,UAC9D,EAAC,MAAM,kBAAkB,MAAM,OAAO,QAAQ,cAAc,OAAM;AAAA,UAClE,EAAC,MAAM,wBAAwB,MAAM,OAAO,QAAQ,cAAc,OAAM;AAAA,QAC1E,CAAC;AAED,eAAO;AAAA,UACL,aAAa,iBAAiB,OAAO,aAAa,UAAU,UAAU,MAAM,CAAC;AAAA;AAAA,UAE7E,aAAa,UAAU,cAAc,CAAC;AAAA,+CACD,SAAS,IAAI;AAAA;AAAA;AAAA,YAGhD,aAAa,sCAAsC,MAAM,CAAC;AAAA;AAAA;AAAA;AAAA,kBAIpD,YAAY,2BAA2B,WAAW,eAAe,IAAI,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC;AAAA;AAAA,sBAE7F,YAAY,YAAY,kBAAkB,CAAC;AAAA,oFACmB,WAAW;AAAA,yDACtC,WAAW;AAAA,uBAC7C,MAAM,YAAY,GAAG,CAAC,MAAM,SAAS,IAAI,eAAe,SAAS,CAAC;AAAA,kBACvE,MAAM,YAAY,GAAG,CAAC,MAAM,SAAS,IAAI,eAAe,SAAS,CAAC;AAAA,cACtE,OAAO,YAAY,KAAK,IAAI,CAAC;AAAA,uBACpB,MAAM,YAAY,GAAG,CAAC,MAAM,SAAS,IAAI,eAAe,SAAS,CAAC;AAAA,kBACvE,MAAM,YAAY,GAAG,CAAC,MAAM,SAAS,IAAI,eAAe,SAAS,CAAC;AAAA,cACtE,OAAO,YAAY,KAAK,IAAI,CAAC;AAAA;AAAA;AAAA,cAG7B,OAAO,YAAY,KAAK,MAAM,YAAY,GAAG,CAAC,CAAC;AAAA;AAAA;AAAA,MAGvD;AAEA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa;AAAA,UACX,MAAM,4BAA4B;AAAA,YAC1B;AAAA,UACF,CAAC,EAAE;AAAA,UACT,mBAAmB,CAAC,QAAQ,QAAQ,QAAQ,MAAM;AAAA,QACpD;AAAA,QACA;AAAA,QACA,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,OAAO,CAAC,EAAE,MAAM,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,UAC9D,eAAe,EAAC,GAAG,KAAK,KAAK,UAAU,KAAK,WAAW,IAAI,cAAc,EAAC;AAAA,UAC1E;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEG,IAAM,kBAAkB,CAAC,SAAyB,eAAgD;AACvG,MAAAA,iBAAe,QAAQ,QAAQ,UAAU;AACzC,cAAQ,QAAQ,iCAAiC,QAAQ,QAAQ,UAAU,CAAC;AAAA,IAC9E;AAAA;AAAA;;;ACzKA,IAeMC,kBAyDA,gCA2GO;AAnLb;AAAA;AAAA;AAGA;AAEA;AAGA;AAOA,IAAMA,mBAAiB,CAAC,WAAwC;AAC9D,UAAI,CAAC,UAAU,OAAO,SAAS,GAAG;AAChC,cAAM,IAAI,MAAM,uCAAuC;AAAA,MACzD;AAEA,YAAM,QAAoB,OAAO,CAAC;AAClC,YAAM,OAAmB,OAAO,CAAC;AACjC,YAAM,QAAoB,OAAO,CAAC;AAElC,UAAI,MAAM,aAAa,KAAK,YAAY,MAAM,aAAa,MAAM,UAAU;AACzE,cAAM,IAAI,MAAM,yCAAyC;AAAA,MAC3D;AAEA,UAAI,MAAM,KAAK,WAAW,KAAK,MAAM,KAAK,WAAW,GAAG;AACtD,cAAM,IAAI,MAAM,wBAAwB;AAAA,MAC1C;AAEA,UAAI,KAAK,KAAK,WAAW,KAAK,KAAK,KAAK,WAAW,GAAG;AACpD,cAAM,IAAI,MAAM,uBAAuB;AAAA,MACzC;AAEA,YAAM,aAAa,MAAM,KAAK,MAAM,KAAK,SAAS,CAAC;AACnD,YAAM,iBAAiB,MAAM,KAAK,MAAM,KAAK,SAAS,CAAC;AACvD,UAAI,KAAK,KAAK,KAAK,KAAK,SAAS,CAAC,MAAM,YAAY;AAClD,cAAM,IAAI,MAAM,8CAA8C;AAAA,MAChE;AACA,UAAI,KAAK,KAAK,KAAK,KAAK,SAAS,CAAC,MAAM,gBAAgB;AACtD,cAAM,IAAI,MAAM,kDAAkD;AAAA,MACpE;AAEA,UAAI,MAAM,KAAK,WAAW,GAAG;AAC3B,cAAM,IAAI,MAAM,kBAAkB;AAAA,MACpC;AACA,UAAI,MAAM,KAAK,MAAM,KAAK,SAAS,CAAC,MAAM,YAAY;AACpD,cAAM,IAAI,MAAM,+CAA+C;AAAA,MACjE;AACA,UAAI,OAAO,SAAS,GAAG;AACrB,cAAM,OAAmB,OAAO,CAAC;AACjC,YAAI,KAAK,KAAK,WAAW,GAAG;AAC1B,gBAAM,IAAI,MAAM,iBAAiB;AAAA,QACnC;AACA,YAAI,KAAK,KAAK,KAAK,KAAK,SAAS,CAAC,MAAM,YAAY;AAClD,gBAAM,IAAI,MAAM,8CAA8C;AAAA,QAChE;AAAA,MACF;AAEA,UAAI,OAAO,SAAS,GAAG;AACrB,cAAM,OAAmB,OAAO,CAAC;AACjC,YAAI,KAAK,KAAK,WAAW,GAAG;AAC1B,gBAAM,IAAI,MAAM,iBAAiB;AAAA,QACnC;AACA,YAAI,KAAK,KAAK,KAAK,KAAK,SAAS,CAAC,MAAM,YAAY;AAClD,gBAAM,IAAI,MAAM,8CAA8C;AAAA,QAChE;AAAA,MACF;AAAA,IACF;AAEA,IAAM,iCACF,CAAC,QAA+B,YAAqC,aAAqB,eACvE;AACb,YAAM,aAAa,WAAW;AAE9B,YAAM,aAAa,OAAO,CAAC,EAAE;AAC7B,YAAM,YAAY,UAAU,KAAK,UAAU;AAC3C,YAAM,cAAc;AACpB,YAAM,aAAa;AACnB,YAAM,aAAa,WAAW,MAAM,EAAE,EAAE,CAAC;AACzC,YAAM,mBAAmB,aAAa,WAAW,MAAM,GAAG,EAAE,EAAE,OAAO,CAAC,IAAI,CAAC;AAC3E,YAAM,eAAe,CAAC,cAAc,OAAO,SAAS;AACpD,YAAM,eAAe,OAAO,SAAS;AACrC,YAAM,gBAAgB,cAAc,cAAc;AAClD,YAAM,qBAAqB,cAAc,cAAc;AACvD,YAAM,4BAA4B,cAAc;AAEhD,YAAM,aAAa,iBAAiB,UAAU;AAE9C,YAAM,kBAAoC;AAAA,QACxC,EAAC,uBAAuB,MAAM,WAAU;AAAA,QACxC,EAAC,uBAAuB,MAAM,WAAU;AAAA,QACxC,EAAC,uBAAuB,MAAM,WAAU;AAAA,QACxC,EAAC,qBAAsB,MAAM,WAAW,QAAO;AAAA,MACjD;AACA,YAAM,kBAAkB,CAAC,iBAA+B;AACtD,cAAM,gBAAmC;AAAA,UACvC,EAAC,MAAM,eAAe,MAAM,MAAK;AAAA,UACjC,EAAC,MAAM,cAAc,MAAM,MAAK;AAAA,UAChC,EAAC,MAAM,eAAe,MAAM,MAAK;AAAA,UACjC,EAAC,MAAM,WAAW,MAAM,MAAK;AAAA,QAC/B;AACA,cAAM,YAAY;AAAA,UAChB,cAAc,KAAK,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,MAAM,UAAU;AAAA,UACjE,cAAc,QAAQ,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,MAAM,UAAU;AAAA,UACpE,cAAc,SAAS,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,MAAM,UAAU;AAAA,QACvE;AACA,YAAI,cAAc;AAChB,oBAAU,KAAK,cAAc,QAAQ,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,MAAM,UAAU,CAAC;AAAA,QACtF;AACA,YAAI,cAAc;AAChB,oBAAU,KAAK,cAAc,QAAQ,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,MAAM,UAAU,CAAC;AAAA,QACtF;AACA,kBAAU,KAAK,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,aAAa,UAAU,CAAC;AACpF,YAAI,eAAe;AACjB,oBAAU,KAAK,eAAe,8BAA+B,gBAAgB,CAAC;AAAA,QAChF;AACA,YAAI,oBAAoB;AACtB,oBAAU,KAAK,eAAe,iCAAkC,gBAAgB,CAAC;AAAA,QACnF;AACA,YAAI,2BAA2B;AAC7B,oBAAU,KAAK,eAAe,uBAAuB,OAAO,CAAC,EAAE,UAAU,aAAa,UAAU,CAAC;AAAA,QACnG;AACA,cAAM,WAAW,4BAA4B,OAAO,CAAC,EAAE,QAAQ;AAC/D,eAAO;AAAA;AAAA,QAEX,aAAa,iBAAiB,aAAa,EAAE,iBAAiB,GAAG,SAAS,CAAC;AAAA;AAAA,QAE3E,aAAa,UAAU,CAAC;AAAA,UACtB,aAAa,sCAAsC,6CAA6C,CAAC;AAAA;AAAA;AAAA,oBAGvF,WAAW,OAAO,UAAU,CAAC;AAAA,0BACvB,WAAW,OAAO,UAAU,CAAC;AAAA;AAAA;AAAA,6BAG1B,eAAe,YAAY,WAAW,OAAO;AAAA;AAAA;AAAA,YAG9D,4BAA4B,6CAA6C,EAAE;AAAA;AAAA,4BAE3D,UAAU,UAAU,YAAY,OAAO,CAAC;AAAA;AAAA;AAAA;AAAA,qBAI/C,UAAU,OAAO,UAAU,CAAC;AAAA,wCACT,UAAU,aAAa,UAAU,CAAC,gCAC1D,aAAa,KAAK,eAAe;AAAA,UACvC,gBAAgB,oCAAoC,EAAE;AAAA,UACtD,qBAAqB,8CAA8C,EAAE;AAAA;AAAA,qDAE1B,aAAa,KAAK,KAAK,QAAQ,QAAQ,OAC5E,QAAQ,4BAA4B,eAAe,cAAc,EAAE;AAAA;AAAA;AAAA,MAGzE;AACA,YAAM,UAAU,CAAC,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAClE,UAAI,cAAc,GAAG;AACnB,gBAAQ,KAAK,EAAC,MAAM,kBAAkB,wBAAwB,CAAC;AAAA,MACjE;AACA,UAAI,cAAc,GAAG;AACnB,gBAAQ,KAAK,EAAC,MAAM,kBAAkB,wBAAwB,CAAC;AAAA,MACjE;AACA,UAAI,cAAc,GAAG;AACnB,gBAAQ,KAAK,EAAC,MAAM,YAAY,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,MAC/D;AACA,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa;AAAA,UACX,MAAM,GAAG,UAAU,IAAI,aAAa,IAAI,kBAAkB,IAAI,yBAAyB;AAAA,UACvF,mBAAmB,OAAO,IAAI,CAAC,QAAQ,WAAW,MAAM;AAAA,QAC1D;AAAA,QACA;AAAA,QACA,YAAY,OAAO,EAAC,SAAS,eAAe,EAAC,GAAG,KAAK,KAAK,aAAa,aAAa,EAAE,EAAC,GAAG,gBAAe;AAAA,MAC3G;AAAA,IACF;AAED,IAAM,gBAAgB,CAAC,SAAyB,eAA8C;AAEnG,YAAM,aAAa;AACnB,MAAAA,iBAAe,QAAQ,MAAM;AAG7B,YAAM,UAAU,CAAC,CAAC;AAClB,UAAI,QAAQ,cAAc,GAAG;AAC3B,gBAAQ,KAAK,aAAa,IAAI,EAAE;AAAA,MAClC;AACA,UAAI,QAAQ,cAAc,GAAG;AAC3B,gBAAQ,KAAK,aAAa,IAAI,EAAE;AAAA,MAClC;AACA,UAAI,QAAQ,cAAc,GAAG;AAC3B,gBAAQ,KAAK,CAAC;AAAA,MAChB;AACA,cAAQ;AAAA,QACJ,+BAA+B,QAAQ,QAAQ,YAAY,QAAQ,aAAa,UAAU;AAAA,QAAG,EAAC,QAAO;AAAA,MAAC;AAAA,IAC5G;AAAA;AAAA;;;ACrMA,IAiBMC,kBAkBA,WAcA,iCAeA,mBAcA,2BAsBA,wBAmFO,OAYA;AAnMb;AAAA;AAAA;AAGA;AAEA;AACA;AAGA;AAQA,IAAMA,mBAAiB,CAAC,QAA+B,eAAsC;AAC3F,UAAI,CAAC,UAAU,OAAO,SAAS,GAAG;AAChC,cAAM,IAAI,MAAM,gBAAgB;AAAA,MAClC;AACA,UAAI,WAAW,KAAK,WAAW,GAAG;AAChC,YAAI,WAAW,KAAK,WAAW,WAAW,OAAO,UAAU,WAAW,KAAK,WAAW,WAAW,KAAK,QAAQ;AAC5G,gBAAM,IAAI,MAAM,iDAAiD;AAAA,QACnE;AAAA,MACF,WAAW,WAAW,OAAO,WAAW,WAAW,KAAK,QAAQ;AAC9D,cAAM,IAAI,MAAM,2CAA2C;AAAA,MAC7D;AACA,aAAO,MAAM,CAAC,EAAE,QAAQ,CAAC,GAAG,QAAQ;AAClC,YAAI,OAAO,MAAM,CAAC,EAAE,8BAA+B,OAAO,MAAM,CAAC,EAAE,4BAA6B;AAC9F,gBAAM,IAAI,MAAM,SAAS,GAAG,qCAAqC;AAAA,QACnE;AAAA,MACF,CAAC;AAAA,IACH;AAEA,IAAM,YAAY,CAAC,QAA+B,QAA0B;AAC1E,YAAM,QAAkB,CAAC;AACzB,UAAI,OAAO,SAAS,KAAK;AACvB,YAAI,OAAO,GAAG,EAAE,4BAA6B;AAC3C,iBAAO,GAAG,EAAE,iBAAiB,EAAE,QAAQ,OAAK,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC;AAAA,QACnE,WAAW,OAAO,GAAG,EAAE,4BAA6B;AAClD,iBAAO,GAAG,EAAE,cAAc,EAAE,QAAQ,OAAK,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC;AAAA,QAChE,OAAO;AACL,gBAAM,IAAI,MAAM,SAAS,GAAG,qCAAqC;AAAA,QACnE;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAEA,IAAM,kCACF,CAAC,QAA+B,eAAiD;AAC/E,UAAI,OAAO,SAAS,GAAG;AACrB,cAAM,SAAmB,UAAU,QAAQ,CAAC;AAC5C,cAAM,OAAiB,UAAU,QAAQ,CAAC;AAC1C,YAAI,OAAiB,UAAU,QAAQ,CAAC;AACxC,YAAI,KAAK,WAAW,GAAG;AACrB,iBAAO,CAAC,GAAG,MAAM,OAAO,CAAC,EAAE,KAAK,MAAM,EAAE,KAAK,CAAC;AAAA,QAChD;AACA,eAAO,4BAA4B,EAAC,QAAQ,MAAM,KAAI,CAAC;AAAA,MACzD,OAAO;AACL,eAAO;AAAA,MACT;AAAA,IACF;AAEJ,IAAM,oBACF,CAAC,OAAe,OAAe,YAA+B,MAAyB,UACzE;AACR,UAAI,WAAW;AACf,UAAI,QAAQ,GAAG;AACb,oBAAY,WAAW,KAAK,KAAK,CAAC;AAAA,MACpC;AACA,UAAI,MAAM,KAAK,IAAI,GAAG;AACpB,eAAO,KAAK,IAAI,GAAG,KAAK,IAAI,UAAU,WAAW,KAAK,KAAK,CAAC,IAAI,CAAC,CAAC;AAAA,MACpE,OAAO;AACL,eAAO,KAAK,IAAI,GAAG,KAAK,IAAI,UAAU,WAAW,KAAK,KAAK,CAAC,CAAC,CAAC;AAAA,MAChE;AAAA,IACF;AAER,IAAM,4BACF,CAAC,OAAsB,QAAuB,eAC1C,4CAA4C,OAAO,KAAK,OAAO,QAAQ,MAAM,KAAK,OAAO;AAAA,+BAClE,MAAM,KAAK,OAAO;AAAA;AAAA,yBAExB,WAAW,MAAM;AAAA,kCACR,aAAa,wBAAwB,KAAK,WAAW,MAAM,CAAC;AAAA,4BAClE,aAAa,kBAAkB,KAAK,WAAW,MAAM,CAAC;AAAA,4BACtD,aAAa,kBAAkB,KAAK,WAAW,MAAM,CAAC;AAAA,6BACrD,aAAa,mBAAmB,KAAK,WAAW,MAAM,CAAC;AAAA,iCACnD,OAAO,WAAW,kBAAkB,GAAG,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,cAO3D,MAAM,WAAW,iBAAiB,KAAK,aAAa,CAAC;AAAA;AAAA;AAAA;AAKnE,IAAM,yBAAyB,CAAC,QAA+B,eAA6C;AAC1G,YAAM,aAAa,OAAO,CAAC,EAAE;AAC7B,YAAM,YAAY,UAAU,KAAK,UAAU;AAC3C,YAAM,OAAQ,WAAW,KAAK,SAAS,IAAK,UAAU,cAAc,WAAW,MAAM,WAAW,MAAM,IAC1D,CAAC,GAAG,MAAM,WAAW,MAAM,EAAE,KAAK,CAAC;AAC/E,UAAI,QAAQ,UAAU,QAAQ,CAAC;AAC/B,YAAM,QAAQ,CAAC,SAAS,SAAS,MAAM,MAAM;AACnB,cAAM,IAAI,MAAM,kBAAkB;AAAA,MACpC,EAAE;AAC1B,UAAI,MAAM,WAAW,GAAG;AACtB,gBAAQ,MAAM,KAAK,MAAM,EAAE,KAAK,CAAC;AAAA,MACnC;AACA,YAAM,SAAS,WAAW,OAAO,IAAI,CAAC,OAAO,MAAM,kBAAkB,OAAO,GAAG,YAAY,MAAM,KAAK,CAAC;AAEvG,YAAM,OAAO,WAAW,KAAK,IAAI,CAAC,KAAK,MAAM,kBAAkB,KAAK,GAAG,YAAY,MAAM,KAAK,CAAC;AAE/F,UAAI,KAAK,WAAW,OAAO,UAAU,KAAK,WAAW,KAAK,QAAQ;AAChE,cAAM,IAAI,MAAM,8DAA8D;AAAA,MAChF;AAEA,UAAI,KAAK,WAAW,WAAW,QAAQ;AACrC,iBAAS,IAAI,GAAG,IAAI,WAAW,QAAQ,EAAE,GAAG;AAC1C,cAAI,CAAC,KAAK,SAAS,CAAC,GAAG;AACrB,mBAAO,OAAO,GAAG,GAAG,CAAC;AACrB,iBAAK,OAAO,GAAG,GAAG,WAAW,CAAC,CAAC;AAC/B,kBAAM,OAAO,GAAG,GAAG,CAAC;AAAA,UACtB;AAAA,QACF;AAAA,MACF;AACA,YAAM,QAAQ,MAAM,IAAI,UAAQ,KAAK,KAAK,IAAI,CAAC;AAE/C,YAAM,QAAQ,CAAC,MAAM,GAAG,UAAU;AAChC,YAAI,OAAO,GAAG;AACZ,gBAAM,YAAY,KAAK,CAAC,IAAI,OAAO,CAAC,KAAK;AACzC,gBAAM,SAAS,OAAO,CAAC;AACvB,gBAAM,WAAW,SAAS,WAAW,MAAM,CAAC;AAC5C,iBAAO,CAAC,IAAI;AACZ,eAAK,CAAC,IAAI;AACV,gBAAM,CAAC,IAAI,CAAC;AAAA,QACd;AAAA,MACF,CAAC;AAED,YAAM,cAAc,WAAW,MAAM,CAAC;AACtC,WAAK,QAAQ,CAAC,MAAM,MAAM;AACxB,oBAAY,IAAI,IAAI,KAAK,MAAM,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,MAAM,IAAI,CAAC;AAAA,MACzE,CAAC;AACD,YAAM,mBAA+B,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ;AAErF,YAAM,SAAS,eAAe,UAAU,OAAO,CAAC,EAAE,UAAU,YAAY,MAAM;AAC9E,YAAM,QAAQ,cAAc,SAAS,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,MAAM;AAC9E,YAAM,aAAa,UAAU,KAAK,WAAW;AAC7C,YAAM,WAA8B;AAAA,QAClC,EAAC,MAAM,cAAc,MAAM,MAAK;AAAA,QAAG,EAAC,MAAM,UAAU,MAAM,OAAO,QAAQ,OAAO,OAAM;AAAA,QACtF,EAAC,MAAM,SAAS,MAAM,OAAO,QAAQ,MAAM,OAAM;AAAA,QAAG,EAAC,MAAM,SAAS,MAAM,OAAO,QAAQ,MAAM,OAAM;AAAA,MACvG;AAEA,YAAM,kBAAoC;AAAA,QACxC,EAAC,uBAAuB,MAAM,WAAU;AAAA,QAAG,EAAC,uBAAuB,MAAM,OAAM;AAAA,QAC/E,EAAC,qBAAsB,MAAM,MAAK;AAAA,QAAG,EAAC,uBAAuB,MAAM,MAAK;AAAA,QACxE,GAAG,2BAA2B,OAAO,CAAC,EAAE,MAAM,WAAW;AAAA,MAC3D;AAEA,YAAM,kBAAkB,CAAC,iBAA+B;AAAA,QAClD,aAAa,iBAAiB,QAAQ,EAAE,iBAAiB,OAAO,MAAM,CAAC;AAAA,UACrE,0BAA0B,OAAO,QAAQ,UAAU,CAAC;AAAA,UACpD,aAAa,UAAU,CAAC;AAAA,YACtB,aAAa,sCAAsC,qBAAqB,CAAC;AAAA,iCACpD,OAAO,gBAAgB,YAAY,CAAC;AAAA;AAAA,YAEzD,OAAO,YAAY,cAAc,MAAM,aAAa,eAAe,CAAC,CAAC;AAAA;AAE/E,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,GAAG,MAAM,MAAM,IAAI,OAAO,MAAM,IAAI,MAAM,MAAM,IAAI,mBAAmB,CAAC,MAAM,EAAC;AAAA,QACnG;AAAA,QACA,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,gBAAgB;AAAA,UAC1B,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,YAAY;AAAA;AAAA,UAAuB,EAAC;AAAA,UACjE;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEO,IAAM,QAAQ,CAAC,SAAyB,eAAsC;AACnF,MAAAA,iBAAe,QAAQ,QAAQ,UAAU;AACzC,YAAM,oBAAoB,gCAAgC,QAAQ,QAAQ,UAAU;AACpF,cAAQ,QAAQ,uBAAuB,QAAQ,QAAQ,iBAAiB,GAAG,EAAC,QAAQ,CAAC,CAAC,EAAC,CAAC;AAAA,IAO1F;AAEO,IAAM,uBAAuB,CAAC,eAAyD;AAC5F,YAAM,SAAS,WAAW;AAC1B,YAAM,OAAO,WAAW;AACxB,YAAM,OAAO,WAAW;AACxB,aAAO,4BAA4B,EAAC,QAAQ,MAAM,KAAI,CAAC;AAAA,IACzD;AAAA;AAAA;;;ACxMA,IAeMC,kBAUA,0BAwHO,SAKA;AAtJb;AAAA;AAAA;AAOA;AAEA;AACA;AAGA;AAEA,IAAMA,mBAAiB,CAAC,WAAwC;AAC9D,UAAI,CAAC,UAAU,OAAO,WAAW,GAAG;AAClC,cAAM,IAAI,MAAM,8BAA8B;AAAA,MAChD;AAAA,IACF;AAMA,IAAM,2BAA2B,CAAC,OAAmB,eAA+C;AAClG,YAAM,QAAQ,MAAM;AACpB,YAAM,aAAa,UAAU,KAAK,KAAK;AACvC,YAAM,KAAK;AACX,UAAI,OAAO,WAAW;AACtB,UAAI,OAAO,GAAG;AACZ,eAAO,MAAM,SAAS;AAAA,MACxB;AACA,UAAI,OAAO,MAAM,SAAS,GAAG;AAC3B,cAAM,IAAI,MAAM,0CAA0C;AAAA,MAC5D;AAEA,YAAM,OAAO,MAAM,IAAI;AACvB,YAAM,OAAO,aAAa;AAC1B,YAAM,aAAa,iBAAiB,IAAI;AACxC,YAAM,aAAa,OAAO;AAE1B,YAAM,YAAY,CAAC,MAAcC,gBAAuB;AACtD,YAAIA,gBAAe,GAAG;AACpB,iBAAO,WAAW,IAAI,OAAO,IAAI,YAAY,IAAI,OAAO,IAAI;AAAA,QAC9D,WAAWA,gBAAe,GAAG;AAC3B,iBAAO,OAAO,IAAI,OAAO,IAAI;AAAA,QAC/B,WAAWA,gBAAe,GAAG;AAC3B,iBAAO,WAAW,IAAI,OAAO,IAAI,QAAQ,IAAI;AAAA,QAC/C;AAEA,eAAO;AAAA,MACT;AACA,YAAM,IAAI,cAAc,KAAK,MAAM,UAAU,MAAM,MAAM,UAAU;AACnE,YAAM,SAAS,eAAe,UAAU,MAAM,UAAU,MAAM,MAAM,UAAU;AAC9E,YAAM,YAAY,EAAE,KAAK;AAEzB,YAAM,gBAAgB,4BAA4B,MAAM,QAAQ,MAAM,QAClE,mBAAmB,SAAS,sBAC5B,mBAAmB,SAAS;AAChC,YAAM,kBAAkB,CAAC,iBAA+B;AAAA,sCACpB,SAAS;AAAA,sCACT,SAAS;AAAA,4CACH,SAAS,KAAK,EAAE;AAAA;AAAA,4DAEA,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA,gEAKL,SAAS;AAAA;AAAA;AAAA;AAAA,QAIjE,aAAa,gBAAgB,cAAc,KAAK,EAAE,iBAAiB,GAAG,MAAM,CAAC;AAAA,QAC7E,aAAa,UAAU,CAAC;AAAA;AAAA;AAAA,qBAGX,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UAMb,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,2BAmBI,SAAS,IAAI,UAAU,mBAAmB,UAAU,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,0BAKtD,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,2BAeR,SAAS,IAAI,UAAU,mBAAmB,UAAU,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAU9E,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,GAAG,UAAU,IAAI,mBAAmB,CAAC,MAAM,EAAC;AAAA,QAChE,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,OAAO,UAAU,MAAM,SAAQ,CAAC;AAAA,UACjD,eAAe,EAAC,GAAG,KAAI;AAAA,UACvB,iBAAiB,CAAC,EAAC,qBAAsB,MAAM,WAAU,CAAC;AAAA,QAC5D;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEO,IAAM,UAAU,CAAC,SAAyB,eAAwC;AACvF,MAAAD,iBAAe,QAAQ,MAAM;AAC7B,cAAQ,QAAQ,yBAAyB,QAAQ,OAAO,CAAC,GAAG,UAAU,CAAC;AAAA,IACzE;AAEO,IAAM,yBAAyB,CAAC,eACnC,4BAA4B,EAAC,MAAM,WAAW,KAAc,CAAC;AAAA;AAAA;;;ACvJjE,IAiBME,kBAMA,iCAWA,0BASA,qBAqBA,wBAuDO,OAOA;AA9Hb;AAAA;AAAA;AAGA;AAEA;AACA;AAGA;AAQA,IAAMA,mBAAiB,CAAC,WAAwC;AAC9D,UAAI,CAAC,UAAU,OAAO,SAAS,GAAG;AAChC,cAAM,IAAI,MAAM,gBAAgB;AAAA,MAClC;AAAA,IACF;AAEA,IAAM,kCACF,CAAC,QAA+B,eAAiD;AAC/E,YAAM,aAAuB,CAAC;AAC9B,UAAI,aAAqB,WAAW;AACpC,UAAI,OAAO,CAAC,EAAE,KAAK,CAAC,IAAI,GAAG;AACzB,eAAO,CAAC,EAAE,iBAAiB,EAAE,QAAQ,OAAK,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC;AACpE,qBAAa,WAAW;AAAA,MAC1B;AACA,aAAO,4BAA4B,EAAC,YAAY,MAAM,WAAW,MAAM,WAAU,CAAC;AAAA,IACpF;AAEJ,IAAM,2BAA2B,CAAC,oBAAoC;AAAA;AAAA,gCAEtC,eAAe;AAAA,kBAC7B,aAAa,+BAA+B,KAAK,eAAe,CAAC;AAAA;AAAA;AAAA;AAAA,aAItE,eAAe;AAAA;AAE5B,IAAM,sBAAsB,CAAC,YAAsC;AACjE,YAAM,kBAAkB,QAAQ;AAChC,YAAM,YAAsB,CAAC;AAC7B,eAAS,IAAI,GAAG,IAAI,iBAAiB,EAAE,GAAG;AACxC,cAAM,gBAAgB,QAAQ,CAAC,EAAE,aAAa,WAAW,mBAAmB;AAC5E,YAAI,oBAAoB,GAAG;AACzB,oBAAU,KAAK,aAAa;AAAA,QAC9B,WAAW,MAAM,GAAG;AAClB,oBAAU,KAAK,wBAAwB,CAAC,QAAQ,aAAa,IAAI;AAAA,QACnE,WAAW,MAAM,kBAAkB,GAAG;AACpC,oBAAU,KAAK,UAAU,aAAa,IAAI;AAAA,QAC5C,OAAO;AACL,oBAAU,KAAK,6BAA6B,CAAC,OAAO,aAAa,IAAI;AAAA,QACvE;AAAA,MACF;AACA,aAAO;AAAA,wDAC+C,QAAQ,CAAC,EAAE,KAAK,OAAO;AAAA,UACrE,UAAU,KAAK,IAAI,CAAC;AAAA;AAAA,IAE9B;AAEA,IAAM,yBAAyB,CAAC,QAA+B,eAA6C;AAC1G,YAAM,aAAa,OAAO,CAAC,EAAE;AAC7B,YAAM,YAAY,UAAU,KAAK,UAAU;AAC3C,YAAM,WAAW,OAAO,CAAC,EAAE;AAC3B,YAAM,OAAO,UAAU,cAAc,WAAW,MAAM,WAAW,MAAM;AACvE,YAAM,UAAU,IAAI,MAAqB,WAAW,UAAU;AAC9D,YAAM,QAAQ,cAAc,SAAS,UAAU,WAAW,MAAM;AAChE,YAAM,kBAAkB,IAAI,MAAc,WAAW,UAAU;AAC/D,YAAM,oBAAkC,CAAC;AACzC,YAAM,eAA2B,CAAC;AAClC,UAAI,cAAc;AAClB,YAAM,kBAAoC,CAAC,EAAC,uBAAuB,MAAM,UAAS,CAAC;AACnF,eAAS,IAAI,GAAG,IAAI,WAAW,YAAY,KAAK;AAC9C,uBAAe,WAAW,WAAW,CAAC;AACtC,wBAAgB,CAAC,IAAI;AACrB,cAAM,cAAc,WAAW,MAAM;AACrC,oBAAY,WAAW,IAAI,IAAI,WAAW,WAAW,CAAC;AACtD,qBAAa,KAAK,WAAW;AAC7B,gBAAQ,CAAC,IAAI,eAAe,SAAS,CAAC,IAAI,UAAU,YAAY,MAAM;AACtE,0BAAkB,KAAK,EAAC,MAAM,aAAa,CAAC,GAAG,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,MAC9E;AACA,sBAAgB;AAAA,QACZ,EAAC,uBAAuB,MAAM,gBAAe;AAAA,QAAG,GAAG,2BAA2B,YAAY,GAAG,YAAY;AAAA,MAAC;AAC9G,YAAM,kBAAkB,CAAC,iBAA+B;AAAA,IAEpD,aAAa,gBAAgB,cAAc,KAAK,EAC3C,gBAAgB,sBAAsB,OAAO,gBAAgB,MAAM,EACnE,iBAAiB,OAAO,GAAG,OAAO,CAAC;AAAA,IAC1C,yBAAyB,gBAAgB,MAAM,CAAC;AAAA,IAChD,oBAAoB,OAAO,CAAC;AAAA;AAAA,IAE5B,aAAa,UAAU,CAAC;AAAA,MACtB,aAAa,sCAAsC,qBAAqB,CAAC;AAAA;AAAA,oBAE3D,MAAM,gBAAgB,YAAY,CAAC;AAAA,kBACrC,MAAM,WAAW,WAAW,IAAI,CAAC;AAAA;AAAA;AAAA,iBAGlC,aAAa,+BAA+B,sBAAsB,gBAAgB,MAAM,CAAC;AAAA,QAClG,MAAM,WAAW,WAAW,MAAM,OAAO,CAAC;AAAA;AAAA;AAAA;AAIhD,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,WAAW,UAAU,mBAAmB,CAAC,MAAM,EAAC;AAAA,QACpE;AAAA,QACA,YAAY,OAAO;AAAA,UACjB,SAAS;AAAA,UACT,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,YAAY;AAAA;AAAA,UAAuB,EAAC;AAAA,UACjE;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEO,IAAM,QAAQ,CAAC,SAAyB,eAAsC;AACnF,MAAAA,iBAAe,QAAQ,MAAM;AAC7B,YAAM,oBACF,QAAQ,OAAO,WAAW,IAAI,aAAa,gCAAgC,QAAQ,QAAQ,UAAU;AACzG,cAAQ,QAAQ,uBAAuB,QAAQ,QAAQ,iBAAiB,GAAG,EAAC,QAAQ,CAAC,CAAC,EAAC,CAAC;AAAA,IAC1F;AAEO,IAAM,uBAAuB,CAAC,eAAyD;AAC5F,YAAM,OAAO,WAAW;AACxB,YAAM,aAAuB,WAAW;AACxC,YAAM,aAAa,WAAW,aAAuB,IAAI,WAAW,SAAS,WAAW;AACxF,UAAI,eAAe,WAAW,QAAQ;AACpC,cAAM,IAAI,MAAM,+CAA+C;AAAA,MACjE;AACA,aAAO,4BAA4B,EAAC,MAAM,YAAY,WAAU,CAAC;AAAA,IACnE;AAAA;AAAA;;;ACtIA,IAUM,YAIAC,kBAyBAC,iBAUO,uBAuCA;AAxFb;AAAA;AAAA;AAGA;AAEA;AAGA;AAEA,IAAM,aAAa,CAAC,sBAChB,MAAM,KAAK,kBAAkB,iBAAiB,GAAG,MAAM;AAG3D,IAAMD,mBAAiB,CAAC,WAAwC;AAC9D,UAAI,CAAC,UAAU,OAAO,WAAW,GAAG;AAClC,cAAM,IAAI,MAAM,yBAAyB;AAAA,MAC3C;AAEA,UAAI,OAAO,CAAC,EAAE,8BAA+B,OAAO,CAAC,EAAE,8BACnD,OAAO,CAAC,EAAE,8BAA8B;AAC1C,cAAM,IAAI,MAAM,uDAAuD;AAAA,MACzE;AAEA,UAAI,OAAO,CAAC,EAAE,4BAA6B;AACzC,cAAM,IAAI,MAAM,mDAAmD;AAAA,MACrE;AAEA,UAAI,OAAO,CAAC,EAAE,KAAK,WAAW,GAAG;AAC/B,cAAM,IAAI,MAAM,oCAAoC;AAAA,MACtD;AAEA,YAAM,UAA6B,WAAW,OAAO,CAAC,CAAC;AAEvD,UAAI,QAAQ,WAAW,OAAO,CAAC,EAAE,KAAK,QAAQ;AAC5C,cAAM,IAAI,MAAM,uFAAuF;AAAA,MACzG;AAAA,IACF;AAEA,IAAMC,kBAAiB,CAAC,YAA+B,YAAkD;AACvG,YAAM,cAAwB,CAAC;AAE/B,eAAS,IAAI,GAAG,IAAI,WAAW,QAAQ,EAAE,GAAG;AAC1C,oBAAY,KAAK,WAAW,CAAC,IAAI,QAAQ,CAAC,CAAC;AAAA,MAC7C;AAEA,aAAO;AAAA,IACT;AAEO,IAAM,wBAAwB,CAAC,WAA+C;AACnF,YAAM,aAAa,OAAO,CAAC,EAAE;AAC7B,YAAM,UAA6B,WAAW,OAAO,CAAC,CAAC;AACvD,YAAM,cAAcA,gBAAe,YAAY,OAAO;AACtD,YAAM,aAAa,UAAU,KAAK,WAAW;AAE7C,YAAM,WAAW,OAAO,CAAC,EAAE;AAC3B,YAAM,QAAQ,cAAc,SAAS,UAAU,WAAW,MAAM;AAChE,YAAM,SAAS,eAAe,UAAU,UAAU,YAAY,MAAM;AAEpE,YAAM,kBAAkB,CAAC,iBAA+B;AAAA,2BAC/B,MAAM,QAAQ,GAAG,UAAU,CAAC;AAAA,QAC/C,aAAa,gBAAgB,eAAe,KAAK,EAAE,iBAAiB,OAAO,MAAM,CAAC;AAAA,QAClF,aAAa,UAAU,CAAC;AAAA,QACxB,aAAa,sCAAsC,sBAAsB,CAAC;AAAA,6BACrD,OAAO,gBAAgB,YAAY,CAAC;AAAA,2BACtC,MAAM,KAAK,OAAO;AAAA,4BACjB,WAAW,MAAM;AAAA,4BACjB,MAAM,WAAW,wBAAwB,GAAG,CAAC;AAAA,gCACzC,OAAO,WAAW,kBAAkB,GAAG,CAAC;AAAA;AAAA,UAE9D,MAAM,WAAW,iBAAiB,KAAK,iBAAiB,CAAC;AAAA;AAAA,QAE3D,OAAO,YAAY,cAAc,MAAM,aAAa,eAAe,CAAC,CAAC;AAAA;AAG3E,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,MAAM,GAAG,OAAO,IAAI,mBAAmB,CAAC,MAAM,EAAC;AAAA,QAC7D,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,OAAO,CAAC,EAAE,SAAQ,CAAC;AAAA,UAC3D,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa;AAAA;AAAA,UAAuB,EAAC;AAAA,UAClE,iBACI,CAAC,EAAC,uBAAuB,MAAM,WAAU,GAAG,GAAG,2BAA2B,OAAO,CAAC,EAAE,MAAM,WAAW,CAAC;AAAA,QAC5G;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEO,IAAM,OAAO,CAAC,YAAkC;AACrD,MAAAD,iBAAe,QAAQ,MAAM;AAC7B,cAAQ,QAAQ,sBAAsB,QAAQ,MAAM,GAAG,EAAC,QAAQ,CAAC,CAAC,EAAC,CAAC;AAAA,IACtE;AAAA;AAAA;;;AC3FA,IAUM,4BA4DA,0BAoCO;AA1Gb;AAAA;AAAA;AAGA;AAEA;AAGA;AAEA,IAAM,6BACF,CAAC,cAA4B,QAA+B,YAA+B,aAC1F,eAAuB;AACtB,YAAM,SAAS,eAAe,eAAe,YAAY,WAAW,QAAQ,CAAC;AAC7E,YAAM,IAAI,cAAc,UAAU,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,QAAQ,CAAC;AAC9E,YAAM,IAAI,cAAc,UAAU,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,QAAQ,CAAC;AAC9E,YAAM,IAAI,cAAc,UAAU,OAAO,CAAC,EAAE,UAAU,OAAO,CAAC,EAAE,KAAK,QAAQ,CAAC;AAE9E,UAAI;AACJ,YAAM,aAAa,CAACE,IAAWC,IAAWC,OAAc,UAAUD,EAAC,KAAKD,EAAC,KAAKE,EAAC;AAC/E,UAAI,CAAC,aAAa;AAChB,qBAAa,OAAO;AAAA,UAChB;AAAA,UACA,WAAW,EAAE,YAAY,YAAY,GAAG,EAAE,YAAY,YAAY,GAAG,EAAE,YAAY,YAAY,CAAC;AAAA,QAAC;AAAA,MACvG,OAAO;AACL,cAAM,mBAAmB,CAAC,QAAgB,GAAW,WAAW,OAAO;AACrE,gBAAM,cAAc,iBAAiB,CAAC,gBAAgB,CAAC;AACvD,gBAAM,cAAc,iBAAiB,CAAC,gBAAgB,CAAC;AAEvD,gBAAM,cAAc,sBAAsB,CAAC,6BAA6B,CAAC;AACzE,iBAAO;AAAA,gCACe,CAAC,MAAM,OAAO,gBAAgB,qBAAqB,CAAC,GAAG,CAAC;AAAA,0BAC9D,CAAC,MAAM,EAAE,2BAA2B,iBAAiB,CAAC,IAAI,MAAM,CAAC;AAAA,0BACjE,CAAC,MAAM,EAAE,2BAA2B,iBAAiB,CAAC,IAAI,MAAM,CAAC;AAAA,0BACjE,CAAC,MAAM,EAAE,2BAA2B,iBAAiB,CAAC,IAAI,MAAM,CAAC;AAAA,yBAClE,CAAC,cAAc,CAAC;AAAA,yBAChB,CAAC,cAAc,CAAC;AAAA,yBAChB,CAAC,cAAc,CAAC;AAAA,6BACZ,CAAC,cAAc,CAAC;AAAA,6BAChB,CAAC,cAAc,CAAC;AAAA,6BAChB,CAAC,cAAc,CAAC;AAAA,cAC/B,MAAM,IAAI,CAAC,OAAO,QAAQ,IAAI,WAAW,aAAa,aAAa,WAAW,CAAC;AAAA;AAAA,QAErF;AACA,YAAI,6BAA8B;AAChC,uBAAa;AAAA;AAAA,cAET,iBAAiB,QAAQ,GAAG,KAAK,CAAC;AAAA,cAClC,iBAAiB,QAAQ,GAAG,KAAK,CAAC;AAAA,cAClC,iBAAiB,QAAQ,GAAG,KAAK,CAAC;AAAA,cAClC,iBAAiB,QAAQ,GAAG,KAAK,CAAC;AAAA;AAAA,QAExC,OAAO;AACL,uBAAa;AAAA,cACT,iBAAiB,2BAA2B,CAAC,CAAC;AAAA,cAC9C,iBAAiB,2BAA2B,CAAC,CAAC;AAAA,cAC9C,iBAAiB,2BAA2B,CAAC,CAAC;AAAA,cAC9C,iBAAiB,2BAA2B,CAAC,CAAC;AAAA;AAAA,QAEpD;AAAA,MACF;AAEA,aAAO;AAAA,UACH,aAAa,gBAAgB,YAAY,KAAK,EAAE,iBAAiB,GAAG,GAAG,GAAG,MAAM,CAAC;AAAA,UACjF,aAAa,UAAU,CAAC;AAAA,UACxB,aAAa,sCAAsC,mBAAmB,CAAC;AAAA,UACvE,UAAU;AAAA;AAAA,IAEhB;AAEJ,IAAM,2BAA2B,CAAC,WAA+C;AAC/E,YAAM,QAAQ,OAAO,CAAC,EAAE;AACxB,YAAM,QAAQ,OAAO,CAAC,EAAE;AACxB,YAAM,QAAQ,OAAO,CAAC,EAAE;AACxB,YAAM,iBAAiB,OAAO,CAAC,EAAE;AAEjC,YAAM,cAAc,EAAE,UAAU,SAAS,OAAO,KAAK,KAAK,UAAU,SAAS,OAAO,KAAK;AACzF,UAAI,cAAc;AAClB,UAAI,aAAa,UAAU,KAAK,KAAK;AAGrC,UAAI,aAAa;AACf,cAAM,kBAAkB,cAAc,UAAU,cAAc,UAAU,OAAO,OAAO,KAAK,GAAI,OAAO,KAAK;AAC3G,YAAI,CAAC,iBAAiB;AACpB,gBAAM,IAAI,MAAM,6CAA8C;AAAA,QAChE;AACA,sBAAc;AACd,qBAAa,UAAU,KAAK,WAAW;AAAA,MACzC;AAEA,YAAM,UAAU,KAAK,KAAK,aAAa,CAAC;AAExC,aAAO;AAAA,QACL,MAAM;AAAA,QACN,aAAa,EAAC,mBAAmB,CAAC,QAAQ,QAAQ,MAAM,EAAC;AAAA,QACzD,iBAAiB,CAAC,iBACd,2BAA2B,cAAc,QAAQ,aAAa,aAAa,cAAc;AAAA,QAC7F,YAAY,OAAO;AAAA,UACjB,SAAS,CAAC,EAAC,MAAM,aAAa,UAAU,eAAc,CAAC;AAAA,UACvD,eAAe,EAAC,GAAG,KAAK;AAAA,YAAK,aAAa,KAA0B;AAAA;AAAA,UAAgB,EAAC;AAAA,UACrF,iBACI,CAAC,EAAC,uBAAuB,MAAM,QAAO,GAAG,GAAG,2BAA2B,OAAO,OAAO,OAAO,WAAW,CAAC;AAAA,QAC9G;AAAA,MACF;AAAA,IACF;AAEO,IAAM,QAAQ,CAAC,YAAkC;AACtD,cAAQ,QAAQ,yBAAyB,QAAQ,MAAM,CAAC;AAAA,IAC1D;AAAA;AAAA;;;AC5GA,IA6Ca;AA7Cb;AAAA;AAAA;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAOO,IAAM,0BAA+D,oBAAI,IAAI;AAAA,MAClF,CAAC,OAAO,CAAU,GAAG,CAAC;AAAA,MACtB,CAAC,QAAQ,CAAU,IAAI,CAAC;AAAA,MACxB,CAAC,SAAS,CAAU,KAAK,CAAC;AAAA,MAC1B,CAAC,OAAO,CAAW,GAAG,CAAC;AAAA,MACvB,CAAC,UAAU,CAAC,QAAQ,wBAAwB,CAAC;AAAA,MAC7C,CAAC,UAAU,CAAC,QAAQ,wBAAwB,CAAC;AAAA,MAC7C,CAAC,QAAQ,CAAU,IAAI,CAAC;AAAA,MACxB,CAAC,SAAS,CAAU,KAAK,CAAC;AAAA,MAC1B,CAAC,QAAQ,CAAU,IAAI,CAAC;AAAA,MACxB,CAAC,SAAS,CAAU,KAAK,CAAC;AAAA,MAC1B,CAAC,aAAa,CAAC,SAAS,CAAC;AAAA;AAAA,MAEzB,CAAC,eAAe,CAAM,aAAkB,0BAA0B,CAAC;AAAA,MACnE,CAAC,sBAAsB,CAAC,SAAS,CAAC;AAAA,MAClC,CAAC,WAAW,CAAC,OAAO,CAAC;AAAA,MACrB,CAAC,iBAAiB,CAAC,aAAa,CAAC;AAAA,MACjC,CAAC,QAAQ,CAAU,MAAe,mBAAmB,CAAC;AAAA,MACtD,CAAC,QAAQ,CAAU,IAAI,CAAC;AAAA,MACxB,CAAC,QAAQ,CAAU,IAAI,CAAC;AAAA,MACxB,CAAC,UAAU,CAAC,QAAQ,qBAAqB,CAAC;AAAA,MAC1C,CAAC,QAAQ,CAAC,MAAM,mBAAmB,CAAC;AAAA,MACpC,CAAC,iBAAiB,CAAC,eAAe,4BAA4B,CAAC;AAAA,MAC/D,CAAC,OAAO,CAAU,GAAG,CAAC;AAAA,MACtB,CAAC,QAAQ,CAAU,IAAI,CAAC;AAAA,MACxB,CAAC,UAAU,CAAC,QAAQ,qBAAqB,CAAC;AAAA,MAC1C,CAAC,gBAAgB,CAAC,cAAc,2BAA2B,CAAC;AAAA,MAC5D,CAAC,OAAO,CAAW,GAAG,CAAC;AAAA,MACvB,CAAC,UAAU,CAAC,QAAQ,qBAAqB,CAAC;AAAA,MAC1C,CAAC,OAAO,CAAU,KAAc,oBAAoB,CAAC;AAAA,MACrD,CAAC,SAAS,CAAW,KAAK,CAAC;AAAA,MAC3B,CAAC,OAAO,CAAU,GAAG,CAAC;AAAA,MACtB,CAAC,OAAO,CAAU,GAAG,CAAC;AAAA,MACtB,CAAC,UAAU,CAAC,MAAM,CAAC;AAAA,MACnB,CAAC,YAAY,CAACC,SAAQ,CAAC;AAAA,MACvB,CAAC,SAAS,CAAU,KAAK,CAAC;AAAA,MAC1B,CAAC,aAAa,CAAC,MAAM,mBAAmB,CAAC;AAAA,MACzC,CAAC,UAAU,CAAC,QAAQ,qBAAqB,CAAC;AAAA,MAC1C,CAAC,kBAAkB,CAAC,gBAAgB,6BAA6B,CAAC;AAAA,MAClE,CAAC,QAAQ,CAAU,IAAI,CAAC;AAAA,MACxB,CAAC,QAAQ,CAAC,MAAM,mBAAmB,CAAC;AAAA,MACpC,CAAC,qBAAqB,CAAM,mBAAwB,gCAAgC,CAAC;AAAA,MACrF,CAAC,iBAAiB,CAAM,eAAoB,4BAA4B,CAAC;AAAA,MACzE,CAAC,WAAW,CAAW,OAAO,CAAC;AAAA,MAC/B,CAAC,kBAAkB,CAAW,cAAc,CAAC;AAAA,MAC7C,CAAC,eAAe,CAAU,aAAsB,0BAA0B,CAAC;AAAA,MAC3E,CAAC,yBAAyB,CAAC,YAAY,CAAC;AAAA,MACxC,CAAC,sBAAsB,CAAC,SAAS,CAAC;AAAA,MAClC,CAAC,aAAa,CAAU,WAAoB,oBAAoB,CAAC;AAAA,MACjE,CAAC,QAAQ,CAAW,IAAI,CAAC;AAAA,MACzB,CAAC,eAAe,CAAW,WAAW,CAAC;AAAA,MACvC,CAAC,OAAO,CAAU,GAAG,CAAC;AAAA,MACtB,CAAC,UAAU,CAAC,MAAM,CAAC;AAAA,MACnB,CAAC,eAAe,CAAC,aAAa,0BAA0B,CAAC;AAAA;AAAA,MAEzD,CAAC,WAAW,CAAM,SAAc,sBAAsB,CAAC;AAAA,MACvD,CAAC,OAAO,CAAW,GAAG,CAAC;AAAA,MACvB,CAAC,sBAAsB,CAAC,oBAAoB,iCAAiC,CAAC;AAAA,MAC9E,CAAC,OAAO,CAAU,GAAG,CAAC;AAAA,MACtB,CAAC,OAAO,CAAU,GAAG,CAAC;AAAA,MACtB,CAAC,OAAO,CAAC,GAAG,CAAC;AAAA,MACb,CAAC,OAAO,CAAW,GAAG,CAAC;AAAA,MACvB,CAAC,SAAS,CAAC,KAAK,CAAC;AAAA,MACjB,CAAC,cAAc,CAAU,UAAU,CAAC;AAAA,MACpC,CAAC,aAAa,CAAC,SAAS,CAAC;AAAA,MACzB,CAAC,cAAc,CAAC,UAAU,CAAC;AAAA,MAC3B,CAAC,aAAa,CAAC,SAAS,CAAC;AAAA,MACzB,CAAC,aAAa,CAAC,SAAS,CAAC;AAAA,MACzB,CAAC,cAAc,CAAC,UAAU,CAAC;AAAA,MAC3B,CAAC,YAAY,CAAC,QAAQ,CAAC;AAAA,MACvB,CAAC,YAAY,CAAC,QAAQ,CAAC;AAAA,MACvB,CAAC,gBAAgB,CAAC,YAAY,CAAC;AAAA,MAC/B,CAAC,mBAAmB,CAAC,eAAe,CAAC;AAAA,MACrC,CAAC,mBAAmB,CAAC,eAAe,CAAC;AAAA,MACrC,CAAC,QAAQ,CAAU,IAAI,CAAC;AAAA,MACxB,CAAC,UAAU,CAAC,QAAQ,qBAAqB,CAAC;AAAA,MAC1C,CAAC,mBAAmB,CAAC,eAAe,CAAC;AAAA,MACrC,CAAC,WAAW,CAAU,OAAO,CAAC;AAAA,MAC9B,CAAC,OAAO,CAAU,GAAG,CAAC;AAAA,MACtB,CAAC,QAAQ,CAAU,IAAI,CAAC;AAAA,MACxB,CAAC,SAAS,CAAC,OAAO,oBAAoB,CAAC;AAAA,MACvC,CAAC,0BAA0B,CAAC,aAAa,CAAC;AAAA,MAC1C,CAAC,SAAS,CAAC,OAAO,oBAAoB,CAAC;AAAA,MACvC,CAAC,QAAQ,CAAU,IAAI,CAAC;AAAA,MACxB,CAAC,WAAW,CAAC,SAAS,sBAAsB,CAAC;AAAA,MAC7C,CAAC,OAAO,CAAW,GAAG,CAAC;AAAA,MACvB,CAAC,OAAO,CAAU,GAAG,CAAC;AAAA,MACtB,CAAC,QAAQ,CAAU,IAAI,CAAC;AAAA,MACxB,CAAC,mBAAmB,CAAU,iBAA0B,oBAAoB,CAAC;AAAA,MAC7E,CAAC,QAAQ,CAAC,IAAI,CAAC;AAAA,MACf,CAAC,aAAa,CAAC,WAAW,wBAAwB,CAAC;AAAA,MACnD,CAAC,SAAS,CAAC,KAAK,CAAC;AAAA,IACnB,CAAC;AAAA;AAAA;;;ACzID,IAoBa;AApBb;AAAA;AAAA;AAGA;AAGA;AAEA;AAYO,IAAM,iBAAN,MAAqB;AAAA,MAI1B,YAAoB,SAAwB;AAAxB;AAClB,aAAK,OAAO,oBAAI,IAAI;AACpB,aAAK,kBAAkB;AAAA,MACzB;AAAA,MACA,YAAY,KAAkC;AAC5C,eAAO,KAAK,KAAK,IAAI,GAAG;AAAA,MAC1B;AAAA,MACA,YAAY,KAAc,UAA0B;AAClD,aAAK,KAAK,IAAI,KAAK,QAAQ;AAAA,MAC7B;AAAA,MACA,IAAI,eAAyB,QAAmB,SAAoB,eAChE,sBAA0D;AAC5D,yBAAiB,cAAc,YAAY,IAAI;AAC/C,cAAM,SAAS,KAAK,QAAQ;AAC5B,cAAM,qBAAqB,KAAK,QAAQ,sBAAsB;AAC9D,aAAK,QAAQ,eAAe,KAAK,QAAQ,wBAAwB,CAAC;AAClE,cAAM,UAAU,CAAC;AACjB,mBAAW,SAAS,QAAQ;AAC1B,kBAAQ,KAAK,EAAC,SAAS,QAAQ,QAAQ,UAAU,EAAC,QAAQ,MAAM,OAAM,EAAC,CAAC;AAAA,QAC1E;AACA,mBAAW,UAAU,SAAS;AAC5B,kBAAQ,KAAK,EAAC,SAAS,QAAQ,QAAQ,UAAU,EAAC,QAAQ,OAAO,OAAM,EAAC,CAAC;AAAA,QAC3E;AACA,YAAI,sBAAsB;AACxB,kBAAQ,KAAK,EAAC,SAAS,QAAQ,QAAQ,UAAU,qBAAoB,CAAC;AAAA,QACxE;AACA,cAAM,YAAY,OAAO;AAAA,UACrB,EAAC,QAAQ,cAAc,gBAAgB,mBAAmB,CAAC,GAAG,SAAS,OAAO,cAAc,YAAY,KAAI;AAAA,QAAC;AAEjH,YAAI,KAAK,QAAQ,kBAAkB,aAAa;AAC9C,gBAAM,cAAc;AAAA,YAClB,UAAU,KAAK,QAAQ;AAAA,YACvB,iBAAiB,cAAc;AAAA,YAC/B;AAAA,YACA;AAAA,UACF;AACA,gBAAM,qBAAqB,KAAK,QAAQ,oBAAoB,IAAI,KAAK,QAAQ,gBAAiB;AAC9F,6BAAoB,KAAK,WAAW;AAAA,QACtC;AAEA,2BAAmB,YAAY,cAAc,eAAe;AAC5D,2BAAmB,aAAa,GAAG,SAAS;AAC5C,2BAAmB,mBAAmB,GAAG,aAAa;AACtD,aAAK,QAAQ,eAAe,KAAK,QAAQ,wBAAwB,IAAI,CAAC;AACtE,aAAK,QAAQ;AAEb,YAAI,KAAK,QAAQ,yBAAyB,KAAK,QAAQ,qBACnD,KAAK,QAAQ,cAAc,aAAa;AAC1C,eAAK,QAAQ,eAAe;AAAA,QAC9B;AACA,YAAI,KAAK,QAAQ,yBAAyB,KAAK,QAAQ,mBAAmB;AACxE,eAAK,QAAQ,MAAM;AAAA,QACrB;AACA,uBAAe,cAAc,YAAY,IAAI;AAAA,MAC/C;AAAA,MACA,UAAgB;AAAA,MAEhB;AAAA,MACA,MAAM,aAA0B,6BAAiE;AAC/F,yBAAiB,YAAY,IAAI;AACjC,cAAM,SAAS,KAAK,QAAQ;AAC5B,cAAM,aAAuB,CAAC;AAC9B,YAAI,OAAO,SAAS,IAAI,YAAY,GAAG;AACrC,qBAAW,KAAK,aAAa;AAAA,QAC/B;AACA,cAAM,eAAe,mBAAmB,6BAA6B,KAAK,QAAQ,OAAO,MAAM;AAC/F,cAAM,WAAW,YAAY,gBAAgB,YAAY;AACzD,cAAM,OAAO,GAAG,WAAW,KAAK,IAAI,CAAC;AAAA,EAAK,aAAa,yBAAyB;AAAA,EAAK,QAAQ;AAC7F,cAAM,eAAe,OAAO,mBAAmB,EAAC,MAAM,OAAO,YAAY,KAAI,CAAC;AAC9E,kBAAU,WAAW,MAAM,YAAY,YAAY,IAAI,iBAAiB,IAAI,EAAE;AAE9E,cAAM,kBAAkB,OAAO;AAAA,UAC3B,EAAC,SAAS,EAAC,QAAQ,cAAc,YAAY,OAAM,GAAG,QAAQ,QAAQ,OAAO,YAAY,KAAI;AAAA,QAAC;AAElG,uBAAe,YAAY,IAAI;AAC/B,eAAO,EAAC,aAAa,iBAAiB,sBAAsB,aAAa,cAAa;AAAA,MACxF;AAAA,MAEA,2BAA2B,eACE;AAC3B,cAAM,IAAI,OAAO,kBAAkB,WAAW,gBAAgB,cAAc;AAC5E,cAAM,IAAI,OAAO,kBAAkB,WAAW,IAAK,cAAc,KAAK;AACtE,cAAM,IAAI,OAAO,kBAAkB,WAAW,IAAK,cAAc,KAAK;AACtE,cAAM,oBAAoB,KAAK,QAAQ,OAAO,OAAO;AACrD,YAAI,KAAK,qBAAqB,KAAK,qBAAqB,KAAK,mBAAmB;AAC9E,iBAAO,CAAC,GAAG,GAAG,CAAC;AAAA,QACjB;AACA,cAAM,OAAO,IAAI,IAAI;AACrB,YAAI,kBAAkB,KAAK,KAAK,KAAK,KAAK,IAAI,CAAC;AAC/C,YAAI,kBAAkB,mBAAmB;AACvC,4BAAkB,KAAK,KAAK,KAAK,KAAK,IAAI,CAAC;AAC3C,cAAI,kBAAkB,mBAAmB;AACvC,kBAAM,IAAI,MAAM,6CAA6C;AAAA,UAC/D;AACA,iBAAO,CAAC,iBAAiB,iBAAiB,eAAe;AAAA,QAC3D,OAAO;AACL,iBAAO,CAAC,iBAAiB,iBAAiB,CAAC;AAAA,QAC7C;AAAA,MACF;AAAA,IACF;AAAA;AAAA;;;AC3HA,IAmCM,wCA4CA,yBAiBA,iBAwBO;AAxHb;AAAA;AAAA;AAGA;AAEA;AAEA;AACA;AACA;AACA;AACA;AAwBA,IAAM,yCACF,CAAC,cAAqC,sBAA2E;AAC/G,UAAI,kBAAkB,WAAW,aAAa,QAAQ;AACpD,cAAM,IAAI,MAAM,4BAA4B,kBAAkB,MAAM,wCAChE,aAAa,MAAM,GAAG;AAAA,MAC5B;AAEA,YAAM,aAAuB,CAAC;AAC9B,eAAS,IAAI,GAAG,IAAI,aAAa,QAAQ,EAAE,GAAG;AAC5C,cAAM,OAAO,aAAa,CAAC,EAAE;AAC7B,gBAAQ,kBAAkB,CAAC,GAAG;AAAA,UAC5B,KAAK,QAAQ;AACX,uBAAW,KAAK,EAAE;AAClB;AAAA,UACF;AAAA,UACA,KAAK,QAAQ;AACX,uBAAW,KAAK,GAAG,IAAI,EAAE;AACzB;AAAA,UACF;AAAA,UACA,KAAK,QAAQ;AACX,kBAAM,OAAO,aAAa,CAAC,EAAE,KAAK;AAClC,uBAAW,KAAK,GAAG,IAAI,IAAI,IAAI,EAAE;AACjC;AAAA,UACF;AAAA,UACA,KAAK,QAAQ;AACX,kBAAM,OAAO,aAAa,CAAC,EAAE,KAAK,KAAK,GAAG;AAC1C,uBAAW,KAAK,GAAG,IAAI,IAAI,IAAI,EAAE;AACjC;AAAA,UACF;AAAA,UACA;AACE,kBAAM,IAAI,MAAM,iCAAiC,kBAAkB,CAAC,CAAC,EAAE;AAAA,QAC3E;AAAA,MACF;AAEA,aAAO,WAAW,KAAK,GAAG;AAAA,IAC5B;AASJ,IAAM,0BACF,CAAC,aAA0B,cAAqC,yBAA0C;AAGxG,UAAI,MAAM,YAAY;AACtB,UAAI,YAAY,aAAa,MAAM;AACjC,eAAO,MAAM,YAAY,YAAY,OAAO;AAAA,MAC9C;AACA,aAAO,MAAM,uBACT,IACO;AAAA,QACI;AAAA,QACA,YAAY,aAAa,qBACrB,IAAI,MAAwC,aAAa,MAAM,EAAE,KAAK,MAAM;AAAA,MAAC,CAAC;AACjG,aAAO;AAAA,IACT;AAEJ,IAAM,kBAAN,MAA6C;AAAA,MAI3C,YAAY,aAA6B;AACvC,YAAI,aAAa;AACf,eAAK,eAAe,YAAY;AAChC,eAAK,SAAS,YAAY;AAAA,QAC5B;AAAA,MACF;AAAA,MAEA,eAAe,cAAwC;AACrD,eAAO,KAAK,iBAAiB;AAAA,MAC/B;AAAA,MAEA,SAAS,QAA4B;AACnC,eAAO,KAAK,WAAW;AAAA,MACzB;AAAA,IACF;AAMO,IAAM,gBAAN,MAAoB;AAAA,MAApB;AAkBL;AAAA;AAAA;AAAA;AAAA;AAAA,gCAAgC;AAOhC;AAAA;AAAA;AAAA;AAAA;AAAA,+BAA+B;AAgC/B,aAAQ,iBAAyC;AACjD,aAAQ,qBAAiD;AACzD,iCAAoB;AACpB,qCAAwB;AAGxB;AAAA,aAAQ,iBAAsC,CAAC;AAE/C;AAAA,aAAQ,iBAAsD,oBAAI,IAAI;AAOtE,6BAA8B;AAI9B;AAAA;AAAA;AAAA,mCAAkD,oBAAI,IAAI;AAK1D;AAAA;AAAA;AAAA,aAAQ,yBAA2D,oBAAI,IAAI;AAK3E;AAAA;AAAA;AAAA,0CAA4E,oBAAI,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA,MA7CpF,IAAI,0BAAoD;AACtD,YAAI,KAAK,oBAAoB,MAAM;AACjC,gBAAM,IAAI,MAAM,yEAAyE;AAAA,QAC3F;AAEA,YAAI,OAAO,KAAK,iBAAiB,IAAI,KAAK,eAAe;AACzD,YAAI,CAAC,MAAM;AACT,iBAAO,CAAC;AACR,eAAK,iBAAiB,IAAI,KAAK,iBAAiB,IAAI;AAAA,QACtD;AAEA,eAAO;AAAA,MACT;AAAA,MAmCA,MAAM,WAAWC,MAAU,SAAoC;AAC7D,aAAK,MAAMA;AACX,cAAM,mBAAqC,CAAC;AAC5C,cAAM,mBAAwC;AAAA,UAC5C,gBAAgB;AAAA,YACd,gCAAgC,QAAQ,OAAO;AAAA,YAC/C,kCAAkC,QAAQ,OAAO;AAAA,YACjD,6BAA6B,QAAQ,OAAO;AAAA,YAC5C,eAAe,QAAQ,OAAO;AAAA,YAC9B,mCAAmC,QAAQ,OAAO;AAAA,YAClD,0BAA0B,QAAQ,OAAO;AAAA,YACzC,0BAA0B,QAAQ,OAAO;AAAA,YACzC,0BAA0B,QAAQ,OAAO;AAAA,UAC3C;AAAA,UACA;AAAA,QACF;AAEA,YAAI,QAAQ,SAAS,IAAI,qDAAqD,GAAG;AAC/E,2BAAiB,KAAK,qDAAuE;AAAA,QAC/F,WAAW,QAAQ,SAAS,IAAI,iBAAiB,GAAG;AAClD,2BAAiB,KAAK,iBAAiB;AAAA,QACzC;AACA,YAAI,QAAQ,SAAS,IAAI,YAAY,GAAG;AACtC,2BAAiB,KAAK,YAAY;AAAA,QACpC;AAEA,aAAK,SAAS,MAAM,QAAQ,cAAc,gBAAgB;AAC1D,aAAK,cAAc,IAAI,gBAAgB,MAAM,QAAQ,mBAAmB,CAAC;AACzE,aAAK,iBAAiB,qBAAqB,IAAI;AAC/C,aAAK,iBAAiB,IAAI,eAAe,IAAI;AAC7C,aAAK,UAAU,oBAAI,IAAI;AACvB,aAAK,uBAAuB,oBAAI,IAAI;AACpC,aAAK,mBAAmB,oBAAI,IAAI;AAGhC,wBAAgBA,KAAI,UAAW,CAAC,CAACA,KAAI,KAAK;AAI1C,aAAK,OAAO,oBAAoB,QAAM;AACpC,cAAI,GAAG,iBAAiB,oBAAoB;AAE1C,oBAAQ,MAAM,mDAAmD,GAAG,MAAM,OAAO,EAAE;AAAA,UACrF;AAAA,QACF;AAEA,eAAO;AAAA,UACH,KAAK,IAAI;AAAA,UAAQ;AAAA,UAAU,EAAC,OAAO,KAAK,QAAQ,UAAU,OAAO,YAAY,MAAM,cAAc,MAAK;AAAA,QAAC;AAC3G,eAAO;AAAA,UACH,KAAK,IAAI;AAAA,UAAQ;AAAA,UAAW,EAAC,OAAO,SAAS,UAAU,OAAO,YAAY,MAAM,cAAc,MAAK;AAAA,QAAC;AAGxG,aAAK,aAAa;AAAA,MACpB;AAAA,MAEA,UAAgB;AACd,YAAI,OAAO,KAAK,aAAa,aAAa;AACxC,eAAK,SAAS,QAAQ;AAAA,QACxB;AACA,aAAK,eAAe,QAAQ;AAAA,MAC9B;AAAA,MAEA,oBAAuC;AACrC,YAAI,CAAC,KAAK,gBAAgB;AACxB,eAAK,iBAAiB,KAAK,OAAO,qBAAqB;AAAA,QACzD;AACA,eAAO,KAAK;AAAA,MACd;AAAA,MAEA,wBAA+C;AAC7C,YAAI,CAAC,KAAK,oBAAoB;AAC5B,gBAAM,iBAAiB,KAAK,kBAAkB;AAC9C,gBAAM,wBAAkD,CAAC;AAEzD,cAAI,KAAK,cAAc,aAAa;AAClC,kCAAsB,kBAAkB;AAAA,cACtC,UAAU,KAAK;AAAA,cACf,2BAA2B,KAAK,wBAAwB;AAAA,cACxD,qBAAqB,KAAK,wBAAwB,IAAI;AAAA,YACxD;AAAA,UACF;AAEA,eAAK,qBAAqB,eAAe,iBAAiB,qBAAqB;AAAA,QACjF;AACA,eAAO,KAAK;AAAA,MACd;AAAA,MAEA,iBAAuB;AACrB,YAAI,KAAK,oBAAoB;AAC3B,eAAK,mBAAmB,IAAI;AAC5B,eAAK,qBAAqB;AAAA,QAC5B;AAAA,MACF;AAAA,MAEA,QAAc;AACZ,YAAI,CAAC,KAAK,gBAAgB;AACxB;AAAA,QACF;AAEA,yBAAiB;AAEjB,aAAK,eAAe;AACpB,YAAI;AACJ,YAAI,KAAK,cAAc,QAAQ;AAC7B,eAAK,eAAe;AAAA,YAChB,KAAK;AAAA,YAAW;AAAA,YAAG,KAAK,wBAAwB;AAAA,YAAG,KAAK;AAAA,YAAqB;AAAA,UAAC;AAElF,4BAAkB,KAAK,OAAO;AAAA;AAAA,YAE1B,EAAC,MAAM,KAAK,wBAAwB,IAAI,GAAG,OAAO,eAAe,WAAW,eAAe,SAAQ;AAAA,UAAC;AAExG,eAAK,eAAe,IAAI,iBAAiB,KAAK,cAAc;AAC5D,eAAK,iBAAiB,CAAC;AACvB,eAAK,eAAe;AAAA,YAChB,KAAK;AAAA,YAAqB;AAAA,YAAG;AAAA,YAAiB;AAAA,YAAG,KAAK,wBAAwB,IAAI;AAAA,UAAC;AAAA,QACzF;AAEA,aAAK,OAAO,MAAM,OAAO,CAAC,KAAK,eAAe,OAAO,CAAC,CAAC;AACvD,aAAK,eAAe,sBAAsB;AAC1C,aAAK,iBAAiB;AACtB,aAAK,wBAAwB;AAE7B,YAAI,KAAK,cAAc,QAAQ;AAC7B,eAAK,gBAAiB,SAAS,WAAW,IAAI,EAAE,KAAK,MAAM;AACzD,kBAAM,aAAa,IAAI,eAAe,gBAAgB,eAAe,CAAC;AACtE,kBAAM,iBAAiB,KAAK,eAAe,IAAI,eAAe;AAC9D,qBAAS,IAAI,GAAG,IAAI,WAAW,SAAS,GAAG,KAAK;AAC9C,oBAAM,oBAAoB,eAAe,CAAC;AAC1C,oBAAM,WAAW,kBAAkB;AACnC,oBAAM,aAAa,KAAK,QAAQ,IAAI,QAAQ;AAC5C,oBAAM,aAAa,WAAW;AAC9B,oBAAM,aAAa,WAAW;AAC9B,oBAAM,cAAc,kBAAkB;AACtC,oBAAM,mBAAmB,kBAAkB;AAC3C,oBAAM,oBAAoB,kBAAkB;AAC5C,oBAAM,eAAe,WAAW,IAAI,CAAC;AACrC,oBAAM,aAAa,WAAW,IAAI,IAAI,CAAC;AAEvC,kBAAI,OAAO,KAAK,kBAAkB,aAAa;AAC7C,qBAAK,gBAAgB;AAAA,cACvB;AAEA,oBAAM,YAAY,OAAO,eAAe,KAAK,aAAa;AAC1D,oBAAM,UAAU,OAAO,aAAa,KAAK,aAAa;AAEtD,kBAAI,CAAC,OAAO,cAAc,SAAS,KAAK,CAAC,OAAO,cAAc,OAAO,GAAG;AACtE,sBAAM,IAAI,WAAW,2BAA2B;AAAA,cAClD;AAEA,kBAAI,KAAK,IAAI,OAAO,WAAW,QAAQ;AACrC,qBAAK,IAAI,OAAO,UAAU,OAAO;AAAA,kBAC/B,SAAS;AAAA,kBACT,gBAAgB,iBAAiB;AAAA,oBAC7B,YAAU,EAAC,MAAM,MAAM,MAAM,UAAU,2BAA2B,MAAM,QAAQ,EAAC;AAAA,kBAAE;AAAA,kBACvF,iBAAiB,kBAAkB;AAAA,oBAC/B,YAAU,EAAC,MAAM,MAAM,MAAM,UAAU,2BAA2B,MAAM,QAAQ,EAAC;AAAA,kBAAE;AAAA,kBACvF;AAAA,kBACA;AAAA,kBACA;AAAA,kBACA;AAAA,kBACA;AAAA,kBACA;AAAA,gBACF,CAAC;AAAA,cACH,OAAO;AAEL,oBAAI,cAAc;AAClB,iCAAiB,QAAQ,CAAC,OAAOC,OAAM;AACrC,iCAAe,SAASA,EAAC,OAAO,MAAM,IAAI,OAAO,2BAA2B,MAAM,QAAQ,CAAC;AAAA,gBAC7F,CAAC;AACD,oBAAI,eAAe;AACnB,kCAAkB,QAAQ,CAAC,OAAOA,OAAM;AACtC,kCAAgB,UAAUA,EAAC,OAAO,MAAM,IAAI,OAAO,2BAA2B,MAAM,QAAQ,CAAC;AAAA,gBAC/F,CAAC;AAED,wBAAQ,IAAI,uBAAuB,QAAQ,IAAI,UAAU,IAAI,UAAU,IAAI,WAAW,KAAK,WAAW,GAClG,YAAY,mBAAmB,UAAU,SAAS,KAAK;AAAA,cAC7D;AACA,oBAAM,OAAO,GAAG,WAAW,KAAK,YAAY,KAAK,UAAU,EAAE;AAAA,YAC/D;AACA,4BAAgB,MAAM;AACtB,iBAAK,eAAe,OAAO,eAAe;AAAA,UAC5C,CAAC;AAAA,QACH;AACA,uBAAe;AAAA,MACjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAaA,IAAI,SAAsB,kBAAyC,eAC/D,oBACA,0BACA,aAAmC;AACrC,yBAAiB,QAAQ,IAAI;AAE7B,cAAM,aAAwB,CAAC;AAC/B,iBAAS,IAAI,GAAG,IAAI,iBAAiB,QAAQ,EAAE,GAAG;AAChD,gBAAM,OAAO,iBAAiB,CAAC,EAAE;AAEjC,cAAI,SAAS,GAAG;AACd;AAAA,UACF;AACA,gBAAM,UAAU,KAAK,eAAe,IAAI,IAAI;AAC5C,cAAI,CAAC,SAAS;AACZ,kBAAM,IAAI,MAAM,0BAA0B,IAAI,EAAE;AAAA,UAClD;AACA,qBAAW,KAAK,OAAO;AAAA,QACzB;AAEA,cAAM,EAAC,SAAS,eAAe,gBAAe,IAAI,QAAQ,WAAW,gBAAgB;AAGrF,cAAM,yBAAyB,cAAc,WAAW,IAAI,QAAQ,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI;AACvF,YAAI,uBAAuB,WAAW,QAAQ,QAAQ;AACpD,gBAAM,IAAI,MAAM,eAAe,uBAAuB,MAAM,qBAAqB,QAAQ,MAAM,GAAG;AAAA,QACpG;AAGA,cAAM,oBAAkC,CAAC;AACzC,cAAM,cAAyB,CAAC;AAChC,iBAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,EAAE,GAAG;AAIvC,cAAI,CAAC,OAAO,UAAU,uBAAuB,CAAC,CAAC,KAAK,uBAAuB,CAAC,IAAI,MAC5E,uBAAuB,CAAC,KAAK,aAAa;AAC5C,kBAAM,IAAI,MAAM,yBAAyB,uBAAuB,CAAC,CAAC,EAAE;AAAA,UACtE;AACA,cAAI,uBAAuB,CAAC,MAAM,IAAI;AACpC;AAAA,UACF;AACA,gBAAM,cAAc,uBAAuB,CAAC,MAAM;AAClD,gBAAM,eAAe,uBAAuB,CAAC,MAAM;AACnD,gBAAM,aAAc,eAAe,eAC/B,yBAAyB,QAAQ,CAAC,EAAE,UAAU,QAAQ,CAAC,EAAE,IAAI,IAC7D,mBAAmB,uBAAuB,CAAC,GAAG,QAAQ,CAAC,EAAE,UAAU,QAAQ,CAAC,EAAE,IAAI;AACtF,4BAAkB,KAAK,UAAU;AAEjC,cAAI,WAAW,SAAS,GAAG;AACzB;AAAA,UACF;AACA,gBAAM,UAAU,KAAK,eAAe,IAAI,WAAW,IAAI;AACvD,cAAI,CAAC,SAAS;AACZ,kBAAM,IAAI,MAAM,2BAA2B,WAAW,IAAI,EAAE;AAAA,UAC9D;AACA,cAAI,aAAa;AACf,iBAAK,cAAc,KAAK,OAAO;AAAA,UACjC;AACA,cAAI,cAAc;AAChB,gBAAI,iBAAiB,KAAK,qBAAqB,IAAI,KAAK,eAAgB;AACxE,gBAAI,CAAC,gBAAgB;AACnB,+BAAiB,CAAC;AAClB,mBAAK,qBAAqB,IAAI,KAAK,iBAAkB,cAAc;AAAA,YACrE;AACA,2BAAe,KAAK,OAAO;AAAA,UAC7B;AACA,sBAAY,KAAK,OAAO;AAAA,QAC1B;AAIA,YAAI,WAAW,WAAW,iBAAiB,UAAU,YAAY,WAAW,kBAAkB,QAAQ;AAEpG,cAAI,YAAY,WAAW,GAAG;AAC5B,2BAAe,QAAQ,IAAI;AAC3B,mBAAO;AAAA,UACT;AAKA,gBAAM,IAAI;AAAA,YACN,WAAW,QAAQ,IAAI;AAAA,UAA4E;AAAA,QACzG;AAKA,YAAI;AACJ,YAAI,iBAAiB;AACnB,cAAI,gBAAgB;AACpB,gBAAM,UAAoB,CAAC;AAE3B,0BAAgB,QAAQ,OAAK;AAC3B,kBAAM,OAAO,OAAO,EAAE,SAAS,WAAW,CAAC,EAAE,IAAI,IAAI,EAAE;AACvD,gBAAI,KAAK,WAAW,GAAG;AACrB;AAAA,YACF;AAEA,kBAAM,gBAAgB,EAAE,4BAA4B,IAAI;AACxD,gBAAI;AACJ,gBAAI;AACJ,gBAAI,EAAE,2BAA2B;AAC/B,8BAAgB,KAAK,SAAS,IAAI,KAAM,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS;AAC5E,+BAAiB,KAAK,SAAS,IAAI,KAAK,gBAAgB,KAAK;AAAA,YAC/D,OAAO;AACL,8BAAgB,KAAK,UAAU,IAAI,KAAK,SAAS,gBAAgB;AACjE,+BAAiB;AAAA,YACnB;AACA,4BAAgB,KAAK,KAAK,gBAAgB,aAAa,IAAI;AAC3D,oBAAQ,KAAK,aAAa;AAM1B,kBAAM,qBAAqB,EAAE,4BAA4B,IAAI;AAC7D,6BAAiB,KAAK,SAAS,IAAI,KAAK,KAAK,KAAK,SAAS,kBAAkB,IAAI,iBAC9C,KAAK,SAAS;AAAA,UACnD,CAAC;AAID,gBAAM,sBAAsB;AAC5B,0BAAgB,KAAK,KAAK,gBAAgB,mBAAmB,IAAI;AACjE,gBAAM,cAAc,IAAI,YAAY,aAAa;AACjD,0BAAgB,QAAQ,CAAC,GAAG,MAAM;AAChC,kBAAM,SAAS,QAAQ,CAAC;AACxB,kBAAM,OAAO,OAAO,EAAE,SAAS,WAAW,CAAC,EAAE,IAAI,IAAI,EAAE;AACvD,gBAAI,EAAE,wBAAyB;AAC7B,kBAAI,WAAW,aAAa,QAAQ,KAAK,MAAM,EAAE,IAAI,IAAI;AAAA,YAC3D,WAAW,EAAE,0BAA0B;AACrC,kBAAI,YAAY,aAAa,QAAQ,KAAK,MAAM,EAAE,IAAI,IAAI;AAAA,YAC5D,WAAW,EAAE,2BAA2B;AAEtC,kBAAI,YAAY,aAAa,QAAQ,KAAK,MAAM,EAAE,IAAI,IAAI;AAAA,YAC5D,WAAW,EAAE,wBAAyB;AACpC,kBAAI,aAAa,aAAa,QAAQ,KAAK,MAAM,EAAE,IAAI,IAAI;AAAA,YAC7D,OAAO;AACL,oBAAM,IAAI,MAAM,6BAA6B,2BAA2B,EAAE,IAAI,CAAC,EAAE;AAAA,YACnF;AAAA,UACF,CAAC;AAED,gBAAM;AAAA;AAAA,YAEF,KAAK,eAAe,OAAO,eAAe,eAAe,WAAW,eAAe,OAAO;AAAA;AAC9F,eAAK,OAAO,MAAM,YAAY,kBAAkB,QAAQ,GAAG,aAAa,GAAG,aAAa;AACxF,eAAK,eAAe,QAAQ,kBAAkB,EAAE;AAChD,iCAAuB,EAAC,QAAQ,GAAG,MAAM,eAAe,QAAQ,kBAAkB,OAAM;AAAA,QAC1F;AAEA,cAAM,0BAA0B,KAAK,eAAe,2BAA2B,aAAa;AAC5F,cAAM,uBAAuB,wBAAwB,CAAC,MAAM,KAAK,wBAAwB,CAAC,MAAM;AAEhG,cAAM,MAAM,wBAAwB,SAAS,kBAAkB,oBAAoB;AACnF,YAAI,WAAW,KAAK,eAAe,YAAY,GAAG;AAClD,YAAI,CAAC,UAAU;AACb,qBAAW,KAAK,eAAe,MAAM,SAAS,uBAAuB;AACrE,eAAK,eAAe,YAAY,KAAK,QAAQ;AAC7C,oBAAU,QAAQ,MAAM,mBAAmB,GAAG,kBAAkB,QAAQ,IAAI,EAAE;AAAA,QAChF;AAGA,YAAI,mBAAmB,SAAS,sBAAsB;AACpD,cAAI,gBAAgB,WAAW,SAAS,qBAAqB,QAAQ;AACnE,kBAAM,IAAI,MAAM,4CAA4C,SAAS,qBAAqB,MAAM,SAC5F,gBAAgB,MAAM,gBAAgB,SAAS,YAAY,IAAI,IAAI;AAAA,UACzE;AACA,mBAAS,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK;AAC/C,kBAAM,UAAU,gBAAgB,CAAC;AACjC,kBAAM,aAAa,QAAQ;AAC3B,kBAAM,eAAe,OAAO,QAAQ,SAAS,WAAW,IAAI,QAAQ,KAAK;AACzE,kBAAM,CAAC,MAAM,MAAM,IAAI,SAAS,qBAAqB,CAAC;AACtD,gBAAI,eAAe,QAAQ,iBAAiB,QAAQ;AAClD,oBAAM,IAAI,MAAM,oBAAoB,CAAC,0BAA0B,IAAI,cAAc,MAAM,cACnF,UAAU,cAAc,YAAY,gBAAgB,SAAS,YAAY,IAAI,IAAI;AAAA,YACvF;AAAA,UACF;AAAA,QACF;AAEA;AAAA,UACI;AAAA,UACA,MAAM,yBAAyB,QAAQ,IAAI,UAAU,GAAG,UAAU,wBAAwB,CAAC,CAAC,IACxF,wBAAwB,CAAC,CAAC,IAAI,wBAAwB,CAAC,CAAC;AAAA,QAAE;AAElE,YAAI,KAAK,cAAc,UAAU,KAAK,kBAAkB,aAAa;AACnE,gBAAM,oBAAuC;AAAA,YAC3C,UAAU,KAAK;AAAA,YACf,aAAa,SAAS,YAAY;AAAA,YAClC;AAAA,YACA;AAAA,UACF;AACA,eAAK,eAAe,KAAK,iBAAiB;AAE1C,cAAI,KAAK,kBAAkB,aAAa;AACtC,kBAAM,wBAAwB,KAAK,uBAAuB,IAAI,KAAK,gBAAiB;AACpF,kCAAuB,KAAK,iBAAiB;AAAA,UAC/C;AAAA,QACF;AAEA,aAAK,eAAe,IAAI,UAAU,YAAY,aAAa,yBAAyB,oBAAoB;AAExG,uBAAe,QAAQ,IAAI;AAC3B,eAAO;AAAA,MACT;AAAA,MAEA,OAAO,WAAmB,MAAwB;AAChD,aAAK,eAAe,OAAO,WAAW,IAAI;AAAA,MAC5C;AAAA,MAEA,OAAO,KAAa,KAAmB;AACrC,aAAK,eAAe,OAAO,KAAK,GAAG;AAAA,MACrC;AAAA,MAEA,MAAM,SAAS,WAAmB,iBAAkD;AAGlF,cAAM,KAAK,eAAe,SAAS,WAAW,eAAe;AAAA,MAC/D;AAAA,MAEA,MAAM,MAAsB;AAC1B,eAAO,KAAK,eAAe,OAAO,IAAI,EAAE;AAAA,MAC1C;AAAA,MAEA,KAAK,KAAqB;AACxB,eAAO,KAAK,eAAe,QAAQ,GAAG;AAAA,MACxC;AAAA,MAEA,aAAa,YAAoB,UAAkB,WAAoB,YAA0B;AAC/F,cAAM,KAAK,wBAAwB,IAAI,UAAU;AACjD,YAAI,CAAC,IAAI;AACP,gBAAM,IAAI,MAAM,2BAA2B,UAAU,EAAE;AAAA,QACzD;AAEA,cAAM,aAAyB;AAAA,UAC7B;AAAA,UACA;AAAA,UACA,aAAa,GAAG,CAAC;AAAA,UACjB,YAAY,CAAC,GAAG,CAAC,GAAG,SAAS;AAAA,QAC/B;AACA,aAAK,QAAQ,IAAI,UAAU,UAAU;AAAA,MACvC;AAAA,MAEA,cAAc,UAAwB;AACpC,cAAM,iBAAiB,KAAK,qBAAqB,IAAI,QAAQ;AAC7D,YAAI,gBAAgB;AAClB,qBAAW,QAAQ,gBAAgB;AACjC,iBAAK,eAAe,QAAQ,KAAK,EAAE;AAAA,UACrC;AACA,eAAK,qBAAqB,OAAO,QAAQ;AAAA,QAC3C;AAEA,aAAK,iBAAiB,OAAO,QAAQ;AACrC,aAAK,QAAQ,OAAO,QAAQ;AAAA,MAC9B;AAAA,MAEA,cAAc,UAAkB,SAAyB,QAA6C;AACpG,cAAM,SAAS,KAAK,QAAQ,IAAI,QAAQ;AACxC,YAAI,CAAC,QAAQ;AACX,gBAAM,IAAI,MAAM,uBAAuB,QAAQ,EAAE;AAAA,QACnD;AACA,cAAM,aAAa,OAAO;AAC1B,cAAM,aAAa,OAAO;AAC1B,cAAM,cAAc,OAAO;AAC3B,cAAM,aAAa,OAAO;AAC1B,YAAI,KAAK,oBAAoB,MAAM;AACjC,gBAAM,IAAI,MAAM,YAAY,UAAU,KAAK,UAAU,2CAA2C;AAAA,QAClG;AACA,aAAK,kBAAkB;AAGvB,YAAI,WAAW,CAAC,GAAG;AACjB,qBAAW,CAAC,IAAI,WAAW,CAAC,EAAE,WAAW,CAAC,CAAC;AAC3C,qBAAW,CAAC,IAAI;AAAA,QAClB;AAEA,kBAAU,QAAQ,MAAM,kCAAkC,UAAU,KAAK,UAAU,MAAM;AAEzF,cAAM,gBAAgB,KAAK,IAAI;AAE/B,aAAK,gBAAgB,CAAC;AACtB,YAAI;AACF,cAAI,eAAe;AACjB,iBAAK,OAAO,eAAe,YAAY;AAAA,UACzC;AAEA,sBAAY,SAAS,WAAW,CAAC,CAAC;AAClC,iBAAO;AAAA,QACT,SAAS,GAAG;AACV,iBAAO,KAAK,QAAQ,QAAQ,qBAAqB,UAAU,KAAK,UAAU,aAAa,CAAC,EAAE,CAAC;AAC3F,iBAAO;AAAA,QACT,UAAE;AACA,cAAI,eAAe;AACjB,mBAAO,KAAK,KAAK,OAAO,cAAc,EAAE;AAAA,cACpC,SAAO,MAAM,qCAAqC,UAAU,KAAK,UAAU,MAAM,IAAI,OAAO,KAAK;AAAA,YAAI,CAAC;AAAA,UAC5G;AAEA,qBAAW,QAAQ,KAAK,eAAe;AACrC,iBAAK,eAAe,QAAQ,KAAK,EAAE;AAAA,UACrC;AACA,eAAK,gBAAgB,CAAC;AACtB,eAAK,kBAAkB;AAAA,QACzB;AAAA,MACF;AAAA;AAAA,MAGA,eAAe,WAAmB,OAAe,QAAmB,MAAsB;AACxF,YAAI,4BAA4B,KAAK,2BAA2B,IAAI,SAAS;AAC7E,YAAI,CAAC,2BAA2B;AAC9B,sCAA4B,oBAAI,IAAI;AACpC,eAAK,2BAA2B,IAAI,WAAW,yBAAyB;AAAA,QAC1E;AAEA,cAAM,iBAAiB,0BAA0B,IAAI,KAAK;AAC1D,cAAM,KAAK,KAAK,eAAe,uBAAuB,QAAQ,MAAM,iBAAiB,CAAC,CAAC;AACvF,kCAA0B,IAAI,OAAO,CAAC,IAAI,MAAM,CAAC;AACjD,eAAO;AAAA,MACT;AAAA,MACA,kBAAkB,WAAyB;AACzC,cAAM,4BAA4B,KAAK,2BAA2B,IAAI,SAAS;AAC/E,YAAI,2BAA2B;AAC7B,oCAA0B,QAAQ,gBAAc,KAAK,eAAe,yBAAyB,WAAW,CAAC,CAAC,CAAC;AAC3G,eAAK,2BAA2B,OAAO,SAAS;AAAA,QAClD;AAAA,MACF;AAAA,MACA,UAAU,WAA8B;AACtC,cAAM,UAAU,KAAK,eAAe,IAAI,SAAS;AACjD,YAAI,CAAC,SAAS;AACZ,gBAAM,IAAI,MAAM,2BAA2B,SAAS,EAAE;AAAA,QACxD;AACA,eAAO,QAAQ;AAAA,MACjB;AAAA,MACA,iBAAiB,WAAsB,MAAc,MAClB;AACjC,eAAO,YAAY;AACjB,gBAAM,OAAO,MAAM,gBAAgB,MAAM,WAAW,IAAI;AACxD,iBAAO,WAAW,KAAK,QAAQ,IAAI;AAAA,QACrC;AAAA,MACF;AAAA;AAAA,MAEA,eAAe,OAAqB;AAClC,YAAI,KAAK,cAAc,iBAAiB;AACtC;AAAA,QACF;AAGA,QAAC,KAAK,mBAA2B,eAAe,KAAK,UAAU,KAAK;AAAA,MACtE;AAAA,MACA,eAAqB;AACnB,aAAK,YAAY;AACjB,YAAI,KAAK,IAAI,OAAO,WAAW,SAAS,cACnC,OAAO,KAAK,IAAI,UAAU,cAAc,KAAK,IAAI,KAAK,QAAQ,KAAK,IAAI,QAAQ;AAClF,cAAI,KAAK,OAAO,SAAS,IAAI,qDAAqD,GAAG;AACnF,iBAAK,YAAY;AAAA,UACnB,WAAW,KAAK,OAAO,SAAS,IAAI,iBAAiB,GAAG;AACtD,iBAAK,YAAY;AAAA,UACnB;AAEA,cAAI,KAAK,cAAc,UAAU,OAAO,KAAK,aAAa,aAAa;AACrE,iBAAK,WAAW,KAAK,OAAO,eAAe;AAAA,cACzC,MAAM;AAAA,cACN,OAAO,KAAK,oBAAoB;AAAA,YAClC,CAAC;AACD,iBAAK,qBAAqB,KAAK,OAAO;AAAA;AAAA,cAElC,EAAC,MAAM,KAAK,oBAAoB,IAAI,GAAG,OAAO,eAAe,WAAW,eAAe,cAAa;AAAA,YAAC;AAAA,UAC3G;AAAA,QACF;AAAA,MACF;AAAA,MAEA,eAAqB;AACnB,kBAAU,QAAQ,cAAc;AAChC,YAAI,CAAC,KAAK,oBAAoB,IAAI,KAAK,gBAAiB,GAAG;AACzD,eAAK,oBAAoB,IAAI,KAAK,kBAAmB,CAAC,CAAC;AAAA,QACzD;AACA,YAAI,CAAC,KAAK,uBAAuB,IAAI,KAAK,gBAAiB,GAAG;AAC5D,eAAK,uBAAuB,IAAI,KAAK,kBAAmB,CAAC,CAAC;AAAA,QAC5D;AAEA,aAAK,MAAM;AACX,aAAK,gBAAgB;AAAA,MACvB;AAAA,MACA,aAAmB;AACjB,kBAAU,QAAQ,YAAY;AAE9B,aAAK,MAAM;AACX,aAAK,gBAAgB;AAAA,MACvB;AAAA,MACA,SAAe;AACb,kBAAU,QAAQ,QAAQ;AAC1B,aAAK,gBAAgB;AACrB,cAAM,qBAAqB,KAAK,oBAAoB,IAAI,KAAK,gBAAiB;AAC9E,cAAM,wBAAwB,KAAK,uBAAuB,IAAI,KAAK,gBAAiB;AACpF,cAAM,SAAS,mBAAoB;AACnC,aAAK,iBAAiB,CAAC;AACvB,iBAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC/B,gBAAM,qBAAqB,KAAK,sBAAsB;AACtD,gBAAM,UAAU,mBAAoB,CAAC;AACrC,eAAK,eAAe,KAAK,wBAAwB,CAAC;AAClD,6BAAmB,YAAY,QAAQ,eAAe;AACtD,6BAAmB,aAAa,GAAG,QAAQ,SAAS;AACpD,6BAAmB,mBAAmB,GAAG,QAAQ,aAAa;AAC9D,eAAK,eAAe,KAAK,wBAAwB,IAAI,CAAC;AACtD,eAAK;AACL,cAAI,KAAK,cAAc,QAAQ;AAC7B,iBAAK,eAAe,KAAK,sBAAuB,CAAC,CAAC;AAAA,UACpD;AACA,cAAI,KAAK,yBAAyB,KAAK,qBAAqB,KAAK,cAAc,aAAa;AAC1F,iBAAK,eAAe;AAAA,UACtB;AACA,cAAI,KAAK,yBAAyB,KAAK,mBAAmB;AACxD,iBAAK,MAAM;AAAA,UACb;AAAA,QACF;AAEA,aAAK,MAAM;AACX,aAAK,gBAAgB;AAAA,MACvB;AAAA,MAEA,iBAAiB,WAAyB;AACxC,aAAK,kBAAkB,SAAS;AAChC,YAAI,KAAK,oBAAoB,IAAI,SAAS,GAAG;AAC3C,eAAK,oBAAoB,OAAO,SAAS;AAAA,QAC3C;AACA,YAAI,KAAK,uBAAuB,IAAI,SAAS,GAAG;AAC9C,eAAK,uBAAuB,OAAO,SAAS;AAAA,QAC9C;AACA,aAAK,eAAe,iBAAiB,SAAS;AAAA,MAChD;AAAA,MAEA,WAAW,WAAyB;AAClC,aAAK,mBAAmB;AACxB,aAAK,aAAa;AAAA,MACpB;AAAA,IACF;AAAA;AAAA;;;ACx0BA;AAAA;AAAA;AAAA;AAAA,IAgBM,gBAuCA,oBAoHO;AA3Kb;AAAA;AAAA;AAMA;AAEA;AACA;AAEA;AAKA,IAAM,iBAAN,MAAM,gBAAqC;AAAA,MACzC,YACY,QAAuC,UAAkC,MACjE,MAAyB;AADjC;AAAuC;AAAkC;AACjE;AAAA,MAA0B;AAAA,MAE9C,kBAAgC;AAC9B,YAAI,KAAK,4BAA6B;AACpC,gBAAM,IAAI,MAAM,mBAAmB;AAAA,QACrC;AACA,cAAM,eAAe,UAAU,KAAK,KAAK,IAAI;AAC7C,eAAO,iBAAiB,IAAI,IAAI,aAAa,IACjB,IAAI,aAAa,KAAK,OAAO,MAAM,QAAQ,KAAK,MAAM,YAAY;AAAA,MAChG;AAAA,MAEA,mBAAkC;AAChC,YAAI,KAAK,4BAA6B;AACpC,gBAAM,IAAI,MAAM,mBAAmB;AAAA,QACrC;AACA,cAAM,eAAe,UAAU,KAAK,KAAK,IAAI;AAC7C,eAAO,iBAAiB,IAAI,IAAI,cAAc,IAClB,IAAI,cAAc,KAAK,OAAO,MAAM,QAAQ,KAAK,MAAM,YAAY;AAAA,MACjG;AAAA,MAEA,gBAA4B;AAC1B,YAAI,KAAK,4BAA6B;AACpC,gBAAM,IAAI,MAAM,mBAAmB;AAAA,QACrC;AACA,cAAM,eAAe,UAAU,KAAK,KAAK,IAAI;AAC7C,eAAO,iBAAiB,IAAI,IAAI,WAAW,IAAI,IAAI,WAAW,KAAK,OAAO,MAAM,QAAQ,KAAK,MAAM,YAAY;AAAA,MACjH;AAAA,MAEA,QAAQ,SAAwC;AAC9C,YAAI,UAAU,KAAK,OAAO,MAAM,UAAU,KAAK,KAAK,IAAI,GAAG;AACzD,gBAAM,IAAI,MAAM,mBAAmB;AAAA,QACrC;AACA,eAAO,IAAI,gBAAe,KAAK,QAAQ,KAAK,UAAU,KAAK,MAAM,OAAO;AAAA,MAC1E;AAAA,IACF;AAEA,IAAM,qBAAN,MAAmD;AAAA,MAajD,YAAoB,QAA+B,SAAwB,mBAA2B;AAAlF;AAA+B;AAFnD,aAAQ,mBAAmB;AAC3B,aAAQ,iBAAiB;AAEvB,aAAK,cAAc,QAAQ;AAC3B,cAAM,UAAU,OAAO;AAGvB,YAAI,YAAa,sBAAsB;AACvC,aAAK,kBAAkB,QAAQ,WAAW;AAC1C,cAAM,aAAa,QAAQ,WAAW;AACtC,aAAK,cAAc,QAAQ,WAAW;AACtC,aAAK,mBAAmB,QAAQ,WAAW;AAC3C,aAAK,iBAAiB,QAAQ,WAAW;AAEzC,cAAM,SAAuB,CAAC;AAC9B,iBAAS,IAAI,GAAG,IAAI,YAAY,KAAK;AACnC,gBAAM,WAAW,QAAQ,WAAW;AACpC,gBAAM,OAAO,QAAQ,WAAW;AAChC,gBAAM,MAAM,QAAQ,WAAW;AAC/B,gBAAM,OAAiB,CAAC;AACxB,mBAAS,IAAI,GAAG,IAAI,KAAK,KAAK;AAC5B,iBAAK,KAAK,QAAQ,WAAW,CAAC;AAAA,UAChC;AACA,iBAAO,KAAK,IAAI,eAAe,QAAQ,UAAU,MAAM,IAAI,CAAC;AAAA,QAC9D;AACA,aAAK,SAAS;AAAA,MAChB;AAAA,MAhCA,IAAI,mBAA6C;AAC/C,eAAO,KAAK,QAAQ;AAAA,MACtB;AAAA,MACA,IAAI,mBAA+B;AACjC,eAAO,KAAK,OAAO,OAAO,SAAS,KAAK,kBAAkB,KAAK,mBAAmB,KAAK,cAAc;AAAA,MACvG;AAAA,MA6BA,8BAAwD;AACtD,eAAO;AAAA,UACL,KAAK,QAAQ,OAAO,OAAO;AAAA,UAA0B,KAAK,QAAQ,OAAO,OAAO;AAAA,UAChF,KAAK,QAAQ,OAAO,OAAO;AAAA,QAC7B;AAAA,MACF;AAAA,MAEA,oCAA4C;AAC1C,eAAO,KAAK,QAAQ,OAAO,OAAO;AAAA,MACpC;AAAA,MAEA,QAAQ,SAAsB,sBAAyE;AAErG,cAAM,eACF,sBAAsB,QAAQ,IAAI,OAAK,OAAO,MAAM,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,KAAK,KAAK;AAE/F,cAAM,gBAAgB,sBAAsB,WAAW,CAAC;AACxD,cAAM,qBAAqB,CAAC,OAAe,UAAkB,SACzD,IAAI,eAAe,KAAK,QAAQ,UAAU,KAAK,OAAO,OAAO,IAAI,GAAG,IAAI;AAC5E,cAAM,wBAAwB,CAAC,UAAkB,SAAwC;AACvF,gBAAM,cAAc,qBAAqB,QAAQ;AACjD,cAAI,CAAC,aAAa;AAChB,kBAAM,IAAI,MAAM,0BAA0B,QAAQ,EAAE;AAAA,UACtD;AACA,gBAAM,aAAa,cAAc,UAAU,KAAK,IAAI;AACpD,gBAAM,YAAY,aAAa,IAAI,KAAK,QAAQ,eAAe,OAAO,UAAU,EAAE,KAAK;AACvF,iBAAO,IAAI,eAAe,KAAK,QAAQ,UAAU,WAAW,IAAI;AAAA,QAClE;AACA,eAAO,KAAK,QAAQ;AAAA,UAChB;AAAA,UAAS;AAAA,UAAc;AAAA,UAAe;AAAA,UAAoB;AAAA,UAAuB,KAAK;AAAA,QAAW;AAAA,MACvG;AAAA,MAEA,OAAO,OAAe,MAAiC;AACrD,cAAM,QAAQ,KAAK,OAAO,UAAU;AACpC,YAAI;AACF,gBAAM,OAAO,KAAK,OAAO;AAAA,aAAY,IAAI,KAAK,UAAU;AAAA;AAAA,UAAsB;AAC9E,cAAI,SAAS,QAAQ;AACrB,eAAK,OAAO,QAAQ,QAAQ,IAAI,KAAK;AACrC,mBAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,iBAAK,OAAO,QAAQ,QAAQ,IAAI,KAAK,CAAC;AAAA,UACxC;AACA,iBAAO,KAAK,OAAO,YAAa,KAAK,iBAAiB,OAAO,IAAI;AAAA,QACnE,SAAS,GAAG;AACV,gBAAM,IAAI;AAAA,YACN,sCAAsC,KAAK,gBAAgB,IAAI,8GAErD,CAAC;AAAA,UAAE;AAAA,QACnB,UAAE;AACA,eAAK,OAAO,aAAa,KAAK;AAAA,QAChC;AAAA,MACF;AAAA,IACF;AA0BO,IAAM,OACT,OAAM,MAAwB,QAAuBC,MAAU,eAA2C;AAC5G,YAAM,WAAW,OAAO;AACxB,UAAI,CAAC,UAAU;AACb,cAAM,IAAI,MAAM,mFAAmF;AAAA,MACrG;AAEA,UAAI,SAAS,UAAU;AACrB,cAAM,UAAU,IAAI,cAAc;AAClC,cAAM,QAAQ,WAAWA,MAAK,UAAW;AAEzC,iBAAS,UAAU;AAAA;AAAA,UAEjB;AAAA;AAAA,UAGA,CAAC,SAAiB,QAAQ,MAAM,IAAI;AAAA;AAAA,UAGpC,CAAC,QAAgB,QAAQ,KAAK,GAAG;AAAA;AAAA,UAGjC,CAAC,KAAa,KAAa,MAAc,cAAc,UAAU;AAC/D,gBAAI,aAAa;AACf,wBAAU,WAAW,MAAM,kCAAkC,GAAG,SAAS,GAAG,UAAU,IAAI,EAAE;AAC5F,sBAAQ,OAAO,KAAK,GAAG;AAAA,YACzB,OAAO;AACL,wBAAU,WAAW,MAAM,yCAAyC,GAAG,eAAe,GAAG,UAAU,IAAI,EAAE;AACzG,oBAAM,OAAO,OAAO,OAAO,SAAS,QAAQ,IAAI,QAAQ,KAAK,IAAI;AACjE,sBAAQ,OAAO,KAAK,IAAI;AAAA,YAC1B;AAAA,UACF;AAAA;AAAA,UAGA,OAAM,WAAmB,YAAoB,SACxB;AACf;AAAA,cACI;AAAA,cACA,MAAM,wCAAwC,SAAS,gBAAgB,UAAU,UAAU,IAAI;AAAA,YAAE;AAErG,kBAAM,QAAQ;AAAA,cACV;AAAA,cAAW,MAAM,OAAO,OAAO,SAAS,eAAe,IAAI,eAAe,KAAK,IAAI;AAAA,YAAC;AAAA,UAC1F;AAAA;AAAA,UAGJ,CAAC,YAAoB,UAAkB,cAAuB,QAAQ;AAAA,YAClE;AAAA,YAAY;AAAA,YAAU;AAAA,YAAW,OAAO,aAAa,OAAO,iBAAkB,QAAQ,CAAC;AAAA,UAAC;AAAA;AAAA,UAG5F,CAAC,WAAmB,QAAQ,cAAc,MAAM;AAAA;AAAA,UAGhD,CAAC,QAAgB,mBAA2B,eAAuB,WAAwC;AACzG;AAAA,cACI;AAAA,cACA,MAAM,mCAAmC,aAAa,YAAY,MAAM,uBACpE,iBAAiB;AAAA,YAAE;AAC3B,kBAAM,UAAU,IAAI,mBAAmB,QAAQ,SAAS,iBAAiB;AACzE,mBAAO,QAAQ,cAAc,QAAQ,SAAS,MAAM;AAAA,UACtD;AAAA;AAAA,UAEA,MAAM,QAAQ,aAAa;AAAA;AAAA,UAE3B,MAAM,QAAQ,WAAW;AAAA;AAAA,UAEzB,MAAM,QAAQ,OAAO;AAAA,QACvB,CAAC;AAAA,MACH,OAAO;AACL,iBAAS,OAAO;AAAA,MAClB;AAAA,IACF;AAAA;AAAA;;;ACjPA,IA+DM,SAWO,aAWA,QAyFP,gBAOA,4BAqBO,wBAkBA,eAmIA,gBAuBA,0BA+EA,KA6OA,cAgBA;AAlsBb;AAAA;AAAA;AAMA;AACA;AACA;AACA;AACA;AACA;AAoDA,IAAM,UAAU,CAAC,YAAoB,iBAA+B;AAClE,YAAM,YAAY,YAAY,EAAE,SAAS,YAAY,YAAY;AACjE,UAAI,cAAc,GAAG;AACnB,uBAAe,+BAAgC;AAAA,MACjD;AAAA,IACF;AAMO,IAAM,cAAc,OAAMC,SAA4B;AAE3D,cAAQA,KAAI,KAAK,YAAa,qBAAqBA,KAAI,QAAQ,CAAC;AAAA,IAClE;AAQO,IAAM,SAAS,OAAMA,MAAU,WAAkC;AACtE,UAAI,MAA4B;AAE9B,cAAM,WAAW,0CAAuB;AAExC,YAAI,WAAW,UAAU;AAEvB,cAAI,OAAO,cAAc,eAAe,CAAC,UAAU,KAAK;AACtD,kBAAM,IAAI,MAAM,gDAAgD;AAAA,UAClE;AAEA,cAAI,UAAUA,KAAI,OAAO;AACzB,cAAI,CAAC,SAAS;AAEZ,kBAAM,kBAAkBA,KAAI,OAAO;AACnC,gBAAI,oBAAoB,UAAa,oBAAoB,eACrD,oBAAoB,oBAAoB;AAC1C,oBAAM,IAAI,MAAM,qCAAqC,eAAe,GAAG;AAAA,YACzE;AACA,kBAAM,uBAAuBA,KAAI,OAAO;AACxC,gBAAI,yBAAyB,UAAa,OAAO,yBAAyB,WAAW;AACnF,oBAAM,IAAI,MAAM,0CAA0C,oBAAoB,GAAG;AAAA,YACnF;AACA,sBAAU,MAAM,UAAU,IAAI,eAAe,EAAC,iBAAiB,qBAAoB,CAAC;AACpF,gBAAI,CAAC,SAAS;AACZ,oBAAM,IAAI;AAAA,gBACN;AAAA,cAC+E;AAAA,YACrF;AAAA,UACF,OAAO;AAEL,gBAAI,OAAO,QAAQ,WAAW,YAAY,OAAO,QAAQ,aAAa,YAClE,OAAO,QAAQ,kBAAkB,YAAY;AAC/C,oBAAM,IAAI,MAAM,kFAAkF;AAAA,YACpG;AAAA,UACF;AAEA,cAAI,CAACA,KAAI,KAAK,MAAM;AAClB,kBAAM,IAAI;AAAA,cACN;AAAA,YAAqG;AAAA,UAC3G;AAEA,gBAAM,SAAS,UAAU,YAAY,GAAGA,MAAK,OAAO;AAAA,QACtD;AACA,YAAI,WAAW,SAAS;AAEtB,cAAI,OAAO,cAAc,eAAe,CAAE,UAAuC,IAAI;AACnF,kBAAM,IAAI,MAAM,+CAA+C;AAAA,UACjE;AAEA,gBAAM,SAAS,SAAS,YAAY,GAAGA,IAAG;AAAA,QAC5C;AAAA,MACF;AAAA,IACF;AAoCA,IAAM,iBAAiB,oBAAI,IAA6B;AAOxD,IAAM,6BAA6B,CAAC,kBAA4C;AAC9E,YAAMC,QAAO,YAAY;AACzB,YAAM,QAAQA,MAAK,UAAU;AAC7B,UAAI;AACF,cAAM,aAAaA,MAAK,WAAW,CAAC;AACpC,cAAM,YAAYA,MAAK,wBAAwB,eAAe,YAAY,aAAa,CAAC;AACxF,YAAI,cAAc,GAAG;AACnB,yBAAe,uCAAwC;AAAA,QACzD;AACA,eAAO,CAACA,MAAK,OAAO,aAAa,CAAC,GAAGA,MAAK,OAAO,aAAa,IAAI,CAAC,CAAC;AAAA,MACtE,UAAE;AACA,QAAAA,MAAK,aAAa,KAAK;AAAA,MACzB;AAAA,IACF;AAQO,IAAM,yBAAyB,CAAC,UAAwC;AAC7E,YAAMA,QAAO,YAAY;AACzB,YAAM,kBAAkBA,MAAK,QAAQ,MAAM,UAAU;AACrD,UAAI,oBAAoB,GAAG;AACzB,cAAM,IAAI,MAAM,+DAA+D,MAAM,UAAU,GAAG;AAAA,MACpG;AACA,MAAAA,MAAK,OAAO,IAAI,OAAO,eAAe;AACtC,aAAO,CAAC,iBAAiB,MAAM,UAAU;AAAA,IAC3C;AAUO,IAAM,gBAAgB,OACzB,WACA,YAAoF;AACtF,UAAI,iBAAyB;AAC7B,YAAMA,QAAO,YAAY;AAEzB,UAAI,MAAM,QAAQ,SAAS,GAAG;AAE5B,SAAC,iBAAiB,eAAe,IAAI;AAAA,MACvC,WAAW,UAAU,WAAWA,MAAK,OAAO,QAAQ;AAElD,SAAC,iBAAiB,eAAe,IAAI,CAAC,UAAU,YAAY,UAAU,UAAU;AAAA,MAClF,OAAO;AAEL,SAAC,iBAAiB,eAAe,IAAI,uBAAuB,SAAS;AAAA,MACvE;AAEA,UAAI,gBAAgB;AACpB,UAAI,uBAAuB;AAC3B,UAAI,kBAAkB;AACtB,UAAI,SAAmB,CAAC;AACxB,YAAM,wBAAwB,CAAC;AAC/B,YAAM,yBAAyB,CAAC;AAEhC,UAAI;AACF,SAAC,sBAAsB,MAAM,IAAI,kBAAkB,OAAO;AAE1D,YAAI,SAAS,gBAAgBA,MAAK,mBAAmB;AACnD,gBAAM,kBAAkB,CAAC;AACzB,qBAAW,QAAQ,QAAQ,cAAc;AACvC,kBAAM,OAAO,OAAO,SAAS,WAAW,OAAO,KAAK;AACpD,4BAAgB,KAAK,SAAS,OAAO,SAAS,WAAW,OAAO,KAAK,IAAI,EAAE,KAAK,UAAQ;AACtF,cAAAA,MAAK,kBAAmB,MAAM,IAAI;AAAA,YACpC,CAAC,CAAC;AAAA,UACJ;AAGA,gBAAM,QAAQ,IAAI,eAAe;AAAA,QACnC;AAEA,wBAAgB,MAAMA,MAAK,kBAAkB,iBAAiB,iBAAiB,oBAAoB;AACnG,YAAI,kBAAkB,GAAG;AACvB,yBAAe,yBAA0B;AAAA,QAC3C;AAEA,cAAM,CAAC,YAAY,WAAW,IAAI,2BAA2B,aAAa;AAE1E,cAAM,qBAAqB,CAAC,CAAC,SAAS;AAEtC,cAAM,aAAa,CAAC;AACpB,cAAM,cAAc,CAAC;AACrB,cAAM,2BAAwE,CAAC;AAC/E,iBAAS,IAAI,GAAG,IAAI,YAAY,KAAK;AACnC,gBAAM,OAAOA,MAAK,iBAAiB,eAAe,CAAC;AACnD,cAAI,SAAS,GAAG;AACd,2BAAe,0BAA2B;AAAA,UAC5C;AACA,gCAAsB,KAAK,IAAI;AAC/B,qBAAW,KAAKA,MAAK,aAAa,IAAI,CAAC;AAAA,QACzC;AACA,iBAAS,IAAI,GAAG,IAAI,aAAa,KAAK;AACpC,gBAAM,OAAOA,MAAK,kBAAkB,eAAe,CAAC;AACpD,cAAI,SAAS,GAAG;AACd,2BAAe,2BAA4B;AAAA,UAC7C;AACA,iCAAuB,KAAK,IAAI;AAChC,gBAAM,aAAaA,MAAK,aAAa,IAAI;AACzC,sBAAY,KAAK,UAAU;AAE3B,cAAI,MAA4B;AAC9B,gBAAI,sBAAsB,SAAS,4BAA4B,QAAW;AACxE,uCAAyB,KAAK,YAAY;AAC1C;AAAA,YACF;AACA,kBAAM,WAAW,OAAO,SAAS,4BAA4B,WACzD,QAAQ,0BACR,SAAS,0BAA0B,UAAU,KAAK;AACtD,gBAAI,aAAa,SAAS,aAAa,gBAAgB,aAAa,cAAc;AAChF,oBAAM,IAAI,MAAM,4CAA4C,QAAQ,GAAG;AAAA,YACzE;AACA,gBAAI,sBAAsB,aAAa,cAAc;AACnD,oBAAM,IAAI,MAAM,4CACZ,QAAQ,4EAA4E;AAAA,YAC1F;AACA,qCAAyB,KAAK,QAAQ;AAAA,UACxC;AAAA,QACF;AAGA,YAAI,eAAoC;AACxC,YAAkC,yBAAyB,KAAK,OAAK,MAAM,YAAY,GAAG;AACxF,4BAAkBA,MAAK,kBAAkB,aAAa;AACtD,cAAI,oBAAoB,GAAG;AACzB,2BAAe,0BAA2B;AAAA,UAC5C;AAEA,yBAAe;AAAA,YACb,QAAQ;AAAA,YACR;AAAA,YACA,iCAAiC,yBAAyB,IAAI,OAAK,yBAAyB,CAAC,CAAC;AAAA,UAChG;AAAA,QACF;AAEA,uBAAe;AAAA,UACX;AAAA,UACA,CAAC,eAAe,uBAAuB,wBAAwB,cAAc,oBAAoB,KAAK;AAAA,QAAC;AAC3G,eAAO,CAAC,eAAe,YAAY,WAAW;AAAA,MAChD,SAAS,GAAG;AACV,8BAAsB,QAAQ,SAAOA,MAAK,SAAS,GAAG,CAAC;AACvD,+BAAuB,QAAQ,SAAOA,MAAK,SAAS,GAAG,CAAC;AAExD,YAAI,oBAAoB,GAAG;AACzB,UAAAA,MAAK,mBAAmB,eAAe;AAAA,QACzC;AAEA,YAAI,kBAAkB,GAAG;AACvB,UAAAA,MAAK,mBAAmB,aAAa;AAAA,QACvC;AACA,cAAM;AAAA,MACR,UAAE;AACA,QAAAA,MAAK,MAAM,eAAe;AAC1B,YAAI,yBAAyB,GAAG;AAC9B,UAAAA,MAAK,0BAA0B,oBAAoB;AAAA,QACrD;AACA,eAAO,QAAQ,WAASA,MAAK,MAAM,KAAK,CAAC;AAGzC,QAAAA,MAAK,sBAAsB;AAAA,MAC7B;AAAA,IACF;AAEO,IAAM,iBAAiB,CAAC,cAA4B;AACzD,YAAMA,QAAO,YAAY;AACzB,YAAM,UAAU,eAAe,IAAI,SAAS;AAC5C,UAAI,CAAC,SAAS;AACZ,cAAM,IAAI,MAAM,+CAA+C,SAAS,EAAE;AAAA,MAC5E;AACA,YAAM,CAAC,eAAe,uBAAuB,wBAAwB,gBAAgB,kBAAkB,IAAI;AAE3G,UAAI,gBAAgB;AAClB,YAAI,oBAAoB;AACtB,UAAAA,MAAK,sBAAsB,eAAe,MAAM;AAAA,QAClD;AACA,QAAAA,MAAK,mBAAmB,eAAe,MAAM;AAAA,MAC/C;AAEA,MAAAA,MAAK,uBAAuB,SAAS;AAErC,4BAAsB,QAAQ,SAAOA,MAAK,SAAS,GAAG,CAAC;AACvD,6BAAuB,QAAQ,SAAOA,MAAK,SAAS,GAAG,CAAC;AACxD,MAAAA,MAAK,mBAAmB,aAAa;AACrC,qBAAe,OAAO,SAAS;AAAA,IACjC;AAEO,IAAM,2BACT,CAAC,QAA6B,eAAyB,QAAkB,WAAmB,OAC3F,qBAAqB,UAAgB;AACpC,UAAI,CAAC,QAAQ;AACX,sBAAc,KAAK,CAAC;AACpB;AAAA,MACF;AAEA,YAAMA,QAAO,YAAY;AAEzB,YAAM,WAAW,OAAO,CAAC;AACzB,YAAM,OAAO,OAAO,CAAC;AACrB,YAAM,WAAW,OAAO,CAAC;AAEzB,UAAI;AACJ,UAAI;AAEJ,UAAI,aAAa,YAAY,aAAa,cAAc;AACtD,cAAM,IAAI,MAAM,wCAAwC;AAAA,MAC1D;AAEA,UAAI,sBAAsB,aAAa,cAAc;AACnD,cAAM,IAAI;AAAA,UACN,2DAA2D,KAAK;AAAA,QAAmC;AAAA,MACzG;AAEA,UAAI,aAAa,cAAc;AAC7B,cAAM,YAAY,OAAO,CAAC,EAAE;AAC5B,cAAM,qBAAqB,qBAAqB,2BAA2B,QAAQ,CAAC;AACpF,yBAAiB,KAAK,OAAO,CAAC,GAAG,MAAM,IAAI,GAAG,CAAC,IAAI;AAEnD,cAAM,iBAAiBA,MAAK;AAC5B,YAAI,CAAC,gBAAgB;AACnB,gBAAM,IAAI,MAAM,qEAAqE;AAAA,QACvF;AACA,kBAAU,eAAe,WAAW,OAAO,WAAW,cAAc;AAAA,MACtE,OAAO;AACL,cAAM,OAAO,OAAO,CAAC;AAErB,YAAI,MAAM,QAAQ,IAAI,GAAG;AAEvB,2BAAiB,IAAI,KAAK;AAC1B,oBAAUA,MAAK,QAAQ,cAAc;AACrC,iBAAO,KAAK,OAAO;AACnB,cAAI,YAAY,UAAU;AAC1B,mBAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,gBAAI,OAAO,KAAK,CAAC,MAAM,UAAU;AAC/B,oBAAM,IAAI,UAAU,wBAAwB,CAAC,kBAAkB;AAAA,YACjE;AACA,YAAAA,MAAK,QAAQ,WAAW,IAAI,gBAAgB,KAAK,CAAC,GAAG,MAAM;AAAA,UAC7D;AAAA,QACF,OAAO;AACL,2BAAiB,KAAK;AACtB,oBAAUA,MAAK,QAAQ,cAAc;AACrC,iBAAO,KAAK,OAAO;AACnB,UAAAA,MAAK,OAAO,IAAI,IAAI,WAAW,KAAK,QAAQ,KAAK,YAAY,cAAc,GAAG,OAAO;AAAA,QACvF;AAAA,MACF;AAEA,YAAM,QAAQA,MAAK,UAAU;AAC7B,YAAM,aAAaA,MAAK,WAAW,IAAI,KAAK,MAAM;AAClD,UAAI;AACF,YAAI,WAAW,aAAa;AAC5B,aAAK,QAAQ,OAAKA,MAAK,OAAO,UAAU,IAAI,CAAC;AAC7C,cAAMC,UAASD,MAAK;AAAA,UAChB,2BAA2B,QAAQ;AAAA,UAAG;AAAA,UAAS;AAAA,UAAgB;AAAA,UAAY,KAAK;AAAA,UAChF,yBAAyB,QAAQ;AAAA,QAAC;AACtC,YAAIC,YAAW,GAAG;AAChB,yBAAe,iDAAiD,SAAS,WAAW,KAAK,GAAG;AAAA,QAC9F;AACA,sBAAc,KAAKA,OAAM;AAAA,MAC3B,UAAE;AACA,QAAAD,MAAK,aAAa,KAAK;AAAA,MACzB;AAAA,IACF;AAKG,IAAM,MAAM,OACf,WAAmB,cAAwB,cAAgC,eAC3E,eAA2C,YAAoE;AACjH,YAAMA,QAAO,YAAY;AACzB,YAAM,UAAU,eAAe,IAAI,SAAS;AAC5C,UAAI,CAAC,SAAS;AACZ,cAAM,IAAI,MAAM,6CAA6C,SAAS,EAAE;AAAA,MAC1E;AACA,YAAM,gBAAgB,QAAQ,CAAC;AAC/B,YAAM,wBAAwB,QAAQ,CAAC;AACvC,YAAM,yBAAyB,QAAQ,CAAC;AACxC,YAAM,iBAAiB,QAAQ,CAAC;AAChC,YAAM,qBAAqB,QAAQ,CAAC;AACpC,YAAM,mBAAmB,QAAQ,CAAC;AAElC,YAAM,aAAa,aAAa;AAChC,YAAM,cAAc,cAAc;AAElC,UAAI,mBAAmB;AACvB,UAAI,mBAA6B,CAAC;AAElC,YAAM,qBAA+B,CAAC;AACtC,YAAM,sBAAgC,CAAC;AACvC,YAAM,oBAA8B,CAAC;AAErC,YAAM,iBAAiBA,MAAK,UAAU;AACtC,YAAM,oBAAoBA,MAAK,WAAW,aAAa,CAAC;AACxD,YAAM,mBAAmBA,MAAK,WAAW,aAAa,CAAC;AACvD,YAAM,qBAAqBA,MAAK,WAAW,cAAc,CAAC;AAC1D,YAAM,oBAAoBA,MAAK,WAAW,cAAc,CAAC;AAEzD,UAAI;AACF,SAAC,kBAAkB,gBAAgB,IAAI,cAAc,OAAO;AAG5D,iBAAS,IAAI,GAAG,IAAI,YAAY,KAAK;AACnC;AAAA,YACI,aAAa,CAAC;AAAA,YAAG;AAAA,YAAoB;AAAA,YAAmB;AAAA,YAAW,aAAa,CAAC;AAAA,YAAG;AAAA,UAAkB;AAAA,QAC5G;AAGA,iBAAS,IAAI,GAAG,IAAI,aAAa,KAAK;AACpC;AAAA,YACI,cAAc,CAAC;AAAA,YAAG;AAAA,YAAqB;AAAA,YAAmB;AAAA,YAAW,aAAa,cAAc,CAAC;AAAA,YACjG;AAAA,UAAkB;AAAA,QACxB;AAEA,YAAI,mBAAmB,oBAAoB;AAC3C,YAAI,kBAAkB,mBAAmB;AACzC,YAAI,oBAAoB,qBAAqB;AAC7C,YAAI,mBAAmB,oBAAoB;AAC3C,iBAAS,IAAI,GAAG,IAAI,YAAY,KAAK;AACnC,UAAAA,MAAK,QAAQ,kBAAkB,IAAI,mBAAmB,CAAC;AACvD,UAAAA,MAAK,QAAQ,iBAAiB,IAAI,sBAAsB,aAAa,CAAC,CAAC;AAAA,QACzE;AACA,iBAAS,IAAI,GAAG,IAAI,aAAa,KAAK;AACpC,UAAAA,MAAK,QAAQ,mBAAmB,IAAI,oBAAoB,CAAC;AACzD,UAAAA,MAAK,QAAQ,kBAAkB,IAAI,uBAAuB,cAAc,CAAC,CAAC;AAAA,QAC5E;AAEA,YAAkC,kBAAkB,CAAC,kBAAkB;AACrE,gBAAM,EAAC,QAAQ,0BAA0B,gCAA+B,IAAI;AAE5E,cAAI,sBAAsB,WAAW,YAAY;AAC/C,kBAAM,IAAI,MAAM,2BACZ,UAAU,4DAA4D,sBAAsB,MAAM,IAAI;AAAA,UAC5G;AAGA,mBAAS,IAAI,GAAG,IAAI,YAAY,KAAK;AACnC,kBAAM,QAAQ,aAAa,CAAC;AAC5B,kBAAME,aAAY,MAAMF,MAAK,cAAc,QAAQ,sBAAsB,KAAK,GAAG,mBAAmB,CAAC,CAAC;AACtG,gBAAIE,eAAc,GAAG;AACnB,6BAAe,oBAAoB,CAAC,iBAAiB,SAAS,GAAG;AAAA,YACnE;AAAA,UACF;AAGA,mBAAS,IAAI,GAAG,IAAI,aAAa,KAAK;AACpC,kBAAM,QAAQ,cAAc,CAAC;AAC7B,kBAAM,WAAW,cAAc,CAAC,IAAI,CAAC;AAErC,gBAAI,UAAU;AAEZ,oBAAMA,aAAYF,MAAK,eAAe,QAAQ,uBAAuB,KAAK,GAAG,oBAAoB,CAAC,GAAG,CAAC;AACtG,kBAAIE,eAAc,GAAG;AACnB,+BAAe,mCAAmC,CAAC,iBAAiB,SAAS,GAAG;AAAA,cAClF;AAAA,YACF,OAAO;AAEL,oBAAMA,aACFF,MAAK,eAAe,QAAQ,uBAAuB,KAAK,GAAG,GAAG,gCAAgC,KAAK,CAAC;AACxG,kBAAIE,eAAc,GAAG;AACnB,+BAAe,qBAAqB,CAAC,QAAQ,yBAAyB,CAAC,CAAC,gBAAgB,SAAS,GAAG;AAAA,cACtG;AAAA,YACF;AAAA,UACF;AACA,yBAAe;AAAA,YACX;AAAA,YACA,CAAC,eAAe,uBAAuB,wBAAwB,gBAAgB,oBAAoB,IAAI;AAAA,UAAC;AAAA,QAC9G;AAEA,QAAAF,MAAK,iBAAiB,aAAa;AACnC,YAAI;AACJ,YAAkC,gBAAgB;AAChD,sBAAY,MAAMA,MAAK;AAAA,YACnB;AAAA,YAAe,eAAe;AAAA,YAAQ;AAAA,YAAa;AAAA,YAAoB;AAAA,UAAgB;AAAA,QAC7F,OAAO;AACL,sBAAY,MAAMA,MAAK;AAAA,YACnB;AAAA,YAAe;AAAA,YAAkB;AAAA,YAAmB;AAAA,YAAY;AAAA,YAAmB;AAAA,YACnF;AAAA,YAAoB;AAAA,UAAgB;AAAA,QAC1C;AAEA,YAAI,cAAc,GAAG;AACnB,yBAAe,0BAA0B;AAAA,QAC3C;AAEA,cAAM,SAA2B,CAAC;AAElC,iBAAS,IAAI,GAAG,IAAI,aAAa,KAAK;AACpC,gBAAM,SAASA,MAAK,QAAQ,qBAAqB,IAAI,CAAC;AACtD,cAAI,WAAW,oBAAoB,CAAC,GAAG;AAErC,mBAAO,KAAK,cAAc,CAAC,CAAE;AAC7B;AAAA,UACF;AAEA,gBAAM,2BAA2BA,MAAK,UAAU;AAEhD,gBAAM,mBAAmBA,MAAK,WAAW,IAAI,CAAC;AAE9C,cAAI,mBAAmB;AACvB,cAAI,MAA6B,aAAa;AAC9C,cAAI;AACF,kBAAME,aAAYF,MAAK;AAAA,cACnB;AAAA,cAAQ;AAAA,cAAkB,mBAAmB;AAAA,cAAG,mBAAmB;AAAA,cAAG,mBAAmB;AAAA,YAAE;AAC/F,gBAAIE,eAAc,GAAG;AACnB,6BAAe,4CAA4C,CAAC,GAAG;AAAA,YACjE;AACA,gBAAI,kBAAkB,mBAAmB;AACzC,kBAAM,WAAWF,MAAK,QAAQ,iBAAiB;AAC/C,yBAAaA,MAAK,QAAQ,iBAAiB;AAC3C,kBAAM,aAAaA,MAAK,QAAQ,iBAAiB;AACjD,kBAAM,aAAaA,MAAK,QAAQ,iBAAiB;AACjD,kBAAM,OAAO,CAAC;AACd,qBAASG,KAAI,GAAGA,KAAI,YAAYA,MAAK;AACnC,mBAAK,KAAKH,MAAK,QAAQ,aAAa,IAAIG,EAAC,CAAC;AAAA,YAC5C;AACA,YAAAH,MAAK,SAAS,UAAU;AAExB,kBAAM,OAAO,KAAK,OAAO,CAAC,GAAG,MAAM,IAAI,GAAG,CAAC;AAC3C,mBAAO,2BAA2B,QAAQ;AAE1C,kBAAM,oBAAoB,gBAAgB,yBAAyB,cAAc,CAAC,CAAC;AAEnF,gBAAI,SAAS,UAAU;AACrB,kBAAI,sBAAsB,cAAc;AACtC,sBAAM,IAAI,MAAM,wCAAwC;AAAA,cAC1D;AACA,oBAAM,aAAuB,CAAC;AAC9B,kBAAI,YAAY,aAAa;AAC7B,uBAASG,KAAI,GAAGA,KAAI,MAAMA,MAAK;AAC7B,sBAAM,SAASH,MAAK,QAAQ,WAAW;AACvC,sBAAM,iBAAiBG,OAAM,OAAO,IAAI,SAAYH,MAAK,QAAQ,SAAS,IAAI;AAC9E,2BAAW,KAAKA,MAAK,aAAa,QAAQ,cAAc,CAAC;AAAA,cAC3D;AACA,qBAAO,KAAK,CAAC,MAAM,MAAM,YAAY,KAAK,CAAC;AAAA,YAC7C,OAAO;AAGL,kBAAI,sBAAsB,gBAAgB,OAAO,GAAG;AAClD,sBAAM,YAAYA,MAAK;AACvB,oBAAI,CAAC,WAAW;AACd,wBAAM,IAAI,MAAM,uEAAuE;AAAA,gBACzF;AACA,sBAAM,YAAY,UAAU,UAAU;AACtC,sBAAM,cAAc,qBAAqB,QAAQ;AACjD,oBAAI,gBAAgB,UAAa,CAAC,yBAAyB,IAAI,GAAG;AAChE,wBAAM,IAAI,MAAM,0BAA0B,IAAI,EAAE;AAAA,gBAClD;AAGA,mCAAmB;AAEnB,uBAAO,KAAK;AAAA,kBACV;AAAA,kBAAM;AAAA,kBAAM;AAAA,oBACV;AAAA,oBACA,UAAUA,MAAK,qBAAsB,WAAW,OAAO,aAAa,IAAI;AAAA,oBACxE,SAAS,MAAM;AACb,sBAAAA,MAAK,kBAAkB,MAAM;AAAA,oBAC/B;AAAA,kBACF;AAAA,kBACA;AAAA,gBACF,CAAC;AAAA,cACH,OAAO;AACL,sBAAM,wBAAwB,kCAAkC,IAAI;AACpE,sBAAM,OAAO,IAAI,sBAAsB,IAAI;AAC3C,oBAAI,WAAW,KAAK,QAAQ,KAAK,YAAY,KAAK,UAAU,EACvD,IAAIA,MAAK,OAAO,SAAS,YAAY,aAAa,KAAK,UAAU,CAAC;AACvE,uBAAO,KAAK,CAAC,MAAM,MAAM,MAAM,KAAK,CAAC;AAAA,cACvC;AAAA,YACF;AAAA,UACF,UAAE;AACA,YAAAA,MAAK,aAAa,wBAAwB;AAC1C,gBAAI,SAAS,YAAY,YAAY;AACnC,cAAAA,MAAK,MAAM,UAAU;AAAA,YACvB;AACA,gBAAI,CAAC,kBAAkB;AACrB,cAAAA,MAAK,kBAAkB,MAAM;AAAA,YAC/B;AAAA,UACF;AAAA,QACF;AAEA,YAAI,kBAAkB,CAAC,oBAAoB;AACzC,UAAAA,MAAK,sBAAsB,eAAe,MAAM;AAChD,yBAAe;AAAA,YACX;AAAA,YACA,CAAC,eAAe,uBAAuB,wBAAwB,gBAAgB,oBAAoB,KAAK;AAAA,UAAC;AAAA,QAC/G;AACA,eAAO;AAAA,MACT,UAAE;AACA,QAAAA,MAAK,aAAa,cAAc;AAEhC,2BAAmB,QAAQ,OAAKA,MAAK,kBAAkB,CAAC,CAAC;AACzD,4BAAoB,QAAQ,OAAKA,MAAK,kBAAkB,CAAC,CAAC;AAC1D,0BAAkB,QAAQ,OAAKA,MAAK,MAAM,CAAC,CAAC;AAE5C,YAAI,qBAAqB,GAAG;AAC1B,UAAAA,MAAK,sBAAsB,gBAAgB;AAAA,QAC7C;AACA,yBAAiB,QAAQ,OAAKA,MAAK,MAAM,CAAC,CAAC;AAAA,MAC7C;AAAA,IACF;AAKO,IAAM,eAAe,CAAC,cAA4B;AACvD,YAAMA,QAAO,YAAY;AACzB,YAAM,UAAU,eAAe,IAAI,SAAS;AAC5C,UAAI,CAAC,SAAS;AACZ,cAAM,IAAI,MAAM,oBAAoB;AAAA,MACtC;AACA,YAAM,gBAAgB,QAAQ,CAAC;AAG/B,YAAM,kBAAkBA,MAAK,iBAAiB,aAAa;AAC3D,UAAI,oBAAoB,GAAG;AACzB,uBAAe,iCAAkC;AAAA,MACnD;AACA,MAAAA,MAAK,SAAS,eAAe;AAAA,IAC/B;AAEO,IAAM,6BAA6B,CAAC,YAAsE;AAC/G,YAAM,UAA6B,CAAC;AACpC,iBAAW,UAAU,SAAS;AAC5B,cAAM,OAAO,OAAO,CAAC;AACrB,YAAI,CAAC,MAAM,QAAQ,IAAI,KAAK,YAAY,MAAM;AAC5C,kBAAQ,KAAK,KAAK,MAAM;AAAA,QAC1B;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAAA;AAAA;;;AC3sBA;AAAA;AAAA;AAAA;AAAA;;;ACAA,IASM,SACF,aACAI,eACAC,cACAC,UAGA,mBACE,iBAEA,kBASA,cAMA,sBA8BA,WAEO,oCAsDA,iBAaAC,yBAaAC,gBAuBAC,iBAaAC,MAyBAC;AA/Mb;AAAA;AAAA;AAGA;AAGA;AACA;AAEA,IAAM,UAAU,MAAe,CAAC,CAACC,KAAI,KAAK,SAAS,OAAO,aAAa;AAEvE,IAAIR,gBAAe;AACnB,IAAIC,eAAc;AAClB,IAAIC,WAAU;AAId,IAAM,kBAAiF,oBAAI,IAAI;AAE/F,IAAM,mBAAmB,CAAC,MAA8B,cAA+C;AACrG,YAAM,QAAQ,gBAAgB,IAAI,IAAI;AACtC,UAAI,OAAO;AACT,cAAM,KAAK,SAAS;AAAA,MACtB,OAAO;AACL,wBAAgB,IAAI,MAAM,CAAC,SAAS,CAAC;AAAA,MACvC;AAAA,IACF;AAEA,IAAM,eAAe,MAAY;AAC/B,UAAIF,iBAAgB,CAACC,gBAAeC,YAAW,CAAC,aAAa;AAC3D,cAAM,IAAI,MAAM,kBAAkB;AAAA,MACpC;AAAA,IACF;AAEA,IAAM,uBAAuB,CAAC,OAA2C;AACvE,cAAQ,GAAG,KAAK,MAAM;AAAA,QACpB,KAAK;AACH,UAAAF,gBAAe;AACf,cAAI,GAAG,KAAK,KAAK;AACf,YAAAE,WAAU;AACV,8BAAkB,CAAC,EAAE,GAAG,KAAK,GAAG;AAAA,UAClC,OAAO;AACL,YAAAD,eAAc;AACd,8BAAkB,CAAC,EAAE;AAAA,UACvB;AACA;AAAA,QACF,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,QACL,KAAK,iBAAiB;AACpB,gBAAM,YAAY,gBAAgB,IAAI,GAAG,KAAK,IAAI;AAClD,cAAI,GAAG,KAAK,KAAK;AACf,sBAAU,MAAM,EAAG,CAAC,EAAE,GAAG,KAAK,GAAG;AAAA,UACnC,OAAO;AACL,sBAAU,MAAM,EAAG,CAAC,EAAE,GAAG,KAAK,GAAI;AAAA,UACpC;AACA;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAEA,IAAM,YAAY,OAAO,aAAa,cAAe,UAAU,eAAqC,MAAM;AAEnG,IAAM,qCAAqC,YAA0B;AAC1E,UAAIA,cAAa;AACf;AAAA,MACF;AACA,UAAID,eAAc;AAChB,cAAM,IAAI,MAAM,0CAA4C;AAAA,MAC9D;AACA,UAAIE,UAAS;AACX,cAAM,IAAI,MAAM,uCAAyC;AAAA,MAC3D;AAEA,MAAAF,gBAAe;AAEf,UAAsC,QAAQ,GAAG;AAE/C,YAAIQ,KAAI,KAAK,cAAc,QAAW;AACpC,cAAI,aAAa,UAAU,QAAQ,OAAO,MAAM,GAAG;AACjD,YAAAA,KAAI,KAAK,YAAY,UAAU,OAAO,GAAG,CAAE,UAAW,YAAY,GAAG,IAAI,CAAC;AAAA,UAC5E;AAAA,QACF;AAEA,eAAO,IAAI,QAAc,CAAC,SAAS,WAAW;AAC5C,uBAAa,UAAU;AAEvB,gBAAM,YAAY,IAAI,gBAAgB,IAAI;AAAA,YACtC;AAAA;AAAA;AAAA,cAGE;AAAA,YACF;AAAA,YACA,EAAC,MAAM,kBAAiB;AAAA,UAAC,CAAC;AAC9B,wBAAc,IAAI,OAAO,WAAW,EAAC,MAAM,wBAAuB,CAAC;AACnE,sBAAY,UAAU,CAAC,OAAmB,OAAO,EAAE;AACnD,sBAAY,YAAY;AACxB,cAAI,gBAAgB,SAAS;AAC7B,8BAAoB,CAAC,SAAS,MAAM;AACpC,gBAAM,UAA0B,EAAC,MAAM,aAAa,IAAKA,KAAG;AAC5D,sBAAY,YAAY,OAAO;AAAA,QACjC,CAAC;AAAA,MAEH,OAAO;AACL,YAAI;AACF,gBAAM,sBAAsBA,KAAI,IAAI;AACpC,gBAAW,YAAYA,IAAG;AAC1B,UAAAP,eAAc;AAAA,QAChB,SAAS,GAAG;AACV,UAAAC,WAAU;AACV,gBAAM;AAAA,QACR,UAAE;AACA,UAAAF,gBAAe;AAAA,QACjB;AAAA,MACF;AAAA,IACF;AAEO,IAAM,kBAAkB,OAAM,WAAkC;AACrE,UAAsC,QAAQ,GAAG;AAC/C,qBAAa;AACb,eAAO,IAAI,QAAc,CAAC,SAAS,WAAW;AAC5C,2BAAiB,WAAW,CAAC,SAAS,MAAM,CAAC;AAC7C,gBAAM,UAA0B,EAAC,MAAM,WAAW,IAAK,EAAC,QAAQ,KAAAQ,KAAG,EAAC;AACpE,sBAAa,YAAY,OAAO;AAAA,QAClC,CAAC;AAAA,MACH,OAAO;AACL,cAAW,OAAOA,MAAK,MAAM;AAAA,MAC/B;AAAA,IACF;AAEO,IAAML,0BAAyB,OAAM,WAA4D;AACtG,UAAsC,QAAQ,GAAG;AAC/C,qBAAa;AACb,eAAO,IAAI,QAAoC,CAAC,SAAS,WAAW;AAClE,2BAAiB,aAAa,CAAC,SAAS,MAAM,CAAC;AAC/C,gBAAM,UAA0B,EAAC,MAAM,aAAa,IAAK,EAAC,OAAM,EAAC;AACjE,sBAAa,YAAY,SAAS,CAAC,OAAO,MAAM,CAAC;AAAA,QACnD,CAAC;AAAA,MACH,OAAO;AACL,eAAY,uBAAuB,MAAM;AAAA,MAC3C;AAAA,IACF;AAEO,IAAMC,iBACT,OAAM,OAA8C,YACR;AACtC,UAAsC,QAAQ,GAAG;AAE/C,YAAI,SAAS,yBAAyB;AACpC,gBAAM,IAAI,MAAM,sEAAsE;AAAA,QACxF;AACA,qBAAa;AACb,eAAO,IAAI,QAAqC,CAAC,SAAS,WAAW;AACnE,2BAAiB,UAAU,CAAC,SAAS,MAAM,CAAC;AAC5C,gBAAM,UAA0B,EAAC,MAAM,UAAU,IAAK,EAAC,OAAO,SAAS,EAAC,GAAG,QAAO,EAAC,EAAC;AACpF,gBAAM,eAA+B,CAAC;AACtC,cAAI,iBAAiB,YAAY;AAC/B,yBAAa,KAAK,MAAM,MAAM;AAAA,UAChC;AACA,sBAAa,YAAY,SAAS,YAAY;AAAA,QAChD,CAAC;AAAA,MACH,OAAO;AACL,eAAY,cAAc,OAAO,OAAO;AAAA,MAC1C;AAAA,IACF;AAED,IAAMC,kBAAiB,OAAM,cAAqC;AACvE,UAAsC,QAAQ,GAAG;AAC/C,qBAAa;AACb,eAAO,IAAI,QAAc,CAAC,SAAS,WAAW;AAC5C,2BAAiB,WAAW,CAAC,SAAS,MAAM,CAAC;AAC7C,gBAAM,UAA0B,EAAC,MAAM,WAAW,IAAK,UAAS;AAChE,sBAAa,YAAY,OAAO;AAAA,QAClC,CAAC;AAAA,MACH,OAAO;AACL,QAAK,eAAe,SAAS;AAAA,MAC/B;AAAA,IACF;AAEO,IAAMC,OAAM,OACf,WAAmB,cAAwB,QAA0B,eACrE,SAAqC,YAAoE;AAC3G,UAAsC,QAAQ,GAAG;AAE/C,YAAI,OAAO,KAAK,OAAK,EAAE,CAAC,MAAM,KAAK,GAAG;AACpC,gBAAM,IAAI,MAAM,iDAAiD;AAAA,QACnE;AAEA,YAAI,QAAQ,KAAK,OAAK,CAAC,GAAG;AACxB,gBAAM,IAAI,MAAM,yDAAyD;AAAA,QAC3E;AACA,qBAAa;AACb,eAAO,IAAI,QAAsC,CAAC,SAAS,WAAW;AACpE,2BAAiB,OAAO,CAAC,SAAS,MAAM,CAAC;AACzC,gBAAM,qBAAqB;AAC3B,gBAAM,UACF,EAAC,MAAM,OAAO,IAAK,EAAC,WAAW,cAAc,QAAQ,oBAAoB,eAAe,QAAO,EAAC;AACpG,sBAAa,YAAY,SAAc,2BAA2B,kBAAkB,CAAC;AAAA,QACvF,CAAC;AAAA,MACH,OAAO;AACL,eAAY,IAAI,WAAW,cAAc,QAAQ,eAAe,SAAS,OAAO;AAAA,MAClF;AAAA,IACF;AAEO,IAAMC,gBAAe,OAAM,cAAqC;AACrE,UAAsC,QAAQ,GAAG;AAC/C,qBAAa;AACb,eAAO,IAAI,QAAc,CAAC,SAAS,WAAW;AAC5C,2BAAiB,iBAAiB,CAAC,SAAS,MAAM,CAAC;AACnD,gBAAM,UAA0B,EAAC,MAAM,iBAAiB,IAAK,UAAS;AACtE,sBAAa,YAAY,OAAO;AAAA,QAClC,CAAC;AAAA,MACH,OAAO;AACL,QAAK,aAAa,SAAS;AAAA,MAC7B;AAAA,IACF;AAAA;AAAA;;;AC1NA,IAUa,sBAWA,sBAiBA;AAtCb;AAAA;AAAA;AAGA;AAGA;AACA;AACA;AAEO,IAAM,uBAAuB,CAAC,QAAgB,YAA0C;AAC7F,cAAQ,OAAO,UAAU;AAAA,QACvB,KAAK;AACH,iBAAO,CAAC,OAAO,MAAM,OAAO,MAAM,OAAO,MAAM,KAAK;AAAA,QACtD,KAAK;AACH,iBAAO,CAAC,OAAO,MAAM,OAAO,MAAM,EAAC,WAAW,OAAO,UAAS,GAAG,YAAY;AAAA,QAC/E;AACE,gBAAM,IAAI,MAAM,0BAA0B,OAAO,QAAQ,QAAQ,QAAQ,CAAC,EAAE;AAAA,MAChF;AAAA,IACF;AAEO,IAAM,uBAAuB,CAAC,WAAmC;AACtE,cAAQ,OAAO,CAAC,GAAG;AAAA,QACjB,KAAK;AACH,iBAAO,IAAIE,QAAO,OAAO,CAAC,GAAG,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC;AAAA,QACnD,KAAK,cAAc;AACjB,gBAAM,WAAW,OAAO,CAAC;AACzB,cAAI,CAAC,yBAAyB,QAAQ,GAAG;AACvC,kBAAM,IAAI,MAAM,4BAA4B,QAAQ,+BAA+B;AAAA,UACrF;AACA,gBAAM,EAAC,WAAW,UAAU,QAAO,IAAI,OAAO,CAAC;AAC/C,iBAAOA,QAAO,cAAc,WAAW,EAAC,UAAU,MAAM,OAAO,CAAC,GAAG,UAAU,QAAO,CAAC;AAAA,QACvF;AAAA,QACA;AACE,gBAAM,IAAI,MAAM,0BAA0B,OAAO,CAAC,CAAC,EAAE;AAAA,MACzD;AAAA,IACF;AAEO,IAAM,uCAAN,MAA8E;AAAA,MAMnF,MAAM,8BAA8B,MAAmD;AAErF,eAAOC,wBAAuB,MAAM,SAAS,IAAI,CAAC;AAAA,MACpD;AAAA,MAEA,MAAM,UAAU,cAAiC,SAA0D;AACzG,yBAAiB;AACjB,YAAI;AAEJ,YAAI,OAAO,iBAAiB,UAAU;AACpC,cAAI,OAAO,YAAY,eAAe,QAAQ,YAAY,QAAQ,SAAS,MAAM;AAE/E,oBAAQ,MAAM,SAAS,YAAY;AAAA,UACrC,OAAO;AAGL,oBAAQ,MAAM,KAAK,8BAA8B,YAAY;AAAA,UAC/D;AAAA,QACF,OAAO;AACL,kBAAQ;AAAA,QACV;AAEA,SAAC,KAAK,WAAW,KAAK,YAAY,KAAK,WAAW,IAAI,MAAMC,eAAc,OAAO,OAAO;AACxF,uBAAe;AAAA,MACjB;AAAA,MAEA,MAAM,UAAyB;AAC7B,eAAOC,gBAAe,KAAK,SAAS;AAAA,MACtC;AAAA,MAEA,MAAM,IAAI,OAAiC,SAAqC,SACzC;AACrC,yBAAiB;AACjB,cAAM,aAAuB,CAAC;AAC9B,cAAM,eAAyB,CAAC;AAChC,eAAO,QAAQ,KAAK,EAAE,QAAQ,SAAO;AACnC,gBAAM,OAAO,IAAI,CAAC;AAClB,gBAAM,SAAS,IAAI,CAAC;AACpB,gBAAM,QAAQ,KAAK,WAAW,QAAQ,IAAI;AAC1C,cAAI,UAAU,IAAI;AAChB,kBAAM,IAAI,MAAM,kBAAkB,IAAI,GAAG;AAAA,UAC3C;AACA,qBAAW,KAAK,MAAM;AACtB,uBAAa,KAAK,KAAK;AAAA,QACzB,CAAC;AAED,cAAM,cAAkC,CAAC;AACzC,cAAM,gBAA0B,CAAC;AACjC,eAAO,QAAQ,OAAO,EAAE,QAAQ,SAAO;AACrC,gBAAM,OAAO,IAAI,CAAC;AAClB,gBAAM,SAAS,IAAI,CAAC;AACpB,gBAAM,QAAQ,KAAK,YAAY,QAAQ,IAAI;AAC3C,cAAI,UAAU,IAAI;AAChB,kBAAM,IAAI,MAAM,mBAAmB,IAAI,GAAG;AAAA,UAC5C;AACA,sBAAY,KAAK,MAAM;AACvB,wBAAc,KAAK,KAAK;AAAA,QAC1B,CAAC;AAED,cAAM,SACF,WAAW,IAAI,CAAC,GAAG,MAAM,qBAAqB,GAAG,MAAM,UAAU,KAAK,WAAW,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC;AACzG,cAAM,UAAU,YAAY;AAAA,UACxB,CAAC,GAAG,MAAM,IAAI,qBAAqB,GAAG,MAAM,WAAW,KAAK,YAAY,cAAc,CAAC,CAAC,CAAC,GAAG,IAAI;AAAA,QAAI;AAExG,cAAM,UAAU,MAAMC,KAAI,KAAK,WAAW,cAAc,QAAQ,eAAe,SAAS,OAAO;AAE/F,cAAM,YAAuC,CAAC;AAC9C,iBAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,oBAAU,KAAK,YAAY,cAAc,CAAC,CAAC,CAAC,IAAI,YAAY,CAAC,KAAK,qBAAqB,QAAQ,CAAC,CAAC;AAAA,QACnG;AACA,uBAAe;AACf,eAAO;AAAA,MACT;AAAA,MAEA,iBAAuB;AAAA,MAEvB;AAAA,MAEA,eAAqB;AACnB,aAAKC,cAAa,KAAK,SAAS;AAAA,MAClC;AAAA,IACF;AAAA;AAAA;;;AC7HA,IAea,iBA6BA;AA5Cb;AAAA;AAAA;AAGA;AACA;AAEA;AACA;AAQO,IAAM,kBAAkB,MAAY;AACzC,UAAI,OAAOC,KAAI,KAAK,gBAAgB,YAAYA,KAAI,KAAK,cAAc,GAAG;AACxE,QAAAA,KAAI,KAAK,cAAc;AAAA,MACzB;AAEA,UAAI,OAAOA,KAAI,KAAK,SAAS,WAAW;AACtC,QAAAA,KAAI,KAAK,OAAO;AAAA,MAClB;AAEA,UAAI,OAAOA,KAAI,KAAK,UAAU,WAAW;AACvC,QAAAA,KAAI,KAAK,QAAQ;AAAA,MACnB;AAEA,UAAI,OAAOA,KAAI,KAAK,UAAU,WAAW;AACvC,QAAAA,KAAI,KAAK,QAAQ;AAAA,MACnB;AAEA,UAAI,OAAOA,KAAI,KAAK,eAAe,YAAY,CAAC,OAAO,UAAUA,KAAI,KAAK,UAAU,KAAKA,KAAI,KAAK,cAAc,GAAG;AAGjH,YAAK,OAAO,SAAS,eAAe,CAAC,KAAK,uBACrC,OAAO,YAAY,eAAe,QAAQ,YAAY,QAAQ,SAAS,MAAO;AACjF,UAAAA,KAAI,KAAK,aAAa;AAAA,QACxB;AACA,cAAM,qBAAqB,OAAO,cAAc,cAAc,KAAK,EAAE,SAAS,UAAU;AACxF,QAAAA,KAAI,KAAK,aAAa,KAAK,IAAI,GAAG,KAAK,MAAM,sBAAsB,KAAK,CAAC,CAAC;AAAA,MAC5E;AAAA,IACF;AAEO,IAAM,gCAAN,MAAuD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAS5D,MAAM,KAAK,aAAoC;AAE7C,wBAAgB;AAGhB,cAAM,mCAAmC;AAGzC,cAAM,gBAAgB,WAAW;AAAA,MACnC;AAAA,MAKA,MAAM,8BAA8B,cAAiC,SAChC;AACnC,cAAM,UAAU,IAAI,qCAAqC;AACzD,cAAM,QAAQ,UAAU,cAAc,OAAO;AAC7C,eAAO,QAAQ,QAAQ,OAAO;AAAA,MAChC;AAAA,IACF;AAAA;AAAA;;;ACzEA;AAAA;AAAA;AAAA;AAAA,IAIa;AAJb;AAAA;AAAA;AAGA;AACO,IAAM,cAAc,IAAI,8BAA8B;AAAA;AAAA;;;ACI7D;AACA;AAGA;;;ACNO,IAAMC,WAAU;;;ADIvB,IAAO,cAAQ;AAKf,IAAI,OAA2B;AAC7B,QAAM,gBAAgB,KAA4B;AAClD,kBAAgB,SAAS,eAAe,GAAG;AAC7C;AAEA,IAAI,MAA0B;AAC5B,QAAMC,eAAc,OAA8B,8EAAoC,cACpC,KAAmC;AACrF,MAAI,MAA4B;AAC9B,oBAAgB,UAAUA,cAAa,CAAC;AACxC,oBAAgB,SAASA,cAAa,CAAC;AAAA,EACzC;AACA,kBAAgB,OAAOA,cAAa,EAAE;AACtC,kBAAgB,QAAQA,cAAa,EAAE;AACzC;AAEA,OAAO,eAAeC,KAAI,UAAU,OAAO,EAAC,OAAOC,UAAS,YAAY,KAAI,CAAC;",
  "names": ["i", "env", "Tensor", "Tensor", "InferenceSession", "Tensor", "TrainingSession", "InferenceSession", "Tensor", "TrainingSession", "env", "join", "cpus", "wasm", "wasm", "wasm", "readFile", "readFile", "pad", "init", "offsets", "indices", "impl", "validateInputs", "reduceOps", "validateInputs", "validateInputs", "i", "validateInputs", "env", "validateInputs", "validateInputs", "a", "b", "transpose", "outputVariable", "innerElementSize", "validateInputs", "validateInputs", "outputShape", "transposedWeight", "convInputs", "innerElementSize", "validateInputs", "validateInputs", "permFunctionBody", "symbol", "reduceOps", "validateInputs", "calculateOutputShape", "fastGelu", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "dataType", "validateInputs", "weightTransposeAttribute", "validateInputs", "validateInputs", "env", "env", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "components", "validateInputs", "validateInputs", "getOutputShape", "a", "b", "c", "fastGelu", "env", "i", "env", "env", "wasm", "tensor", "errorCode", "i", "initializing", "initialized", "aborted", "copyFromExternalBuffer", "createSession", "releaseSession", "run", "endProfiling", "env", "Tensor", "copyFromExternalBuffer", "createSession", "releaseSession", "run", "endProfiling", "env", "version", "wasmBackend", "env", "version"]
}
