Quelle ort-dev.mjs Sprache: unbekannt

Spracherkennung für: .mjs vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen]

/*!
* ONNX Runtime Web v1.20.1
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License.
*/
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
 get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
 if (typeof require !== "undefined")
 return require.apply(this, arguments);
 throw Error('Dynamic require of "' + x + '" is not supported');
});
var __esm = (fn, res) => function __init() {
 return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod2) => function __require2() {
 return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
};
var __export = (target, all) => {
 for (var name2 in all)
 __defProp(target, name2, { get: all[name2], 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 __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
 // If the importer is in node compatibility mode or this is not an ESM
 // file that has been converted to a CommonJS file using a Babel-
 // compatible transform (i.e. "__esModule" has not been set), then set
 // "default" to the CommonJS "module.exports" for node compatibility.
 isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
 mod2
));
var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);

// 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 = (name2, backend2, priority) => {
 if (backend2 && typeof backend2.init === "function" && typeof backend2.createInferenceSessionHandler === "function") {
 const currentBackend = backends.get(name2);
 if (currentBackend === void 0) {
 backends.set(name2, { backend: backend2, priority });
 } else if (currentBackend.priority > priority) {
 return;
 } else if (currentBackend.priority === priority) {
 if (currentBackend.backend !== backend2) {
 throw new Error(`cannot register backend "${name2}" using priority ${priority}`);
 }
 }
 if (priority >= 0) {
 const i = backendsSortedByPriority.indexOf(name2);
 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, name2);
 return;
 }
 }
 backendsSortedByPriority.push(name2);
 }
 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 backend2;
 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 (!backend2) {
 backend2 = resolveResult;
 }
 if (backend2 === resolveResult) {
 availableBackendNames.add(backendName);
 }
 }
 }
 if (!backend2) {
 throw new Error(`no available backend found. ERR: ${errors.map((e) => `[${e.name}] ${e.err}`).join(", ")}`);
 }
 for (const { name: name2, err } of errors) {
 if (backendHints.includes(name2)) {
 console.warn(`removing requested execution provider "${name2}" from session options because it is not available: ${err}`);
 }
 }
 const filteredEps = eps.filter((i) => availableBackendNames.has(typeof i === "string" ? i : i.name));
 return [
 backend2,
 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.20.1";
 }
});

// 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, tensorFromMLTensor, 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 createCanvas2 = () => {
 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 (typeof HTMLCanvasElement !== "undefined" && canvas instanceof HTMLCanvasElement) {
 return canvas.getContext("2d");
 } else if (canvas instanceof OffscreenCanvas) {
 return canvas.getContext("2d");
 } else {
 return null;
 }
 };
 if (isHTMLImageEle) {
 const canvas = createCanvas2();
 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 = createCanvas2();
 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 = createCanvas2();
 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 = createCanvas2();
 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 });
 };
 tensorFromMLTensor = (mlTensor, options) => {
 const { dataType, dims, download, dispose } = options;
 return new Tensor({ location: "ml-tensor", type: dataType ?? "float32", mlTensor, 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],
 ["int4", Uint8Array],
 ["uint4", Uint8Array]
 ]);
 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
 });
 case "ml-tensor":
 return new Tensor({
 location: "ml-tensor",
 mlTensor: tensor.mlTensor,
 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" && type !== "uint4" && type !== "int4") {
 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;
 }
 case "ml-tensor": {
 if (type !== "float32" && type !== "float16" && type !== "int32" && type !== "int64" && type !== "uint32" && type !== "uint64" && type !== "int8" && type !== "uint8" && type !== "bool") {
 throw new TypeError(`unsupported type "${type}" to create tensor from MLTensor`);
 }
 this.mlTensorData = arg0.mlTensor;
 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 || arg0 === "uint4" || arg0 === "int4") {
 throw new TypeError(`Creating a ${arg0} tensor from number array is not supported. Please use ${typedArrayConstructor.name} 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 if (arg1 instanceof Uint8ClampedArray) {
 if (arg0 === "uint8") {
 data = Uint8Array.from(arg1);
 } else {
 throw new TypeError(`A Uint8ClampedArray tensor's data must be type of uint8`);
 }
 } 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 if (arg0 instanceof Uint8ClampedArray) {
 type = "uint8";
 data = Uint8Array.from(arg0);
 } 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) {
 if ((type === "uint4" || type === "int4") && Math.ceil(size / 2) === this.cpuData.length) {
 } else {
 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 fromMLTensor(mlTensor, options) {
 return tensorFromMLTensor(mlTensor, 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;
 }
 get mlTensor() {
 this.ensureValid();
 if (!this.mlTensorData) {
 throw new Error("The data is not stored as a WebNN MLTensor.");
 }
 return this.mlTensorData;
 }
 // #endregion
 // #region methods
 async getData(releaseData) {
 this.ensureValid();
 switch (this.dataLocation) {
 case "cpu":
 case "cpu-pinned":
 return this.data;
 case "texture":
 case "gpu-buffer":
 case "ml-tensor": {
 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.mlTensorData = 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 name2 of arg1) {
 if (typeof name2 !== "string") {
 throw new TypeError("'fetches' must be a string array or an object.");
 }
 if (this.outputNames.indexOf(name2) === -1) {
 throw new RangeError(`'fetches' contains invalid output name: ${name2}.`);
 }
 fetches[name2] = 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 name2 of this.outputNames) {
 if (arg1Keys.indexOf(name2) !== -1) {
 const v = arg1[name2];
 if (v === null || v instanceof Tensor2) {
 isFetches = true;
 isFetchesEmpty = false;
 fetches[name2] = 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 name2 of this.inputNames) {
 if (typeof feeds[name2] === "undefined") {
 throw new Error(`input '${name2}' is missing in 'feeds'.`);
 }
 }
 if (isFetchesEmpty) {
 for (const name2 of this.outputNames) {
 fetches[name2] = 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 [backend2, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);
 const handler = await backend2.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 [backend2, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);
 if (backend2.createTrainingSessionHandler) {
 const handler = await backend2.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 name2 of arg1) {
 if (typeof name2 !== "string") {
 throw new TypeError("'fetches' must be a string array or an object.");
 }
 if (outputNames.indexOf(name2) === -1) {
 throw new RangeError(`'fetches' contains invalid output name: ${name2}.`);
 }
 fetches[name2] = 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 name2 of outputNames) {
 if (arg1Keys.indexOf(name2) !== -1) {
 const v = arg1[name2];
 if (v === null || v instanceof Tensor2) {
 isFetches = true;
 isFetchesEmpty = false;
 fetches[name2] = 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 name2 of inputNames) {
 if (typeof feeds[name2] === "undefined") {
 throw new Error(`input '${name2}' is missing in 'feeds'.`);
 }
 }
 if (isFetchesEmpty) {
 for (const name2 of outputNames) {
 fetches[name2] = 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();
 }
});

// web/lib/onnxjs/instrument.ts
function log(arg0, arg1, arg2, arg3) {
 if (arg1 === void 0) {
 return createCategorizedLogger(arg0);
 } else if (arg2 === void 0) {
 logInternal(arg0, arg1, 1);
 } else if (typeof arg2 === "number" && arg3 === void 0) {
 logInternal(arg0, arg1, arg2);
 } else if (typeof arg2 === "string" && arg3 === void 0) {
 logInternal(arg0, arg2, 1, arg1);
 } else if (typeof arg2 === "string" && typeof arg3 === "number") {
 logInternal(arg0, arg2, arg3, arg1);
 } else {
 throw new TypeError("input is valid");
 }
}
function createCategorizedLogger(category) {
 return {
 verbose: log.verbose.bind(null, category),
 info: log.info.bind(null, category),
 warning: log.warning.bind(null, category),
 error: log.error.bind(null, category),
 fatal: log.fatal.bind(null, category)
 };
}
function logInternal(severity, content, _stack, category) {
 const config = LOGGER_CONFIG_MAP[category || ""] || LOGGER_CONFIG_MAP[""];
 if (SEVERITY_VALUE[severity] < SEVERITY_VALUE[config.minimalSeverity]) {
 return;
 }
 if (config.logDateTime) {
 content = `${(/* @__PURE__ */ new Date()).toISOString()}|${content}`;
 }
 if (config.logSourceLocation) {
 }
 LOGGER_PROVIDER_MAP[config.provider].log(severity, content, category);
}
var NoOpLoggerProvider, ConsoleLoggerProvider, SEVERITY_VALUE, LOGGER_PROVIDER_MAP, LOGGER_DEFAULT_CONFIG, LOGGER_CONFIG_MAP, Logger, Event, EventRecord, Profiler, now;
var init_instrument = __esm({
 "web/lib/onnxjs/instrument.ts"() {
 "use strict";
 NoOpLoggerProvider = class {
 log(_severity, _content, _category) {
 }
 };
 ConsoleLoggerProvider = class {
 log(severity, content, category) {
 console.log(`${this.color(severity)} ${category ? "\x1B[35m" + category + "\x1B[0m " : ""}${content}`);
 }
 color(severity) {
 switch (severity) {
 case "verbose":
 return "\x1B[34;40mv\x1B[0m";
 case "info":
 return "\x1B[32mi\x1B[0m";
 case "warning":
 return "\x1B[30;43mw\x1B[0m";
 case "error":
 return "\x1B[31;40me\x1B[0m";
 case "fatal":
 return "\x1B[101mf\x1B[0m";
 default:
 throw new Error(`unsupported severity: ${severity}`);
 }
 }
 };
 SEVERITY_VALUE = {
 verbose: 1e3,
 info: 2e3,
 warning: 4e3,
 error: 5e3,
 fatal: 6e3
 };
 LOGGER_PROVIDER_MAP = {
 ["none"]: new NoOpLoggerProvider(),
 ["console"]: new ConsoleLoggerProvider()
 };
 LOGGER_DEFAULT_CONFIG = {
 provider: "console",
 minimalSeverity: "warning",
 logDateTime: true,
 logSourceLocation: false
 };
 LOGGER_CONFIG_MAP = {
 [""]: LOGGER_DEFAULT_CONFIG
 };
 ((log3) => {
 function verbose(arg0, arg1) {
 log3("verbose", arg0, arg1);
 }
 log3.verbose = verbose;
 function info(arg0, arg1) {
 log3("info", arg0, arg1);
 }
 log3.info = info;
 function warning(arg0, arg1) {
 log3("warning", arg0, arg1);
 }
 log3.warning = warning;
 function error(arg0, arg1) {
 log3("error", arg0, arg1);
 }
 log3.error = error;
 function fatal(arg0, arg1) {
 log3("fatal", arg0, arg1);
 }
 log3.fatal = fatal;
 function reset(config) {
 LOGGER_CONFIG_MAP = {};
 set("", config || {});
 }
 log3.reset = reset;
 function set(category, config) {
 if (category === "*") {
 reset(config);
 } else {
 const previousConfig = LOGGER_CONFIG_MAP[category] || LOGGER_DEFAULT_CONFIG;
 LOGGER_CONFIG_MAP[category] = {
 provider: config.provider || previousConfig.provider,
 minimalSeverity: config.minimalSeverity || previousConfig.minimalSeverity,
 logDateTime: config.logDateTime === void 0 ? previousConfig.logDateTime : config.logDateTime,
 logSourceLocation: config.logSourceLocation === void 0 ? previousConfig.logSourceLocation : config.logSourceLocation
 };
 }
 }
 log3.set = set;
 function setWithEnv(env3) {
 const config = {};
 if (env3.logLevel) {
 config.minimalSeverity = env3.logLevel;
 }
 set("", config);
 }
 log3.setWithEnv = setWithEnv;
 })(log || (log = {}));
 Logger = log;
 Event = class {
 constructor(category, name2, startTime, endCallback, timer, ctx) {
 this.category = category;
 this.name = name2;
 this.startTime = startTime;
 this.endCallback = endCallback;
 this.timer = timer;
 this.ctx = ctx;
 }
 async end() {
 return this.endCallback(this);
 }
 async checkTimer() {
 if (this.ctx === void 0 || this.timer === void 0) {
 throw new Error("No webgl timer found");
 } else {
 this.ctx.endTimer();
 return this.ctx.waitForQueryAndGetTime(this.timer);
 }
 }
 };
 EventRecord = class {
 constructor(category, name2, startTime, endTime) {
 this.category = category;
 this.name = name2;
 this.startTime = startTime;
 this.endTime = endTime;
 }
 };
 Profiler = class {
 constructor(maxNumberEvents, flushBatchSize, flushIntervalInMilliseconds) {
 this._started = false;
 this._flushPointer = 0;
 this._started = false;
 this._maxNumberEvents = maxNumberEvents === void 0 ? 1e4 : maxNumberEvents;
 this._flushBatchSize = flushBatchSize === void 0 ? 10 : flushBatchSize;
 this._flushIntervalInMilliseconds = flushIntervalInMilliseconds === void 0 ? 5e3 : flushIntervalInMilliseconds;
 }
 static create(config) {
 if (config === void 0) {
 return new this();
 }
 return new this(config.maxNumberEvents, config.flushBatchSize, config.flushIntervalInMilliseconds);
 }
 // start profiling
 start() {
 this._started = true;
 this._timingEvents = [];
 this._flushTime = now();
 this._flushPointer = 0;
 }
 // stop profiling
 stop() {
 this._started = false;
 for (; this._flushPointer < this._timingEvents.length; this._flushPointer++) {
 this.logOneEvent(this._timingEvents[this._flushPointer]);
 }
 }
 event(category, name2, func, ctx) {
 const event = this._started ? this.begin(category, name2, ctx) : void 0;
 let isPromise = false;
 const res = func();
 if (res && typeof res.then === "function") {
 isPromise = true;
 return new Promise((resolve, reject) => {
 res.then(
 async (value) => {
 if (event) {
 await event.end();
 }
 resolve(value);
 },
 async (reason) => {
 if (event) {
 await event.end();
 }
 reject(reason);
 }
 );
 });
 }
 if (!isPromise && event) {
 const eventRes = event.end();
 if (eventRes && typeof eventRes.then === "function") {
 return new Promise((resolve, reject) => {
 eventRes.then(
 () => {
 resolve(res);
 },
 (reason) => {
 reject(reason);
 }
 );
 });
 }
 }
 return res;
 }
 // begin an event
 begin(category, name2, ctx) {
 if (!this._started) {
 throw new Error("profiler is not started yet");
 }
 if (ctx === void 0) {
 const startTime = now();
 this.flush(startTime);
 return new Event(category, name2, startTime, (e) => this.endSync(e));
 } else {
 const timer = ctx.beginTimer();
 return new Event(category, name2, 0, async (e) => this.end(e), timer, ctx);
 }
 }
 // end the specific event
 async end(event) {
 const endTime = await event.checkTimer();
 if (this._timingEvents.length < this._maxNumberEvents) {
 this._timingEvents.push(new EventRecord(event.category, event.name, event.startTime, endTime));
 this.flush(endTime);
 }
 }
 endSync(event) {
 const endTime = now();
 if (this._timingEvents.length < this._maxNumberEvents) {
 this._timingEvents.push(new EventRecord(event.category, event.name, event.startTime, endTime));
 this.flush(endTime);
 }
 }
 logOneEvent(event) {
 Logger.verbose(
 `Profiler.${event.category}`,
 `${(event.endTime - event.startTime).toFixed(2)}ms on event '${event.name}' at ${event.endTime.toFixed(2)}`
 );
 }
 flush(currentTime) {
 if (this._timingEvents.length - this._flushPointer >= this._flushBatchSize || currentTime - this._flushTime >= this._flushIntervalInMilliseconds) {
 for (const previousPointer = this._flushPointer; this._flushPointer < previousPointer + this._flushBatchSize && this._flushPointer < this._timingEvents.length; this._flushPointer++) {
 this.logOneEvent(this._timingEvents[this._flushPointer]);
 }
 this._flushTime = now();
 }
 }
 get started() {
 return this._started;
 }
 };
 now = typeof performance !== "undefined" && performance.now ? () => performance.now() : Date.now;
 }
});

// web/lib/onnxjs/opset.ts
function resolveOperator(node, opsets, rules) {
 for (const rule of rules) {
 const opType = rule[0];
 const domain = rule[1];
 const versionSelector = rule[2];
 const opImpl = rule[3];
 const opInit = rule[4];
 if (node.opType === opType) {
 for (const opset of opsets) {
 if (opset.domain === domain || opset.domain === "ai.onnx" && domain === "") {
 if (matchSelector(opset.version, versionSelector)) {
 return { opImpl, opInit };
 }
 }
 }
 }
 }
 throw new TypeError(
 `cannot resolve operator '${node.opType}' with opsets: ${opsets.map((set) => `${set.domain || "ai.onnx"} v${set.version}`).join(", ")}`
 );
}
function matchSelector(version3, selector) {
 if (selector.endsWith("+")) {
 const rangeStart = Number.parseInt(selector.substring(0, selector.length - 1), 10);
 return !isNaN(rangeStart) && rangeStart <= version3;
 } else if (selector.split("-").length === 2) {
 const pair = selector.split("-");
 const rangeStart = Number.parseInt(pair[0], 10);
 const rangeEnd = Number.parseInt(pair[1], 10);
 return !isNaN(rangeStart) && !isNaN(rangeEnd) && rangeStart <= version3 && version3 <= rangeEnd;
 } else {
 return Number.parseInt(selector, 10) === version3;
 }
}
var init_opset = __esm({
 "web/lib/onnxjs/opset.ts"() {
 "use strict";
 }
});

// web/node_modules/guid-typescript/dist/guid.js
var require_guid = __commonJS({
 "web/node_modules/guid-typescript/dist/guid.js"(exports2) {
 "use strict";
 exports2.__esModule = true;
 var Guid2 = (
 /** @class */
 function() {
 function Guid3(guid) {
 if (!guid) {
 throw new TypeError("Invalid argument; `value` has no value.");
 }
 this.value = Guid3.EMPTY;
 if (guid && Guid3.isGuid(guid)) {
 this.value = guid;
 }
 }
 Guid3.isGuid = function(guid) {
 var value = guid.toString();
 return guid && (guid instanceof Guid3 || Guid3.validator.test(value));
 };
 Guid3.create = function() {
 return new Guid3([Guid3.gen(2), Guid3.gen(1), Guid3.gen(1), Guid3.gen(1), Guid3.gen(3)].join("-"));
 };
 Guid3.createEmpty = function() {
 return new Guid3("emptyguid");
 };
 Guid3.parse = function(guid) {
 return new Guid3(guid);
 };
 Guid3.raw = function() {
 return [Guid3.gen(2), Guid3.gen(1), Guid3.gen(1), Guid3.gen(1), Guid3.gen(3)].join("-");
 };
 Guid3.gen = function(count) {
 var out = "";
 for (var i = 0; i < count; i++) {
 out += ((1 + Math.random()) * 65536 | 0).toString(16).substring(1);
 }
 return out;
 };
 Guid3.prototype.equals = function(other) {
 return Guid3.isGuid(other) && this.value === other.toString();
 };
 Guid3.prototype.isEmpty = function() {
 return this.value === Guid3.EMPTY;
 };
 Guid3.prototype.toString = function() {
 return this.value;
 };
 Guid3.prototype.toJSON = function() {
 return {
 value: this.value
 };
 };
 Guid3.validator = new RegExp("^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}$", "i");
 Guid3.EMPTY = "00000000-0000-0000-0000-000000000000";
 return Guid3;
 }()
 );
 exports2.Guid = Guid2;
 }
});

// web/node_modules/long/index.js
function Long(low, high, unsigned) {
 this.low = low | 0;
 this.high = high | 0;
 this.unsigned = !!unsigned;
}
function isLong(obj) {
 return (obj && obj["__isLong__"]) === true;
}
function ctz32(value) {
 var c = Math.clz32(value & -value);
 return value ? 31 - c : c;
}
function fromInt(value, unsigned) {
 var obj, cachedObj, cache2;
 if (unsigned) {
 value >>>= 0;
 if (cache2 = 0 <= value && value < 256) {
 cachedObj = UINT_CACHE[value];
 if (cachedObj)
 return cachedObj;
 }
 obj = fromBits(value, 0, true);
 if (cache2)
 UINT_CACHE[value] = obj;
 return obj;
 } else {
 value |= 0;
 if (cache2 = -128 <= value && value < 128) {
 cachedObj = INT_CACHE[value];
 if (cachedObj)
 return cachedObj;
 }
 obj = fromBits(value, value < 0 ? -1 : 0, false);
 if (cache2)
 INT_CACHE[value] = obj;
 return obj;
 }
}
function fromNumber(value, unsigned) {
 if (isNaN(value))
 return unsigned ? UZERO : ZERO;
 if (unsigned) {
 if (value < 0)
 return UZERO;
 if (value >= TWO_PWR_64_DBL)
 return MAX_UNSIGNED_VALUE;
 } else {
 if (value <= -TWO_PWR_63_DBL)
 return MIN_VALUE;
 if (value + 1 >= TWO_PWR_63_DBL)
 return MAX_VALUE;
 }
 if (value < 0)
 return fromNumber(-value, unsigned).neg();
 return fromBits(value % TWO_PWR_32_DBL | 0, value / TWO_PWR_32_DBL | 0, unsigned);
}
function fromBits(lowBits, highBits, unsigned) {
 return new Long(lowBits, highBits, unsigned);
}
function fromString(str, unsigned, radix) {
 if (str.length === 0)
 throw Error("empty string");
 if (typeof unsigned === "number") {
 radix = unsigned;
 unsigned = false;
 } else {
 unsigned = !!unsigned;
 }
 if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity")
 return unsigned ? UZERO : ZERO;
 radix = radix || 10;
 if (radix < 2 || 36 < radix)
 throw RangeError("radix");
 var p;
 if ((p = str.indexOf("-")) > 0)
 throw Error("interior hyphen");
 else if (p === 0) {
 return fromString(str.substring(1), unsigned, radix).neg();
 }
 var radixToPower = fromNumber(pow_dbl(radix, 8));
 var result = ZERO;
 for (var i = 0; i < str.length; i += 8) {
 var size = Math.min(8, str.length - i), value = parseInt(str.substring(i, i + size), radix);
 if (size < 8) {
 var power = fromNumber(pow_dbl(radix, size));
 result = result.mul(power).add(fromNumber(value));
 } else {
 result = result.mul(radixToPower);
 result = result.add(fromNumber(value));
 }
 }
 result.unsigned = unsigned;
 return result;
}
function fromValue(val, unsigned) {
 if (typeof val === "number")
 return fromNumber(val, unsigned);
 if (typeof val === "string")
 return fromString(val, unsigned);
 return fromBits(val.low, val.high, typeof unsigned === "boolean" ? unsigned : val.unsigned);
}
var wasm, INT_CACHE, UINT_CACHE, pow_dbl, TWO_PWR_16_DBL, TWO_PWR_24_DBL, TWO_PWR_32_DBL, TWO_PWR_64_DBL, TWO_PWR_63_DBL, TWO_PWR_24, ZERO, UZERO, ONE, UONE, NEG_ONE, MAX_VALUE, MAX_UNSIGNED_VALUE, MIN_VALUE, LongPrototype, long_default;
var init_long = __esm({
 "web/node_modules/long/index.js"() {
 wasm = null;
 try {
 wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([
 0,
 97,
 115,
 109,
 1,
 0,
 0,
 0,
 1,
 13,
 2,
 96,
 0,
 1,
 127,
 96,
 4,
 127,
 127,
 127,
 127,
 1,
 127,
 3,
 7,
 6,
 0,
 1,
 1,
 1,
 1,
 1,
 6,
 6,
 1,
 127,
 1,
 65,
 0,
 11,
 7,
 50,
 6,
 3,
 109,
 117,
 108,
 0,
 1,
 5,
 100,
 105,
 118,
 95,
 115,
 0,
 2,
 5,
 100,
 105,
 118,
 95,
 117,
 0,
 3,
 5,
 114,
 101,
 109,
 95,
 115,
 0,
 4,
 5,
 114,
 101,
 109,
 95,
 117,
 0,
 5,
 8,
 103,
 101,
 116,
 95,
 104,
 105,
 103,
 104,
 0,
 0,
 10,
 191,
 1,
 6,
 4,
 0,
 35,
 0,
 11,
 36,
 1,
 1,
 126,
 32,
 0,
 173,
 32,
 1,
 173,
 66,
 32,
 134,
 132,
 32,
 2,
 173,
 32,
 3,
 173,
 66,
 32,
 134,
 132,
 126,
 34,
 4,
 66,
 32,
 135,
 167,
 36,
 0,
 32,
 4,
 167,
 11,
 36,
 1,
 1,
 126,
 32,
 0,
 173,
 32,
 1,
 173,
 66,
 32,
 134,
 132,
 32,
 2,
 173,
 32,
 3,
 173,
 66,
 32,
 134,
 132,
 127,
 34,
 4,
 66,
 32,
 135,
 167,
 36,
 0,
 32,
 4,
 167,
 11,
 36,
 1,
 1,
 126,
 32,
 0,
 173,
 32,
 1,
 173,
 66,
 32,
 134,
 132,
 32,
 2,
 173,
 32,
 3,
 173,
 66,
 32,
 134,
 132,
 128,
 34,
 4,
 66,
 32,
 135,
 167,
 36,
 0,
 32,
 4,
 167,
 11,
 36,
 1,
 1,
 126,
 32,
 0,
 173,
 32,
 1,
 173,
 66,
 32,
 134,
 132,
 32,
 2,
 173,
 32,
 3,
 173,
 66,
 32,
 134,
 132,
 129,
 34,
 4,
 66,
 32,
 135,
 167,
 36,
 0,
 32,
 4,
 167,
 11,
 36,
 1,
 1,
 126,
 32,
 0,
 173,
 32,
 1,
 173,
 66,
 32,
 134,
 132,
 32,
 2,
 173,
 32,
 3,
 173,
 66,
 32,
 134,
 132,
 130,
 34,
 4,
 66,
 32,
 135,
 167,
 36,
 0,
 32,
 4,
 167,
 11
 ])), {}).exports;
 } catch (e) {
 }
 Long.prototype.__isLong__;
 Object.defineProperty(Long.prototype, "__isLong__", { value: true });
 Long.isLong = isLong;
 INT_CACHE = {};
 UINT_CACHE = {};
 Long.fromInt = fromInt;
 Long.fromNumber = fromNumber;
 Long.fromBits = fromBits;
 pow_dbl = Math.pow;
 Long.fromString = fromString;
 Long.fromValue = fromValue;
 TWO_PWR_16_DBL = 1 << 16;
 TWO_PWR_24_DBL = 1 << 24;
 TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
 TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;
 TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;
 TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);
 ZERO = fromInt(0);
 Long.ZERO = ZERO;
 UZERO = fromInt(0, true);
 Long.UZERO = UZERO;
 ONE = fromInt(1);
 Long.ONE = ONE;
 UONE = fromInt(1, true);
 Long.UONE = UONE;
 NEG_ONE = fromInt(-1);
 Long.NEG_ONE = NEG_ONE;
 MAX_VALUE = fromBits(4294967295 | 0, 2147483647 | 0, false);
 Long.MAX_VALUE = MAX_VALUE;
 MAX_UNSIGNED_VALUE = fromBits(4294967295 | 0, 4294967295 | 0, true);
 Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;
 MIN_VALUE = fromBits(0, 2147483648 | 0, false);
 Long.MIN_VALUE = MIN_VALUE;
 LongPrototype = Long.prototype;
 LongPrototype.toInt = function toInt() {
 return this.unsigned ? this.low >>> 0 : this.low;
 };
 LongPrototype.toNumber = function toNumber() {
 if (this.unsigned)
 return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0);
 return this.high * TWO_PWR_32_DBL + (this.low >>> 0);
 };
 LongPrototype.toString = function toString(radix) {
 radix = radix || 10;
 if (radix < 2 || 36 < radix)
 throw RangeError("radix");
 if (this.isZero())
 return "0";
 if (this.isNegative()) {
 if (this.eq(MIN_VALUE)) {
 var radixLong = fromNumber(radix), div2 = this.div(radixLong), rem1 = div2.mul(radixLong).sub(this);
 return div2.toString(radix) + rem1.toInt().toString(radix);
 } else
 return "-" + this.neg().toString(radix);
 }
 var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned), rem = this;
 var result = "";
 while (true) {
 var remDiv = rem.div(radixToPower), intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0, digits = intval.toString(radix);
 rem = remDiv;
 if (rem.isZero())
 return digits + result;
 else {
 while (digits.length < 6)
 digits = "0" + digits;
 result = "" + digits + result;
 }
 }
 };
 LongPrototype.getHighBits = function getHighBits() {
 return this.high;
 };
 LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {
 return this.high >>> 0;
 };
 LongPrototype.getLowBits = function getLowBits() {
 return this.low;
 };
 LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {
 return this.low >>> 0;
 };
 LongPrototype.getNumBitsAbs = function getNumBitsAbs() {
 if (this.isNegative())
 return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();
 var val = this.high != 0 ? this.high : this.low;
 for (var bit = 31; bit > 0; bit--)
 if ((val & 1 << bit) != 0)
 break;
 return this.high != 0 ? bit + 33 : bit + 1;
 };
 LongPrototype.isZero = function isZero() {
 return this.high === 0 && this.low === 0;
 };
 LongPrototype.eqz = LongPrototype.isZero;
 LongPrototype.isNegative = function isNegative() {
 return !this.unsigned && this.high < 0;
 };
 LongPrototype.isPositive = function isPositive() {
 return this.unsigned || this.high >= 0;
 };
 LongPrototype.isOdd = function isOdd() {
 return (this.low & 1) === 1;
 };
 LongPrototype.isEven = function isEven() {
 return (this.low & 1) === 0;
 };
 LongPrototype.equals = function equals(other) {
 if (!isLong(other))
 other = fromValue(other);
 if (this.unsigned !== other.unsigned && this.high >>> 31 === 1 && other.high >>> 31 === 1)
 return false;
 return this.high === other.high && this.low === other.low;
 };
 LongPrototype.eq = LongPrototype.equals;
 LongPrototype.notEquals = function notEquals(other) {
 return !this.eq(
 /* validates */
 other
 );
 };
 LongPrototype.neq = LongPrototype.notEquals;
 LongPrototype.ne = LongPrototype.notEquals;
 LongPrototype.lessThan = function lessThan(other) {
 return this.comp(
 /* validates */
 other
 ) < 0;
 };
 LongPrototype.lt = LongPrototype.lessThan;
 LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {
 return this.comp(
 /* validates */
 other
 ) <= 0;
 };
 LongPrototype.lte = LongPrototype.lessThanOrEqual;
 LongPrototype.le = LongPrototype.lessThanOrEqual;
 LongPrototype.greaterThan = function greaterThan(other) {
 return this.comp(
 /* validates */
 other
 ) > 0;
 };
 LongPrototype.gt = LongPrototype.greaterThan;
 LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {
 return this.comp(
 /* validates */
 other
 ) >= 0;
 };
 LongPrototype.gte = LongPrototype.greaterThanOrEqual;
 LongPrototype.ge = LongPrototype.greaterThanOrEqual;
 LongPrototype.compare = function compare(other) {
 if (!isLong(other))
 other = fromValue(other);
 if (this.eq(other))
 return 0;
 var thisNeg = this.isNegative(), otherNeg = other.isNegative();
 if (thisNeg && !otherNeg)
 return -1;
 if (!thisNeg && otherNeg)
 return 1;
 if (!this.unsigned)
 return this.sub(other).isNegative() ? -1 : 1;
 return other.high >>> 0 > this.high >>> 0 || other.high === this.high && other.low >>> 0 > this.low >>> 0 ? -1 : 1;
 };
 LongPrototype.comp = LongPrototype.compare;
 LongPrototype.negate = function negate() {
 if (!this.unsigned && this.eq(MIN_VALUE))
 return MIN_VALUE;
 return this.not().add(ONE);
 };
 LongPrototype.neg = LongPrototype.negate;
 LongPrototype.add = function add(addend) {
 if (!isLong(addend))
 addend = fromValue(addend);
 var a48 = this.high >>> 16;
 var a32 = this.high & 65535;
 var a16 = this.low >>> 16;
 var a00 = this.low & 65535;
 var b48 = addend.high >>> 16;
 var b32 = addend.high & 65535;
 var b16 = addend.low >>> 16;
 var b00 = addend.low & 65535;
 var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
 c00 += a00 + b00;
 c16 += c00 >>> 16;
 c00 &= 65535;
 c16 += a16 + b16;
 c32 += c16 >>> 16;
 c16 &= 65535;
 c32 += a32 + b32;
 c48 += c32 >>> 16;
 c32 &= 65535;
 c48 += a48 + b48;
 c48 &= 65535;
 return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
 };
 LongPrototype.subtract = function subtract(subtrahend) {
 if (!isLong(subtrahend))
 subtrahend = fromValue(subtrahend);
 return this.add(subtrahend.neg());
 };
 LongPrototype.sub = LongPrototype.subtract;
 LongPrototype.multiply = function multiply(multiplier) {
 if (this.isZero())
 return this;
 if (!isLong(multiplier))
 multiplier = fromValue(multiplier);
 if (wasm) {
 var low = wasm["mul"](
 this.low,
 this.high,
 multiplier.low,
 multiplier.high
 );
 return fromBits(low, wasm["get_high"](), this.unsigned);
 }
 if (multiplier.isZero())
 return this.unsigned ? UZERO : ZERO;
 if (this.eq(MIN_VALUE))
 return multiplier.isOdd() ? MIN_VALUE : ZERO;
 if (multiplier.eq(MIN_VALUE))
 return this.isOdd() ? MIN_VALUE : ZERO;
 if (this.isNegative()) {
 if (multiplier.isNegative())
 return this.neg().mul(multiplier.neg());
 else
 return this.neg().mul(multiplier).neg();
 } else if (multiplier.isNegative())
 return this.mul(multiplier.neg()).neg();
 if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))
 return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);
 var a48 = this.high >>> 16;
 var a32 = this.high & 65535;
 var a16 = this.low >>> 16;
 var a00 = this.low & 65535;
 var b48 = multiplier.high >>> 16;
 var b32 = multiplier.high & 65535;
 var b16 = multiplier.low >>> 16;
 var b00 = multiplier.low & 65535;
 var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
 c00 += a00 * b00;
 c16 += c00 >>> 16;
 c00 &= 65535;
 c16 += a16 * b00;
 c32 += c16 >>> 16;
 c16 &= 65535;
 c16 += a00 * b16;
 c32 += c16 >>> 16;
 c16 &= 65535;
 c32 += a32 * b00;
 c48 += c32 >>> 16;
 c32 &= 65535;
 c32 += a16 * b16;
 c48 += c32 >>> 16;
 c32 &= 65535;
 c32 += a00 * b32;
 c48 += c32 >>> 16;
 c32 &= 65535;
 c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
 c48 &= 65535;
 return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
 };
 LongPrototype.mul = LongPrototype.multiply;
 LongPrototype.divide = function divide(divisor) {
 if (!isLong(divisor))
 divisor = fromValue(divisor);
 if (divisor.isZero())
 throw Error("division by zero");
 if (wasm) {
 if (!this.unsigned && this.high === -2147483648 && divisor.low === -1 && divisor.high === -1) {
 return this;
 }
 var low = (this.unsigned ? wasm["div_u"] : wasm["div_s"])(
 this.low,
 this.high,
 divisor.low,
 divisor.high
 );
 return fromBits(low, wasm["get_high"](), this.unsigned);
 }
 if (this.isZero())
 return this.unsigned ? UZERO : ZERO;
 var approx, rem, res;
 if (!this.unsigned) {
 if (this.eq(MIN_VALUE)) {
 if (divisor.eq(ONE) || divisor.eq(NEG_ONE))
 return MIN_VALUE;
 else if (divisor.eq(MIN_VALUE))
 return ONE;
 else {
 var halfThis = this.shr(1);
 approx = halfThis.div(divisor).shl(1);
 if (approx.eq(ZERO)) {
 return divisor.isNegative() ? ONE : NEG_ONE;
 } else {
 rem = this.sub(divisor.mul(approx));
 res = approx.add(rem.div(divisor));
 return res;
 }
 }
 } else if (divisor.eq(MIN_VALUE))
 return this.unsigned ? UZERO : ZERO;
 if (this.isNegative()) {
 if (divisor.isNegative())
 return this.neg().div(divisor.neg());
 return this.neg().div(divisor).neg();
 } else if (divisor.isNegative())
 return this.div(divisor.neg()).neg();
 res = ZERO;
 } else {
 if (!divisor.unsigned)
 divisor = divisor.toUnsigned();
 if (divisor.gt(this))
 return UZERO;
 if (divisor.gt(this.shru(1)))
 return UONE;
 res = UZERO;
 }
 rem = this;
 while (rem.gte(divisor)) {
 approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));
 var log22 = Math.ceil(Math.log(approx) / Math.LN2), delta = log22 <= 48 ? 1 : pow_dbl(2, log22 - 48), approxRes = fromNumber(approx), approxRem = approxRes.mul(divisor);
 while (approxRem.isNegative() || approxRem.gt(rem)) {
 approx -= delta;
 approxRes = fromNumber(approx, this.unsigned);
 approxRem = approxRes.mul(divisor);
 }
 if (approxRes.isZero())
 approxRes = ONE;
 res = res.add(approxRes);
 rem = rem.sub(approxRem);
 }
 return res;
 };
 LongPrototype.div = LongPrototype.divide;
 LongPrototype.modulo = function modulo(divisor) {
 if (!isLong(divisor))
 divisor = fromValue(divisor);
 if (wasm) {
 var low = (this.unsigned ? wasm["rem_u"] : wasm["rem_s"])(
 this.low,
 this.high,
 divisor.low,
 divisor.high
 );
 return fromBits(low, wasm["get_high"](), this.unsigned);
 }
 return this.sub(this.div(divisor).mul(divisor));
 };
 LongPrototype.mod = LongPrototype.modulo;
 LongPrototype.rem = LongPrototype.modulo;
 LongPrototype.not = function not() {
 return fromBits(~this.low, ~this.high, this.unsigned);
 };
 LongPrototype.countLeadingZeros = function countLeadingZeros() {
 return this.high ? Math.clz32(this.high) : Math.clz32(this.low) + 32;
 };
 LongPrototype.clz = LongPrototype.countLeadingZeros;
 LongPrototype.countTrailingZeros = function countTrailingZeros() {
 return this.low ? ctz32(this.low) : ctz32(this.high) + 32;
 };
 LongPrototype.ctz = LongPrototype.countTrailingZeros;
 LongPrototype.and = function and(other) {
 if (!isLong(other))
 other = fromValue(other);
 return fromBits(this.low & other.low, this.high & other.high, this.unsigned);
 };
 LongPrototype.or = function or(other) {
 if (!isLong(other))
 other = fromValue(other);
 return fromBits(this.low | other.low, this.high | other.high, this.unsigned);
 };
 LongPrototype.xor = function xor(other) {
 if (!isLong(other))
 other = fromValue(other);
 return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);
 };
 LongPrototype.shiftLeft = function shiftLeft(numBits) {
 if (isLong(numBits))
 numBits = numBits.toInt();
 if ((numBits &= 63) === 0)
 return this;
 else if (numBits < 32)
 return fromBits(this.low << numBits, this.high << numBits | this.low >>> 32 - numBits, this.unsigned);
 else
 return fromBits(0, this.low << numBits - 32, this.unsigned);
 };
 LongPrototype.shl = LongPrototype.shiftLeft;
 LongPrototype.shiftRight = function shiftRight(numBits) {
 if (isLong(numBits))
 numBits = numBits.toInt();
 if ((numBits &= 63) === 0)
 return this;
 else if (numBits < 32)
 return fromBits(this.low >>> numBits | this.high << 32 - numBits, this.high >> numBits, this.unsigned);
 else
 return fromBits(this.high >> numBits - 32, this.high >= 0 ? 0 : -1, this.unsigned);
 };
 LongPrototype.shr = LongPrototype.shiftRight;
 LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {
 if (isLong(numBits))
 numBits = numBits.toInt();
 if ((numBits &= 63) === 0)
 return this;
 if (numBits < 32)
 return fromBits(this.low >>> numBits | this.high << 32 - numBits, this.high >>> numBits, this.unsigned);
 if (numBits === 32)
 return fromBits(this.high, 0, this.unsigned);
 return fromBits(this.high >>> numBits - 32, 0, this.unsigned);
 };
 LongPrototype.shru = LongPrototype.shiftRightUnsigned;
 LongPrototype.shr_u = LongPrototype.shiftRightUnsigned;
 LongPrototype.rotateLeft = function rotateLeft(numBits) {
 var b;
 if (isLong(numBits))
 numBits = numBits.toInt();
 if ((numBits &= 63) === 0)
 return this;
 if (numBits === 32)
 return fromBits(this.high, this.low, this.unsigned);
 if (numBits < 32) {
 b = 32 - numBits;
 return fromBits(this.low << numBits | this.high >>> b, this.high << numBits | this.low >>> b, this.unsigned);
 }
 numBits -= 32;
 b = 32 - numBits;
 return fromBits(this.high << numBits | this.low >>> b, this.low << numBits | this.high >>> b, this.unsigned);
 };
 LongPrototype.rotl = LongPrototype.rotateLeft;
 LongPrototype.rotateRight = function rotateRight(numBits) {
 var b;
 if (isLong(numBits))
 numBits = numBits.toInt();
 if ((numBits &= 63) === 0)
 return this;
 if (numBits === 32)
 return fromBits(this.high, this.low, this.unsigned);
 if (numBits < 32) {
 b = 32 - numBits;
 return fromBits(this.high <>> numBits, this.low <>> numBits, this.unsigned);
 }
 numBits -= 32;
 b = 32 - numBits;
 return fromBits(this.low <>> numBits, this.high <>> numBits, this.unsigned);
 };
 LongPrototype.rotr = LongPrototype.rotateRight;
 LongPrototype.toSigned = function toSigned() {
 if (!this.unsigned)
 return this;
 return fromBits(this.low, this.high, false);
 };
 LongPrototype.toUnsigned = function toUnsigned() {
 if (this.unsigned)
 return this;
 return fromBits(this.low, this.high, true);
 };
 LongPrototype.toBytes = function toBytes(le) {
 return le ? this.toBytesLE() : this.toBytesBE();
 };
 LongPrototype.toBytesLE = function toBytesLE() {
 var hi = this.high, lo = this.low;
 return [
 lo & 255,
 lo >>> 8 & 255,
 lo >>> 16 & 255,
 lo >>> 24,
 hi & 255,
 hi >>> 8 & 255,
 hi >>> 16 & 255,
 hi >>> 24
 ];
 };
 LongPrototype.toBytesBE = function toBytesBE() {
 var hi = this.high, lo = this.low;
 return [
 hi >>> 24,
 hi >>> 16 & 255,
 hi >>> 8 & 255,
 hi & 255,
 lo >>> 24,
 lo >>> 16 & 255,
 lo >>> 8 & 255,
 lo & 255
 ];
 };
 Long.fromBytes = function fromBytes(bytes, unsigned, le) {
 return le ? Long.fromBytesLE(bytes, unsigned) : Long.fromBytesBE(bytes, unsigned);
 };
 Long.fromBytesLE = function fromBytesLE(bytes, unsigned) {
 return new Long(
 bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24,
 bytes[4] | bytes[5] << 8 | bytes[6] << 16 | bytes[7] << 24,
 unsigned
 );
 };
 Long.fromBytesBE = function fromBytesBE(bytes, unsigned) {
 return new Long(
 bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7],
 bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3],
 unsigned
 );
 };
 long_default = Long;
 }
});

// web/node_modules/flatbuffers/js/flatbuffers.mjs
var flatbuffers;
var init_flatbuffers = __esm({
 "web/node_modules/flatbuffers/js/flatbuffers.mjs"() {
 flatbuffers = {};
 flatbuffers.Offset;
 flatbuffers.Table;
 flatbuffers.SIZEOF_SHORT = 2;
 flatbuffers.SIZEOF_INT = 4;
 flatbuffers.FILE_IDENTIFIER_LENGTH = 4;
 flatbuffers.SIZE_PREFIX_LENGTH = 4;
 flatbuffers.Encoding = {
 UTF8_BYTES: 1,
 UTF16_STRING: 2
 };
 flatbuffers.int32 = new Int32Array(2);
 flatbuffers.float32 = new Float32Array(flatbuffers.int32.buffer);
 flatbuffers.float64 = new Float64Array(flatbuffers.int32.buffer);
 flatbuffers.isLittleEndian = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
 flatbuffers.Long = function(low, high) {
 this.low = low | 0;
 this.high = high | 0;
 };
 flatbuffers.Long.create = function(low, high) {
 return low == 0 && high == 0 ? flatbuffers.Long.ZERO : new flatbuffers.Long(low, high);
 };
 flatbuffers.Long.prototype.toFloat64 = function() {
 return (this.low >>> 0) + this.high * 4294967296;
 };
 flatbuffers.Long.prototype.equals = function(other) {
 return this.low == other.low && this.high == other.high;
 };
 flatbuffers.Long.ZERO = new flatbuffers.Long(0, 0);
 flatbuffers.Builder = function(opt_initial_size) {
 if (!opt_initial_size) {
 var initial_size = 1024;
 } else {
 var initial_size = opt_initial_size;
 }
 this.bb = flatbuffers.ByteBuffer.allocate(initial_size);
 this.space = initial_size;
 this.minalign = 1;
 this.vtable = null;
 this.vtable_in_use = 0;
 this.isNested = false;
 this.object_start = 0;
 this.vtables = [];
 this.vector_num_elems = 0;
 this.force_defaults = false;
 };
 flatbuffers.Builder.prototype.clear = function() {
 this.bb.clear();
 this.space = this.bb.capacity();
 this.minalign = 1;
 this.vtable = null;
 this.vtable_in_use = 0;
 this.isNested = false;
 this.object_start = 0;
 this.vtables = [];
 this.vector_num_elems = 0;
 this.force_defaults = false;
 };
 flatbuffers.Builder.prototype.forceDefaults = function(forceDefaults) {
 this.force_defaults = forceDefaults;
 };
 flatbuffers.Builder.prototype.dataBuffer = function() {
 return this.bb;
 };
 flatbuffers.Builder.prototype.asUint8Array = function() {
 return this.bb.bytes().subarray(this.bb.position(), this.bb.position() + this.offset());
 };
 flatbuffers.Builder.prototype.prep = function(size, additional_bytes) {
 if (size > this.minalign) {
 this.minalign = size;
 }
 var align_size = ~(this.bb.capacity() - this.space + additional_bytes) + 1 & size - 1;
 while (this.space < align_size + size + additional_bytes) {
 var old_buf_size = this.bb.capacity();
 this.bb = flatbuffers.Builder.growByteBuffer(this.bb);
 this.space += this.bb.capacity() - old_buf_size;
 }
 this.pad(align_size);
 };
 flatbuffers.Builder.prototype.pad = function(byte_size) {
 for (var i = 0; i < byte_size; i++) {
 this.bb.writeInt8(--this.space, 0);
 }
 };
 flatbuffers.Builder.prototype.writeInt8 = function(value) {
 this.bb.writeInt8(this.space -= 1, value);
 };
 flatbuffers.Builder.prototype.writeInt16 = function(value) {
 this.bb.writeInt16(this.space -= 2, value);
 };
 flatbuffers.Builder.prototype.writeInt32 = function(value) {
 this.bb.writeInt32(this.space -= 4, value);
 };
 flatbuffers.Builder.prototype.writeInt64 = function(value) {
 this.bb.writeInt64(this.space -= 8, value);
 };
 flatbuffers.Builder.prototype.writeFloat32 = function(value) {
 this.bb.writeFloat32(this.space -= 4, value);
 };
 flatbuffers.Builder.prototype.writeFloat64 = function(value) {
 this.bb.writeFloat64(this.space -= 8, value);
 };
 flatbuffers.Builder.prototype.addInt8 = function(value) {
 this.prep(1, 0);
 this.writeInt8(value);
 };
 flatbuffers.Builder.prototype.addInt16 = function(value) {
 this.prep(2, 0);
 this.writeInt16(value);
 };
 flatbuffers.Builder.prototype.addInt32 = function(value) {
 this.prep(4, 0);
 this.writeInt32(value);
 };
 flatbuffers.Builder.prototype.addInt64 = function(value) {
 this.prep(8, 0);
 this.writeInt64(value);
 };
 flatbuffers.Builder.prototype.addFloat32 = function(value) {
 this.prep(4, 0);
 this.writeFloat32(value);
 };
 flatbuffers.Builder.prototype.addFloat64 = function(value) {
 this.prep(8, 0);
 this.writeFloat64(value);
 };
 flatbuffers.Builder.prototype.addFieldInt8 = function(voffset, value, defaultValue) {
 if (this.force_defaults || value != defaultValue) {
 this.addInt8(value);
 this.slot(voffset);
 }
 };
 flatbuffers.Builder.prototype.addFieldInt16 = function(voffset, value, defaultValue) {
 if (this.force_defaults || value != defaultValue) {
 this.addInt16(value);
 this.slot(voffset);
 }
 };
 flatbuffers.Builder.prototype.addFieldInt32 = function(voffset, value, defaultValue) {
 if (this.force_defaults || value != defaultValue) {
 this.addInt32(value);
 this.slot(voffset);
 }
 };
 flatbuffers.Builder.prototype.addFieldInt64 = function(voffset, value, defaultValue) {
 if (this.force_defaults || !value.equals(defaultValue)) {
 this.addInt64(value);
 this.slot(voffset);
 }
 };
 flatbuffers.Builder.prototype.addFieldFloat32 = function(voffset, value, defaultValue) {
 if (this.force_defaults || value != defaultValue) {
 this.addFloat32(value);
 this.slot(voffset);
 }
 };
 flatbuffers.Builder.prototype.addFieldFloat64 = function(voffset, value, defaultValue) {
 if (this.force_defaults || value != defaultValue) {
 this.addFloat64(value);
 this.slot(voffset);
 }
 };
 flatbuffers.Builder.prototype.addFieldOffset = function(voffset, value, defaultValue) {
 if (this.force_defaults || value != defaultValue) {
 this.addOffset(value);
 this.slot(voffset);
 }
 };
 flatbuffers.Builder.prototype.addFieldStruct = function(voffset, value, defaultValue) {
 if (value != defaultValue) {
 this.nested(value);
 this.slot(voffset);
 }
 };
 flatbuffers.Builder.prototype.nested = function(obj) {
 if (obj != this.offset()) {
 throw new Error("FlatBuffers: struct must be serialized inline.");
 }
 };
 flatbuffers.Builder.prototype.notNested = function() {
 if (this.isNested) {
 throw new Error("FlatBuffers: object serialization must not be nested.");
 }
 };
 flatbuffers.Builder.prototype.slot = function(voffset) {
 this.vtable[voffset] = this.offset();
 };
 flatbuffers.Builder.prototype.offset = function() {
 return this.bb.capacity() - this.space;
 };
 flatbuffers.Builder.growByteBuffer = function(bb) {
 var old_buf_size = bb.capacity();
 if (old_buf_size & 3221225472) {
 throw new Error("FlatBuffers: cannot grow buffer beyond 2 gigabytes.");
 }
 var new_buf_size = old_buf_size << 1;
 var nbb = flatbuffers.ByteBuffer.allocate(new_buf_size);
 nbb.setPosition(new_buf_size - old_buf_size);
 nbb.bytes().set(bb.bytes(), new_buf_size - old_buf_size);
 return nbb;
 };
 flatbuffers.Builder.prototype.addOffset = function(offset) {
 this.prep(flatbuffers.SIZEOF_INT, 0);
 this.writeInt32(this.offset() - offset + flatbuffers.SIZEOF_INT);
 };
 flatbuffers.Builder.prototype.startObject = function(numfields) {
 this.notNested();
 if (this.vtable == null) {
 this.vtable = [];
 }
 this.vtable_in_use = numfields;
 for (var i = 0; i < numfields; i++) {
 this.vtable[i] = 0;
 }
 this.isNested = true;
 this.object_start = this.offset();
 };
 flatbuffers.Builder.prototype.endObject = function() {
 if (this.vtable == null || !this.isNested) {
 throw new Error("FlatBuffers: endObject called without startObject");
 }
 this.addInt32(0);
 var vtableloc = this.offset();
 var i = this.vtable_in_use - 1;
 for (; i >= 0 && this.vtable[i] == 0; i--) {
 }
 var trimmed_size = i + 1;
 for (; i >= 0; i--) {
 this.addInt16(this.vtable[i] != 0 ? vtableloc - this.vtable[i] : 0);
 }
 var standard_fields = 2;
 this.addInt16(vtableloc - this.object_start);
 var len = (trimmed_size + standard_fields) * flatbuffers.SIZEOF_SHORT;
 this.addInt16(len);
 var existing_vtable = 0;
 var vt1 = this.space;
 outer_loop:
 for (i = 0; i < this.vtables.length; i++) {
 var vt2 = this.bb.capacity() - this.vtables[i];
 if (len == this.bb.readInt16(vt2)) {
 for (var j = flatbuffers.SIZEOF_SHORT; j < len; j += flatbuffers.SIZEOF_SHORT) {
 if (this.bb.readInt16(vt1 + j) != this.bb.readInt16(vt2 + j)) {
 continue outer_loop;
 }
 }
 existing_vtable = this.vtables[i];
 break;
 }
 }
 if (existing_vtable) {
 this.space = this.bb.capacity() - vtableloc;
 this.bb.writeInt32(this.space, existing_vtable - vtableloc);
 } else {
 this.vtables.push(this.offset());
 this.bb.writeInt32(this.bb.capacity() - vtableloc, this.offset() - vtableloc);
 }
 this.isNested = false;
 return vtableloc;
 };
 flatbuffers.Builder.prototype.finish = function(root_table, opt_file_identifier, opt_size_prefix) {
 var size_prefix = opt_size_prefix ? flatbuffers.SIZE_PREFIX_LENGTH : 0;
 if (opt_file_identifier) {
 var file_identifier = opt_file_identifier;
 this.prep(this.minalign, flatbuffers.SIZEOF_INT + flatbuffers.FILE_IDENTIFIER_LENGTH + size_prefix);
 if (file_identifier.length != flatbuffers.FILE_IDENTIFIER_LENGTH) {
 throw new Error("FlatBuffers: file identifier must be length " + flatbuffers.FILE_IDENTIFIER_LENGTH);
 }
 for (var i = flatbuffers.FILE_IDENTIFIER_LENGTH - 1; i >= 0; i--) {
 this.writeInt8(file_identifier.charCodeAt(i));
 }
 }
 this.prep(this.minalign, flatbuffers.SIZEOF_INT + size_prefix);
 this.addOffset(root_table);
 if (size_prefix) {
 this.addInt32(this.bb.capacity() - this.space);
 }
 this.bb.setPosition(this.space);
 };
 flatbuffers.Builder.prototype.finishSizePrefixed = function(root_table, opt_file_identifier) {
 this.finish(root_table, opt_file_identifier, true);
 };
 flatbuffers.Builder.prototype.requiredField = function(table, field) {
 var table_start = this.bb.capacity() - table;
 var vtable_start = table_start - this.bb.readInt32(table_start);
 var ok = this.bb.readInt16(vtable_start + field) != 0;
 if (!ok) {
 throw new Error("FlatBuffers: field " + field + " must be set");
 }
 };
 flatbuffers.Builder.prototype.startVector = function(elem_size, num_elems, alignment) {
 this.notNested();
 this.vector_num_elems = num_elems;
 this.prep(flatbuffers.SIZEOF_INT, elem_size * num_elems);
 this.prep(alignment, elem_size * num_elems);
 };
 flatbuffers.Builder.prototype.endVector = function() {
 this.writeInt32(this.vector_num_elems);
 return this.offset();
 };
 flatbuffers.Builder.prototype.createString = function(s) {
 if (s instanceof Uint8Array) {
 var utf8 = s;
 } else {
 var utf8 = [];
 var i = 0;
 while (i < s.length) {
 var codePoint;
 var a = s.charCodeAt(i++);
 if (a < 55296 || a >= 56320) {
 codePoint = a;
 } else {
 var b = s.charCodeAt(i++);
 codePoint = (a << 10) + b + (65536 - (55296 << 10) - 56320);
 }
 if (codePoint < 128) {
 utf8.push(codePoint);
 } else {
 if (codePoint < 2048) {
 utf8.push(codePoint >> 6 & 31 | 192);
 } else {
 if (codePoint < 65536) {
 utf8.push(codePoint >> 12 & 15 | 224);
 } else {
 utf8.push(
 codePoint >> 18 & 7 | 240,
 codePoint >> 12 & 63 | 128
 );
 }
 utf8.push(codePoint >> 6 & 63 | 128);
 }
 utf8.push(codePoint & 63 | 128);
 }
 }
 }
 this.addInt8(0);
 this.startVector(1, utf8.length, 1);
 this.bb.setPosition(this.space -= utf8.length);
 for (var i = 0, offset = this.space, bytes = this.bb.bytes(); i < utf8.length; i++) {
 bytes[offset++] = utf8[i];
 }
 return this.endVector();
 };
 flatbuffers.Builder.prototype.createLong = function(low, high) {
 return flatbuffers.Long.create(low, high);
 };
 flatbuffers.ByteBuffer = function(bytes) {
 this.bytes_ = bytes;
 this.position_ = 0;
 };
 flatbuffers.ByteBuffer.allocate = function(byte_size) {
 return new flatbuffers.ByteBuffer(new Uint8Array(byte_size));
 };
 flatbuffers.ByteBuffer.prototype.clear = function() {
 this.position_ = 0;
 };
 flatbuffers.ByteBuffer.prototype.bytes = function() {
 return this.bytes_;
 };
 flatbuffers.ByteBuffer.prototype.position = function() {
 return this.position_;
 };
 flatbuffers.ByteBuffer.prototype.setPosition = function(position) {
 this.position_ = position;
 };
 flatbuffers.ByteBuffer.prototype.capacity = function() {
 return this.bytes_.length;
 };
 flatbuffers.ByteBuffer.prototype.readInt8 = function(offset) {
 return this.readUint8(offset) << 24 >> 24;
 };
 flatbuffers.ByteBuffer.prototype.readUint8 = function(offset) {
 return this.bytes_[offset];
 };
 flatbuffers.ByteBuffer.prototype.readInt16 = function(offset) {
 return this.readUint16(offset) << 16 >> 16;
 };
 flatbuffers.ByteBuffer.prototype.readUint16 = function(offset) {
 return this.bytes_[offset] | this.bytes_[offset + 1] << 8;
 };
 flatbuffers.ByteBuffer.prototype.readInt32 = function(offset) {
 return this.bytes_[offset] | this.bytes_[offset + 1] << 8 | this.bytes_[offset + 2] << 16 | this.bytes_[offset + 3] << 24;
 };
 flatbuffers.ByteBuffer.prototype.readUint32 = function(offset) {
 return this.readInt32(offset) >>> 0;
 };
 flatbuffers.ByteBuffer.prototype.readInt64 = function(offset) {
 return new flatbuffers.Long(this.readInt32(offset), this.readInt32(offset + 4));
 };
 flatbuffers.ByteBuffer.prototype.readUint64 = function(offset) {
 return new flatbuffers.Long(this.readUint32(offset), this.readUint32(offset + 4));
 };
 flatbuffers.ByteBuffer.prototype.readFloat32 = function(offset) {
 flatbuffers.int32[0] = this.readInt32(offset);
 return flatbuffers.float32[0];
 };
 flatbuffers.ByteBuffer.prototype.readFloat64 = function(offset) {
 flatbuffers.int32[flatbuffers.isLittleEndian ? 0 : 1] = this.readInt32(offset);
 flatbuffers.int32[flatbuffers.isLittleEndian ? 1 : 0] = this.readInt32(offset + 4);
 return flatbuffers.float64[0];
 };
 flatbuffers.ByteBuffer.prototype.writeInt8 = function(offset, value) {
 this.bytes_[offset] = /** @type {number} */
 value;
 };
 flatbuffers.ByteBuffer.prototype.writeUint8 = function(offset, value) {
 this.bytes_[offset] = value;
 };
 flatbuffers.ByteBuffer.prototype.writeInt16 = function(offset, value) {
 this.bytes_[offset] = value;
 this.bytes_[offset + 1] = value >> 8;
 };
 flatbuffers.ByteBuffer.prototype.writeUint16 = function(offset, value) {
 this.bytes_[offset] = value;
 this.bytes_[offset + 1] = value >> 8;
 };
 flatbuffers.ByteBuffer.prototype.writeInt32 = function(offset, value) {
 this.bytes_[offset] = value;
 this.bytes_[offset + 1] = value >> 8;
 this.bytes_[offset + 2] = value >> 16;
 this.bytes_[offset + 3] = value >> 24;
 };
 flatbuffers.ByteBuffer.prototype.writeUint32 = function(offset, value) {
 this.bytes_[offset] = value;
 this.bytes_[offset + 1] = value >> 8;
 this.bytes_[offset + 2] = value >> 16;
 this.bytes_[offset + 3] = value >> 24;
 };
 flatbuffers.ByteBuffer.prototype.writeInt64 = function(offset, value) {
 this.writeInt32(offset, value.low);
 this.writeInt32(offset + 4, value.high);
 };
 flatbuffers.ByteBuffer.prototype.writeUint64 = function(offset, value) {
 this.writeUint32(offset, value.low);
 this.writeUint32(offset + 4, value.high);
 };
 flatbuffers.ByteBuffer.prototype.writeFloat32 = function(offset, value) {
 flatbuffers.float32[0] = value;
 this.writeInt32(offset, flatbuffers.int32[0]);
 };
 flatbuffers.ByteBuffer.prototype.writeFloat64 = function(offset, value) {
 flatbuffers.float64[0] = value;
 this.writeInt32(offset, flatbuffers.int32[flatbuffers.isLittleEndian ? 0 : 1]);
 this.writeInt32(offset + 4, flatbuffers.int32[flatbuffers.isLittleEndian ? 1 : 0]);
 };
 flatbuffers.ByteBuffer.prototype.getBufferIdentifier = function() {
 if (this.bytes_.length < this.position_ + flatbuffers.SIZEOF_INT + flatbuffers.FILE_IDENTIFIER_LENGTH) {
 throw new Error(
 "FlatBuffers: ByteBuffer is too short to contain an identifier."
 );
 }
 var result = "";
 for (var i = 0; i < flatbuffers.FILE_IDENTIFIER_LENGTH; i++) {
 result += String.fromCharCode(
 this.readInt8(this.position_ + flatbuffers.SIZEOF_INT + i)
 );
 }
 return result;
 };
 flatbuffers.ByteBuffer.prototype.__offset = function(bb_pos, vtable_offset) {
 var vtable = bb_pos - this.readInt32(bb_pos);
 return vtable_offset < this.readInt16(vtable) ? this.readInt16(vtable + vtable_offset) : 0;
 };
 flatbuffers.ByteBuffer.prototype.__union = function(t, offset) {
 t.bb_pos = offset + this.readInt32(offset);
 t.bb = this;
 return t;
 };
 flatbuffers.ByteBuffer.prototype.__string = function(offset, opt_encoding) {
 offset += this.readInt32(offset);
 var length = this.readInt32(offset);
 var result = "";
 var i = 0;
 offset += flatbuffers.SIZEOF_INT;
 if (opt_encoding === flatbuffers.Encoding.UTF8_BYTES) {
 return this.bytes_.subarray(offset, offset + length);
 }
 while (i < length) {
 var codePoint;
 var a = this.readUint8(offset + i++);
 if (a < 192) {
 codePoint = a;
 } else {
 var b = this.readUint8(offset + i++);
 if (a < 224) {
 codePoint = (a & 31) << 6 | b & 63;
 } else {
 var c = this.readUint8(offset + i++);
 if (a < 240) {
 codePoint = (a & 15) << 12 | (b & 63) << 6 | c & 63;
 } else {
 var d = this.readUint8(offset + i++);
 codePoint = (a & 7) << 18 | (b & 63) << 12 | (c & 63) << 6 | d & 63;
 }
 }
 }
 if (codePoint < 65536) {
 result += String.fromCharCode(codePoint);
 } else {
 codePoint -= 65536;
 result += String.fromCharCode(
 (codePoint >> 10) + 55296,
 (codePoint & (1 << 10) - 1) + 56320
 );
 }
 }
 return result;
 };
 flatbuffers.ByteBuffer.prototype.__indirect = function(offset) {
 return offset + this.readInt32(offset);
 };
 flatbuffers.ByteBuffer.prototype.__vector = function(offset) {
 return offset + this.readInt32(offset) + flatbuffers.SIZEOF_INT;
 };
 flatbuffers.ByteBuffer.prototype.__vector_len = function(offset) {
 return this.readInt32(offset + this.readInt32(offset));
 };
 flatbuffers.ByteBuffer.prototype.__has_identifier = function(ident) {
 if (ident.length != flatbuffers.FILE_IDENTIFIER_LENGTH) {
 throw new Error("FlatBuffers: file identifier must be length " + flatbuffers.FILE_IDENTIFIER_LENGTH);
 }
 for (var i = 0; i < flatbuffers.FILE_IDENTIFIER_LENGTH; i++) {
 if (ident.charCodeAt(i) != this.readInt8(this.position_ + flatbuffers.SIZEOF_INT + i)) {
 return false;
 }
 }
 return true;
 };
 flatbuffers.ByteBuffer.prototype.createLong = function(low, high) {
 return flatbuffers.Long.create(low, high);
 };
 }
});

// web/lib/onnxjs/ort-schema/flatbuffers/ort-generated.ts
var onnxruntime;
var init_ort_generated = __esm({
 "web/lib/onnxjs/ort-schema/flatbuffers/ort-generated.ts"() {
 "use strict";
 init_flatbuffers();
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 let AttributeType;
 ((AttributeType2) => {
 AttributeType2[AttributeType2["UNDEFINED"] = 0] = "UNDEFINED";
 AttributeType2[AttributeType2["FLOAT"] = 1] = "FLOAT";
 AttributeType2[AttributeType2["INT"] = 2] = "INT";
 AttributeType2[AttributeType2["STRING"] = 3] = "STRING";
 AttributeType2[AttributeType2["TENSOR"] = 4] = "TENSOR";
 AttributeType2[AttributeType2["GRAPH"] = 5] = "GRAPH";
 AttributeType2[AttributeType2["FLOATS"] = 6] = "FLOATS";
 AttributeType2[AttributeType2["INTS"] = 7] = "INTS";
 AttributeType2[AttributeType2["STRINGS"] = 8] = "STRINGS";
 AttributeType2[AttributeType2["TENSORS"] = 9] = "TENSORS";
 AttributeType2[AttributeType2["GRAPHS"] = 10] = "GRAPHS";
 AttributeType2[AttributeType2["SPARSE_TENSOR"] = 11] = "SPARSE_TENSOR";
 AttributeType2[AttributeType2["SPARSE_TENSORS"] = 12] = "SPARSE_TENSORS";
 })(AttributeType = fbs2.AttributeType || (fbs2.AttributeType = {}));
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 let DimensionValueType;
 ((DimensionValueType2) => {
 DimensionValueType2[DimensionValueType2["UNKNOWN"] = 0] = "UNKNOWN";
 DimensionValueType2[DimensionValueType2["VALUE"] = 1] = "VALUE";
 DimensionValueType2[DimensionValueType2["PARAM"] = 2] = "PARAM";
 })(DimensionValueType = fbs2.DimensionValueType || (fbs2.DimensionValueType = {}));
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 let TensorDataType;
 ((TensorDataType2) => {
 TensorDataType2[TensorDataType2["UNDEFINED"] = 0] = "UNDEFINED";
 TensorDataType2[TensorDataType2["FLOAT"] = 1] = "FLOAT";
 TensorDataType2[TensorDataType2["UINT8"] = 2] = "UINT8";
 TensorDataType2[TensorDataType2["INT8"] = 3] = "INT8";
 TensorDataType2[TensorDataType2["UINT16"] = 4] = "UINT16";
 TensorDataType2[TensorDataType2["INT16"] = 5] = "INT16";
 TensorDataType2[TensorDataType2["INT32"] = 6] = "INT32";
 TensorDataType2[TensorDataType2["INT64"] = 7] = "INT64";
 TensorDataType2[TensorDataType2["STRING"] = 8] = "STRING";
 TensorDataType2[TensorDataType2["BOOL"] = 9] = "BOOL";
 TensorDataType2[TensorDataType2["FLOAT16"] = 10] = "FLOAT16";
 TensorDataType2[TensorDataType2["DOUBLE"] = 11] = "DOUBLE";
 TensorDataType2[TensorDataType2["UINT32"] = 12] = "UINT32";
 TensorDataType2[TensorDataType2["UINT64"] = 13] = "UINT64";
 TensorDataType2[TensorDataType2["COMPLEX64"] = 14] = "COMPLEX64";
 TensorDataType2[TensorDataType2["COMPLEX128"] = 15] = "COMPLEX128";
 TensorDataType2[TensorDataType2["BFLOAT16"] = 16] = "BFLOAT16";
 TensorDataType2[TensorDataType2["FLOAT8E4M3FN"] = 17] = "FLOAT8E4M3FN";
 TensorDataType2[TensorDataType2["FLOAT8E4M3FNUZ"] = 18] = "FLOAT8E4M3FNUZ";
 TensorDataType2[TensorDataType2["FLOAT8E5M2"] = 19] = "FLOAT8E5M2";
 TensorDataType2[TensorDataType2["FLOAT8E5M2FNUZ"] = 20] = "FLOAT8E5M2FNUZ";
 })(TensorDataType = fbs2.TensorDataType || (fbs2.TensorDataType = {}));
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 let NodeType;
 ((NodeType2) => {
 NodeType2[NodeType2["Primitive"] = 0] = "Primitive";
 NodeType2[NodeType2["Fused"] = 1] = "Fused";
 })(NodeType = fbs2.NodeType || (fbs2.NodeType = {}));
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 let TypeInfoValue;
 ((TypeInfoValue2) => {
 TypeInfoValue2[TypeInfoValue2["NONE"] = 0] = "NONE";
 TypeInfoValue2[TypeInfoValue2["tensor_type"] = 1] = "tensor_type";
 TypeInfoValue2[TypeInfoValue2["sequence_type"] = 2] = "sequence_type";
 TypeInfoValue2[TypeInfoValue2["map_type"] = 3] = "map_type";
 })(TypeInfoValue = fbs2.TypeInfoValue || (fbs2.TypeInfoValue = {}));
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class Shape {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns Shape
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param Shape= obj
 * @returns Shape
 */
 static getRootAsShape(bb, obj) {
 return (obj || new Shape()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param Shape= obj
 * @returns Shape
 */
 static getSizePrefixedRootAsShape(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new Shape()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param number index
 * @param onnxruntime.experimental.fbs.Dimension= obj
 * @returns onnxruntime.experimental.fbs.Dimension
 */
 dim(index, obj) {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? (obj || new onnxruntime2.experimental.fbs.Dimension()).__init(
 this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
 this.bb
 ) : null;
 }
 /**
 * @returns number
 */
 dimLength() {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startShape(builder) {
 builder.startObject(1);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset dimOffset
 */
 static addDim(builder, dimOffset) {
 builder.addFieldOffset(0, dimOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createDimVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startDimVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endShape(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createShape(builder, dimOffset) {
 Shape.startShape(builder);
 Shape.addDim(builder, dimOffset);
 return Shape.endShape(builder);
 }
 }
 fbs2.Shape = Shape;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class Dimension {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns Dimension
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param Dimension= obj
 * @returns Dimension
 */
 static getRootAsDimension(bb, obj) {
 return (obj || new Dimension()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param Dimension= obj
 * @returns Dimension
 */
 static getSizePrefixedRootAsDimension(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new Dimension()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param onnxruntime.experimental.fbs.DimensionValue= obj
 * @returns onnxruntime.experimental.fbs.DimensionValue|null
 */
 value(obj) {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? (obj || new onnxruntime2.experimental.fbs.DimensionValue()).__init(
 this.bb.__indirect(this.bb_pos + offset),
 this.bb
 ) : null;
 }
 denotation(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startDimension(builder) {
 builder.startObject(2);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset valueOffset
 */
 static addValue(builder, valueOffset) {
 builder.addFieldOffset(0, valueOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset denotationOffset
 */
 static addDenotation(builder, denotationOffset) {
 builder.addFieldOffset(1, denotationOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endDimension(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createDimension(builder, valueOffset, denotationOffset) {
 Dimension.startDimension(builder);
 Dimension.addValue(builder, valueOffset);
 Dimension.addDenotation(builder, denotationOffset);
 return Dimension.endDimension(builder);
 }
 }
 fbs2.Dimension = Dimension;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class DimensionValue {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns DimensionValue
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param DimensionValue= obj
 * @returns DimensionValue
 */
 static getRootAsDimensionValue(bb, obj) {
 return (obj || new DimensionValue()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param DimensionValue= obj
 * @returns DimensionValue
 */
 static getSizePrefixedRootAsDimensionValue(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new DimensionValue()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @returns onnxruntime.experimental.fbs.DimensionValueType
 */
 dimType() {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? (
 /** */
 this.bb.readInt8(this.bb_pos + offset)
 ) : 0 /* UNKNOWN */;
 }
 /**
 * @returns flatbuffers.Long
 */
 dimValue() {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0);
 }
 dimParam(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 8);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startDimensionValue(builder) {
 builder.startObject(3);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param onnxruntime.experimental.fbs.DimensionValueType dimType
 */
 static addDimType(builder, dimType) {
 builder.addFieldInt8(0, dimType, 0 /* UNKNOWN */);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Long dimValue
 */
 static addDimValue(builder, dimValue) {
 builder.addFieldInt64(1, dimValue, builder.createLong(0, 0));
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset dimParamOffset
 */
 static addDimParam(builder, dimParamOffset) {
 builder.addFieldOffset(2, dimParamOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endDimensionValue(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createDimensionValue(builder, dimType, dimValue, dimParamOffset) {
 DimensionValue.startDimensionValue(builder);
 DimensionValue.addDimType(builder, dimType);
 DimensionValue.addDimValue(builder, dimValue);
 DimensionValue.addDimParam(builder, dimParamOffset);
 return DimensionValue.endDimensionValue(builder);
 }
 }
 fbs2.DimensionValue = DimensionValue;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class TensorTypeAndShape {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns TensorTypeAndShape
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param TensorTypeAndShape= obj
 * @returns TensorTypeAndShape
 */
 static getRootAsTensorTypeAndShape(bb, obj) {
 return (obj || new TensorTypeAndShape()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param TensorTypeAndShape= obj
 * @returns TensorTypeAndShape
 */
 static getSizePrefixedRootAsTensorTypeAndShape(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new TensorTypeAndShape()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @returns onnxruntime.experimental.fbs.TensorDataType
 */
 elemType() {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? (
 /** */
 this.bb.readInt32(this.bb_pos + offset)
 ) : 0 /* UNDEFINED */;
 }
 /**
 * @param onnxruntime.experimental.fbs.Shape= obj
 * @returns onnxruntime.experimental.fbs.Shape|null
 */
 shape(obj) {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? (obj || new onnxruntime2.experimental.fbs.Shape()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startTensorTypeAndShape(builder) {
 builder.startObject(2);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param onnxruntime.experimental.fbs.TensorDataType elemType
 */
 static addElemType(builder, elemType) {
 builder.addFieldInt32(0, elemType, 0 /* UNDEFINED */);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset shapeOffset
 */
 static addShape(builder, shapeOffset) {
 builder.addFieldOffset(1, shapeOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endTensorTypeAndShape(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createTensorTypeAndShape(builder, elemType, shapeOffset) {
 TensorTypeAndShape.startTensorTypeAndShape(builder);
 TensorTypeAndShape.addElemType(builder, elemType);
 TensorTypeAndShape.addShape(builder, shapeOffset);
 return TensorTypeAndShape.endTensorTypeAndShape(builder);
 }
 }
 fbs2.TensorTypeAndShape = TensorTypeAndShape;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class MapType {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns MapType
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param MapType= obj
 * @returns MapType
 */
 static getRootAsMapType(bb, obj) {
 return (obj || new MapType()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param MapType= obj
 * @returns MapType
 */
 static getSizePrefixedRootAsMapType(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new MapType()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @returns onnxruntime.experimental.fbs.TensorDataType
 */
 keyType() {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? (
 /** */
 this.bb.readInt32(this.bb_pos + offset)
 ) : 0 /* UNDEFINED */;
 }
 /**
 * @param onnxruntime.experimental.fbs.TypeInfo= obj
 * @returns onnxruntime.experimental.fbs.TypeInfo|null
 */
 valueType(obj) {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? (obj || new onnxruntime2.experimental.fbs.TypeInfo()).__init(
 this.bb.__indirect(this.bb_pos + offset),
 this.bb
 ) : null;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startMapType(builder) {
 builder.startObject(2);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param onnxruntime.experimental.fbs.TensorDataType keyType
 */
 static addKeyType(builder, keyType) {
 builder.addFieldInt32(0, keyType, 0 /* UNDEFINED */);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset valueTypeOffset
 */
 static addValueType(builder, valueTypeOffset) {
 builder.addFieldOffset(1, valueTypeOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endMapType(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createMapType(builder, keyType, valueTypeOffset) {
 MapType.startMapType(builder);
 MapType.addKeyType(builder, keyType);
 MapType.addValueType(builder, valueTypeOffset);
 return MapType.endMapType(builder);
 }
 }
 fbs2.MapType = MapType;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class SequenceType {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns SequenceType
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param SequenceType= obj
 * @returns SequenceType
 */
 static getRootAsSequenceType(bb, obj) {
 return (obj || new SequenceType()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param SequenceType= obj
 * @returns SequenceType
 */
 static getSizePrefixedRootAsSequenceType(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new SequenceType()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param onnxruntime.experimental.fbs.TypeInfo= obj
 * @returns onnxruntime.experimental.fbs.TypeInfo|null
 */
 elemType(obj) {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? (obj || new onnxruntime2.experimental.fbs.TypeInfo()).__init(
 this.bb.__indirect(this.bb_pos + offset),
 this.bb
 ) : null;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startSequenceType(builder) {
 builder.startObject(1);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset elemTypeOffset
 */
 static addElemType(builder, elemTypeOffset) {
 builder.addFieldOffset(0, elemTypeOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endSequenceType(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createSequenceType(builder, elemTypeOffset) {
 SequenceType.startSequenceType(builder);
 SequenceType.addElemType(builder, elemTypeOffset);
 return SequenceType.endSequenceType(builder);
 }
 }
 fbs2.SequenceType = SequenceType;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class EdgeEnd {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns EdgeEnd
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @returns number
 */
 nodeIndex() {
 return this.bb.readUint32(this.bb_pos);
 }
 /**
 * @returns number
 */
 srcArgIndex() {
 return this.bb.readInt32(this.bb_pos + 4);
 }
 /**
 * @returns number
 */
 dstArgIndex() {
 return this.bb.readInt32(this.bb_pos + 8);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number node_index
 * @param number src_arg_index
 * @param number dst_arg_index
 * @returns flatbuffers.Offset
 */
 static createEdgeEnd(builder, node_index, src_arg_index, dst_arg_index) {
 builder.prep(4, 12);
 builder.writeInt32(dst_arg_index);
 builder.writeInt32(src_arg_index);
 builder.writeInt32(node_index);
 return builder.offset();
 }
 }
 fbs2.EdgeEnd = EdgeEnd;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class NodeEdge {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns NodeEdge
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param NodeEdge= obj
 * @returns NodeEdge
 */
 static getRootAsNodeEdge(bb, obj) {
 return (obj || new NodeEdge()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param NodeEdge= obj
 * @returns NodeEdge
 */
 static getSizePrefixedRootAsNodeEdge(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new NodeEdge()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @returns number
 */
 nodeIndex() {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
 }
 /**
 * @param number index
 * @param onnxruntime.experimental.fbs.EdgeEnd= obj
 * @returns onnxruntime.experimental.fbs.EdgeEnd
 */
 inputEdges(index, obj) {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? (obj || new onnxruntime2.experimental.fbs.EdgeEnd()).__init(
 this.bb.__vector(this.bb_pos + offset) + index * 12,
 this.bb
 ) : null;
 }
 /**
 * @returns number
 */
 inputEdgesLength() {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @param number index
 * @param onnxruntime.experimental.fbs.EdgeEnd= obj
 * @returns onnxruntime.experimental.fbs.EdgeEnd
 */
 outputEdges(index, obj) {
 let offset = this.bb.__offset(this.bb_pos, 8);
 return offset ? (obj || new onnxruntime2.experimental.fbs.EdgeEnd()).__init(
 this.bb.__vector(this.bb_pos + offset) + index * 12,
 this.bb
 ) : null;
 }
 /**
 * @returns number
 */
 outputEdgesLength() {
 let offset = this.bb.__offset(this.bb_pos, 8);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startNodeEdge(builder) {
 builder.startObject(3);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number nodeIndex
 */
 static addNodeIndex(builder, nodeIndex) {
 builder.addFieldInt32(0, nodeIndex, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset inputEdgesOffset
 */
 static addInputEdges(builder, inputEdgesOffset) {
 builder.addFieldOffset(1, inputEdgesOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startInputEdgesVector(builder, numElems) {
 builder.startVector(12, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset outputEdgesOffset
 */
 static addOutputEdges(builder, outputEdgesOffset) {
 builder.addFieldOffset(2, outputEdgesOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startOutputEdgesVector(builder, numElems) {
 builder.startVector(12, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endNodeEdge(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createNodeEdge(builder, nodeIndex, inputEdgesOffset, outputEdgesOffset) {
 NodeEdge.startNodeEdge(builder);
 NodeEdge.addNodeIndex(builder, nodeIndex);
 NodeEdge.addInputEdges(builder, inputEdgesOffset);
 NodeEdge.addOutputEdges(builder, outputEdgesOffset);
 return NodeEdge.endNodeEdge(builder);
 }
 }
 fbs2.NodeEdge = NodeEdge;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class Node2 {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns Node
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param Node= obj
 * @returns Node
 */
 static getRootAsNode(bb, obj) {
 return (obj || new Node2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param Node= obj
 * @returns Node
 */
 static getSizePrefixedRootAsNode(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new Node2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 name(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 docString(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 domain(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 8);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 /**
 * @returns number
 */
 sinceVersion() {
 let offset = this.bb.__offset(this.bb_pos, 10);
 return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
 }
 /**
 * @returns number
 */
 index() {
 let offset = this.bb.__offset(this.bb_pos, 12);
 return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
 }
 opType(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 14);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 /**
 * @returns onnxruntime.experimental.fbs.NodeType
 */
 type() {
 let offset = this.bb.__offset(this.bb_pos, 16);
 return offset ? (
 /** */
 this.bb.readInt32(this.bb_pos + offset)
 ) : 0 /* Primitive */;
 }
 executionProviderType(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 18);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 inputs(index, optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 20);
 return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
 }
 /**
 * @returns number
 */
 inputsLength() {
 let offset = this.bb.__offset(this.bb_pos, 20);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 outputs(index, optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 22);
 return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
 }
 /**
 * @returns number
 */
 outputsLength() {
 let offset = this.bb.__offset(this.bb_pos, 22);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @param number index
 * @param onnxruntime.experimental.fbs.Attribute= obj
 * @returns onnxruntime.experimental.fbs.Attribute
 */
 attributes(index, obj) {
 let offset = this.bb.__offset(this.bb_pos, 24);
 return offset ? (obj || new onnxruntime2.experimental.fbs.Attribute()).__init(
 this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
 this.bb
 ) : null;
 }
 /**
 * @returns number
 */
 attributesLength() {
 let offset = this.bb.__offset(this.bb_pos, 24);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @param number index
 * @returns number
 */
 inputArgCounts(index) {
 let offset = this.bb.__offset(this.bb_pos, 26);
 return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
 }
 /**
 * @returns number
 */
 inputArgCountsLength() {
 let offset = this.bb.__offset(this.bb_pos, 26);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @returns Int32Array
 */
 inputArgCountsArray() {
 let offset = this.bb.__offset(this.bb_pos, 26);
 return offset ? new Int32Array(
 this.bb.bytes().buffer,
 this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset),
 this.bb.__vector_len(this.bb_pos + offset)
 ) : null;
 }
 implicitInputs(index, optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 28);
 return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
 }
 /**
 * @returns number
 */
 implicitInputsLength() {
 let offset = this.bb.__offset(this.bb_pos, 28);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startNode(builder) {
 builder.startObject(13);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset nameOffset
 */
 static addName(builder, nameOffset) {
 builder.addFieldOffset(0, nameOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset docStringOffset
 */
 static addDocString(builder, docStringOffset) {
 builder.addFieldOffset(1, docStringOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset domainOffset
 */
 static addDomain(builder, domainOffset) {
 builder.addFieldOffset(2, domainOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number sinceVersion
 */
 static addSinceVersion(builder, sinceVersion) {
 builder.addFieldInt32(3, sinceVersion, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number index
 */
 static addIndex(builder, index) {
 builder.addFieldInt32(4, index, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset opTypeOffset
 */
 static addOpType(builder, opTypeOffset) {
 builder.addFieldOffset(5, opTypeOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param onnxruntime.experimental.fbs.NodeType type
 */
 static addType(builder, type) {
 builder.addFieldInt32(6, type, 0 /* Primitive */);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset executionProviderTypeOffset
 */
 static addExecutionProviderType(builder, executionProviderTypeOffset) {
 builder.addFieldOffset(7, executionProviderTypeOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset inputsOffset
 */
 static addInputs(builder, inputsOffset) {
 builder.addFieldOffset(8, inputsOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createInputsVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startInputsVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset outputsOffset
 */
 static addOutputs(builder, outputsOffset) {
 builder.addFieldOffset(9, outputsOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createOutputsVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startOutputsVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset attributesOffset
 */
 static addAttributes(builder, attributesOffset) {
 builder.addFieldOffset(10, attributesOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createAttributesVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startAttributesVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset inputArgCountsOffset
 */
 static addInputArgCounts(builder, inputArgCountsOffset) {
 builder.addFieldOffset(11, inputArgCountsOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<number> data
 * @returns flatbuffers.Offset
 */
 static createInputArgCountsVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addInt32(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startInputArgCountsVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset implicitInputsOffset
 */
 static addImplicitInputs(builder, implicitInputsOffset) {
 builder.addFieldOffset(12, implicitInputsOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createImplicitInputsVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startImplicitInputsVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endNode(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createNode(builder, nameOffset, docStringOffset, domainOffset, sinceVersion, index, opTypeOffset, type, executionProviderTypeOffset, inputsOffset, outputsOffset, attributesOffset, inputArgCountsOffset, implicitInputsOffset) {
 Node2.startNode(builder);
 Node2.addName(builder, nameOffset);
 Node2.addDocString(builder, docStringOffset);
 Node2.addDomain(builder, domainOffset);
 Node2.addSinceVersion(builder, sinceVersion);
 Node2.addIndex(builder, index);
 Node2.addOpType(builder, opTypeOffset);
 Node2.addType(builder, type);
 Node2.addExecutionProviderType(builder, executionProviderTypeOffset);
 Node2.addInputs(builder, inputsOffset);
 Node2.addOutputs(builder, outputsOffset);
 Node2.addAttributes(builder, attributesOffset);
 Node2.addInputArgCounts(builder, inputArgCountsOffset);
 Node2.addImplicitInputs(builder, implicitInputsOffset);
 return Node2.endNode(builder);
 }
 }
 fbs2.Node = Node2;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class ValueInfo {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns ValueInfo
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param ValueInfo= obj
 * @returns ValueInfo
 */
 static getRootAsValueInfo(bb, obj) {
 return (obj || new ValueInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param ValueInfo= obj
 * @returns ValueInfo
 */
 static getSizePrefixedRootAsValueInfo(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new ValueInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 name(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 docString(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 /**
 * @param onnxruntime.experimental.fbs.TypeInfo= obj
 * @returns onnxruntime.experimental.fbs.TypeInfo|null
 */
 type(obj) {
 let offset = this.bb.__offset(this.bb_pos, 8);
 return offset ? (obj || new onnxruntime2.experimental.fbs.TypeInfo()).__init(
 this.bb.__indirect(this.bb_pos + offset),
 this.bb
 ) : null;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startValueInfo(builder) {
 builder.startObject(3);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset nameOffset
 */
 static addName(builder, nameOffset) {
 builder.addFieldOffset(0, nameOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset docStringOffset
 */
 static addDocString(builder, docStringOffset) {
 builder.addFieldOffset(1, docStringOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset typeOffset
 */
 static addType(builder, typeOffset) {
 builder.addFieldOffset(2, typeOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endValueInfo(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createValueInfo(builder, nameOffset, docStringOffset, typeOffset) {
 ValueInfo.startValueInfo(builder);
 ValueInfo.addName(builder, nameOffset);
 ValueInfo.addDocString(builder, docStringOffset);
 ValueInfo.addType(builder, typeOffset);
 return ValueInfo.endValueInfo(builder);
 }
 }
 fbs2.ValueInfo = ValueInfo;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class TypeInfo {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns TypeInfo
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param TypeInfo= obj
 * @returns TypeInfo
 */
 static getRootAsTypeInfo(bb, obj) {
 return (obj || new TypeInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param TypeInfo= obj
 * @returns TypeInfo
 */
 static getSizePrefixedRootAsTypeInfo(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new TypeInfo()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 denotation(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 /**
 * @returns onnxruntime.experimental.fbs.TypeInfoValue
 */
 valueType() {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? (
 /** */
 this.bb.readUint8(this.bb_pos + offset)
 ) : 0 /* NONE */;
 }
 /**
 * @param flatbuffers.Table obj
 * @returns ?flatbuffers.Table
 */
 value(obj) {
 let offset = this.bb.__offset(this.bb_pos, 8);
 return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startTypeInfo(builder) {
 builder.startObject(3);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset denotationOffset
 */
 static addDenotation(builder, denotationOffset) {
 builder.addFieldOffset(0, denotationOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param onnxruntime.experimental.fbs.TypeInfoValue valueType
 */
 static addValueType(builder, valueType) {
 builder.addFieldInt8(1, valueType, 0 /* NONE */);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset valueOffset
 */
 static addValue(builder, valueOffset) {
 builder.addFieldOffset(2, valueOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endTypeInfo(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createTypeInfo(builder, denotationOffset, valueType, valueOffset) {
 TypeInfo.startTypeInfo(builder);
 TypeInfo.addDenotation(builder, denotationOffset);
 TypeInfo.addValueType(builder, valueType);
 TypeInfo.addValue(builder, valueOffset);
 return TypeInfo.endTypeInfo(builder);
 }
 }
 fbs2.TypeInfo = TypeInfo;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class OperatorSetId {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns OperatorSetId
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param OperatorSetId= obj
 * @returns OperatorSetId
 */
 static getRootAsOperatorSetId(bb, obj) {
 return (obj || new OperatorSetId()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param OperatorSetId= obj
 * @returns OperatorSetId
 */
 static getSizePrefixedRootAsOperatorSetId(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new OperatorSetId()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 domain(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 /**
 * @returns flatbuffers.Long
 */
 version() {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startOperatorSetId(builder) {
 builder.startObject(2);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset domainOffset
 */
 static addDomain(builder, domainOffset) {
 builder.addFieldOffset(0, domainOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Long version
 */
 static addVersion(builder, version3) {
 builder.addFieldInt64(1, version3, builder.createLong(0, 0));
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endOperatorSetId(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createOperatorSetId(builder, domainOffset, version3) {
 OperatorSetId.startOperatorSetId(builder);
 OperatorSetId.addDomain(builder, domainOffset);
 OperatorSetId.addVersion(builder, version3);
 return OperatorSetId.endOperatorSetId(builder);
 }
 }
 fbs2.OperatorSetId = OperatorSetId;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class Tensor4 {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns Tensor
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param Tensor= obj
 * @returns Tensor
 */
 static getRootAsTensor(bb, obj) {
 return (obj || new Tensor4()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param Tensor= obj
 * @returns Tensor
 */
 static getSizePrefixedRootAsTensor(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new Tensor4()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 name(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 docString(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 /**
 * @param number index
 * @returns flatbuffers.Long
 */
 dims(index) {
 let offset = this.bb.__offset(this.bb_pos, 8);
 return offset ? this.bb.readInt64(this.bb.__vector(this.bb_pos + offset) + index * 8) : this.bb.createLong(0, 0);
 }
 /**
 * @returns number
 */
 dimsLength() {
 let offset = this.bb.__offset(this.bb_pos, 8);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @returns onnxruntime.experimental.fbs.TensorDataType
 */
 dataType() {
 let offset = this.bb.__offset(this.bb_pos, 10);
 return offset ? (
 /** */
 this.bb.readInt32(this.bb_pos + offset)
 ) : 0 /* UNDEFINED */;
 }
 /**
 * @param number index
 * @returns number
 */
 rawData(index) {
 let offset = this.bb.__offset(this.bb_pos, 12);
 return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
 }
 /**
 * @returns number
 */
 rawDataLength() {
 let offset = this.bb.__offset(this.bb_pos, 12);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @returns Uint8Array
 */
 rawDataArray() {
 let offset = this.bb.__offset(this.bb_pos, 12);
 return offset ? new Uint8Array(
 this.bb.bytes().buffer,
 this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset),
 this.bb.__vector_len(this.bb_pos + offset)
 ) : null;
 }
 stringData(index, optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 14);
 return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
 }
 /**
 * @returns number
 */
 stringDataLength() {
 let offset = this.bb.__offset(this.bb_pos, 14);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startTensor(builder) {
 builder.startObject(6);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset nameOffset
 */
 static addName(builder, nameOffset) {
 builder.addFieldOffset(0, nameOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset docStringOffset
 */
 static addDocString(builder, docStringOffset) {
 builder.addFieldOffset(1, docStringOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset dimsOffset
 */
 static addDims(builder, dimsOffset) {
 builder.addFieldOffset(2, dimsOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Long> data
 * @returns flatbuffers.Offset
 */
 static createDimsVector(builder, data) {
 builder.startVector(8, data.length, 8);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addInt64(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startDimsVector(builder, numElems) {
 builder.startVector(8, numElems, 8);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param onnxruntime.experimental.fbs.TensorDataType dataType
 */
 static addDataType(builder, dataType) {
 builder.addFieldInt32(3, dataType, 0 /* UNDEFINED */);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset rawDataOffset
 */
 static addRawData(builder, rawDataOffset) {
 builder.addFieldOffset(4, rawDataOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<number> data
 * @returns flatbuffers.Offset
 */
 static createRawDataVector(builder, data) {
 builder.startVector(1, data.length, 1);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addInt8(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startRawDataVector(builder, numElems) {
 builder.startVector(1, numElems, 1);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset stringDataOffset
 */
 static addStringData(builder, stringDataOffset) {
 builder.addFieldOffset(5, stringDataOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createStringDataVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startStringDataVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endTensor(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createTensor(builder, nameOffset, docStringOffset, dimsOffset, dataType, rawDataOffset, stringDataOffset) {
 Tensor4.startTensor(builder);
 Tensor4.addName(builder, nameOffset);
 Tensor4.addDocString(builder, docStringOffset);
 Tensor4.addDims(builder, dimsOffset);
 Tensor4.addDataType(builder, dataType);
 Tensor4.addRawData(builder, rawDataOffset);
 Tensor4.addStringData(builder, stringDataOffset);
 return Tensor4.endTensor(builder);
 }
 }
 fbs2.Tensor = Tensor4;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class SparseTensor {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns SparseTensor
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param SparseTensor= obj
 * @returns SparseTensor
 */
 static getRootAsSparseTensor(bb, obj) {
 return (obj || new SparseTensor()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param SparseTensor= obj
 * @returns SparseTensor
 */
 static getSizePrefixedRootAsSparseTensor(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new SparseTensor()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param onnxruntime.experimental.fbs.Tensor= obj
 * @returns onnxruntime.experimental.fbs.Tensor|null
 */
 values(obj) {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? (obj || new onnxruntime2.experimental.fbs.Tensor()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
 }
 /**
 * @param onnxruntime.experimental.fbs.Tensor= obj
 * @returns onnxruntime.experimental.fbs.Tensor|null
 */
 indices(obj) {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? (obj || new onnxruntime2.experimental.fbs.Tensor()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
 }
 /**
 * @param number index
 * @returns flatbuffers.Long
 */
 dims(index) {
 let offset = this.bb.__offset(this.bb_pos, 8);
 return offset ? this.bb.readInt64(this.bb.__vector(this.bb_pos + offset) + index * 8) : this.bb.createLong(0, 0);
 }
 /**
 * @returns number
 */
 dimsLength() {
 let offset = this.bb.__offset(this.bb_pos, 8);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startSparseTensor(builder) {
 builder.startObject(3);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset valuesOffset
 */
 static addValues(builder, valuesOffset) {
 builder.addFieldOffset(0, valuesOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset indicesOffset
 */
 static addIndices(builder, indicesOffset) {
 builder.addFieldOffset(1, indicesOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset dimsOffset
 */
 static addDims(builder, dimsOffset) {
 builder.addFieldOffset(2, dimsOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Long> data
 * @returns flatbuffers.Offset
 */
 static createDimsVector(builder, data) {
 builder.startVector(8, data.length, 8);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addInt64(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startDimsVector(builder, numElems) {
 builder.startVector(8, numElems, 8);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endSparseTensor(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createSparseTensor(builder, valuesOffset, indicesOffset, dimsOffset) {
 SparseTensor.startSparseTensor(builder);
 SparseTensor.addValues(builder, valuesOffset);
 SparseTensor.addIndices(builder, indicesOffset);
 SparseTensor.addDims(builder, dimsOffset);
 return SparseTensor.endSparseTensor(builder);
 }
 }
 fbs2.SparseTensor = SparseTensor;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class Attribute2 {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns Attribute
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param Attribute= obj
 * @returns Attribute
 */
 static getRootAsAttribute(bb, obj) {
 return (obj || new Attribute2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param Attribute= obj
 * @returns Attribute
 */
 static getSizePrefixedRootAsAttribute(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new Attribute2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 name(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 docString(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 /**
 * @returns onnxruntime.experimental.fbs.AttributeType
 */
 type() {
 let offset = this.bb.__offset(this.bb_pos, 8);
 return offset ? (
 /** */
 this.bb.readInt32(this.bb_pos + offset)
 ) : 0 /* UNDEFINED */;
 }
 /**
 * @returns number
 */
 f() {
 let offset = this.bb.__offset(this.bb_pos, 10);
 return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0;
 }
 /**
 * @returns flatbuffers.Long
 */
 i() {
 let offset = this.bb.__offset(this.bb_pos, 12);
 return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0);
 }
 s(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 14);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 /**
 * @param onnxruntime.experimental.fbs.Tensor= obj
 * @returns onnxruntime.experimental.fbs.Tensor|null
 */
 t(obj) {
 let offset = this.bb.__offset(this.bb_pos, 16);
 return offset ? (obj || new onnxruntime2.experimental.fbs.Tensor()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
 }
 /**
 * @param onnxruntime.experimental.fbs.Graph= obj
 * @returns onnxruntime.experimental.fbs.Graph|null
 */
 g(obj) {
 let offset = this.bb.__offset(this.bb_pos, 18);
 return offset ? (obj || new onnxruntime2.experimental.fbs.Graph()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
 }
 /**
 * @param number index
 * @returns number
 */
 floats(index) {
 let offset = this.bb.__offset(this.bb_pos, 20);
 return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
 }
 /**
 * @returns number
 */
 floatsLength() {
 let offset = this.bb.__offset(this.bb_pos, 20);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @returns Float32Array
 */
 floatsArray() {
 let offset = this.bb.__offset(this.bb_pos, 20);
 return offset ? new Float32Array(
 this.bb.bytes().buffer,
 this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset),
 this.bb.__vector_len(this.bb_pos + offset)
 ) : null;
 }
 /**
 * @param number index
 * @returns flatbuffers.Long
 */
 ints(index) {
 let offset = this.bb.__offset(this.bb_pos, 22);
 return offset ? this.bb.readInt64(this.bb.__vector(this.bb_pos + offset) + index * 8) : this.bb.createLong(0, 0);
 }
 /**
 * @returns number
 */
 intsLength() {
 let offset = this.bb.__offset(this.bb_pos, 22);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 strings(index, optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 24);
 return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
 }
 /**
 * @returns number
 */
 stringsLength() {
 let offset = this.bb.__offset(this.bb_pos, 24);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @param number index
 * @param onnxruntime.experimental.fbs.Tensor= obj
 * @returns onnxruntime.experimental.fbs.Tensor
 */
 tensors(index, obj) {
 let offset = this.bb.__offset(this.bb_pos, 26);
 return offset ? (obj || new onnxruntime2.experimental.fbs.Tensor()).__init(
 this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
 this.bb
 ) : null;
 }
 /**
 * @returns number
 */
 tensorsLength() {
 let offset = this.bb.__offset(this.bb_pos, 26);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @param number index
 * @param onnxruntime.experimental.fbs.Graph= obj
 * @returns onnxruntime.experimental.fbs.Graph
 */
 graphs(index, obj) {
 let offset = this.bb.__offset(this.bb_pos, 28);
 return offset ? (obj || new onnxruntime2.experimental.fbs.Graph()).__init(
 this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
 this.bb
 ) : null;
 }
 /**
 * @returns number
 */
 graphsLength() {
 let offset = this.bb.__offset(this.bb_pos, 28);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startAttribute(builder) {
 builder.startObject(13);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset nameOffset
 */
 static addName(builder, nameOffset) {
 builder.addFieldOffset(0, nameOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset docStringOffset
 */
 static addDocString(builder, docStringOffset) {
 builder.addFieldOffset(1, docStringOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param onnxruntime.experimental.fbs.AttributeType type
 */
 static addType(builder, type) {
 builder.addFieldInt32(2, type, 0 /* UNDEFINED */);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number f
 */
 static addF(builder, f) {
 builder.addFieldFloat32(3, f, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Long i
 */
 static addI(builder, i) {
 builder.addFieldInt64(4, i, builder.createLong(0, 0));
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset sOffset
 */
 static addS(builder, sOffset) {
 builder.addFieldOffset(5, sOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset tOffset
 */
 static addT(builder, tOffset) {
 builder.addFieldOffset(6, tOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset gOffset
 */
 static addG(builder, gOffset) {
 builder.addFieldOffset(7, gOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset floatsOffset
 */
 static addFloats(builder, floatsOffset) {
 builder.addFieldOffset(8, floatsOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<number> data
 * @returns flatbuffers.Offset
 */
 static createFloatsVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addFloat32(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startFloatsVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset intsOffset
 */
 static addInts(builder, intsOffset) {
 builder.addFieldOffset(9, intsOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Long> data
 * @returns flatbuffers.Offset
 */
 static createIntsVector(builder, data) {
 builder.startVector(8, data.length, 8);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addInt64(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startIntsVector(builder, numElems) {
 builder.startVector(8, numElems, 8);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset stringsOffset
 */
 static addStrings(builder, stringsOffset) {
 builder.addFieldOffset(10, stringsOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createStringsVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startStringsVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset tensorsOffset
 */
 static addTensors(builder, tensorsOffset) {
 builder.addFieldOffset(11, tensorsOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createTensorsVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startTensorsVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset graphsOffset
 */
 static addGraphs(builder, graphsOffset) {
 builder.addFieldOffset(12, graphsOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createGraphsVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startGraphsVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endAttribute(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createAttribute(builder, nameOffset, docStringOffset, type, f, i, sOffset, tOffset, gOffset, floatsOffset, intsOffset, stringsOffset, tensorsOffset, graphsOffset) {
 Attribute2.startAttribute(builder);
 Attribute2.addName(builder, nameOffset);
 Attribute2.addDocString(builder, docStringOffset);
 Attribute2.addType(builder, type);
 Attribute2.addF(builder, f);
 Attribute2.addI(builder, i);
 Attribute2.addS(builder, sOffset);
 Attribute2.addT(builder, tOffset);
 Attribute2.addG(builder, gOffset);
 Attribute2.addFloats(builder, floatsOffset);
 Attribute2.addInts(builder, intsOffset);
 Attribute2.addStrings(builder, stringsOffset);
 Attribute2.addTensors(builder, tensorsOffset);
 Attribute2.addGraphs(builder, graphsOffset);
 return Attribute2.endAttribute(builder);
 }
 }
 fbs2.Attribute = Attribute2;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class Graph2 {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns Graph
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param Graph= obj
 * @returns Graph
 */
 static getRootAsGraph(bb, obj) {
 return (obj || new Graph2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param Graph= obj
 * @returns Graph
 */
 static getSizePrefixedRootAsGraph(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new Graph2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param number index
 * @param onnxruntime.experimental.fbs.Tensor= obj
 * @returns onnxruntime.experimental.fbs.Tensor
 */
 initializers(index, obj) {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? (obj || new onnxruntime2.experimental.fbs.Tensor()).__init(
 this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
 this.bb
 ) : null;
 }
 /**
 * @returns number
 */
 initializersLength() {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @param number index
 * @param onnxruntime.experimental.fbs.ValueInfo= obj
 * @returns onnxruntime.experimental.fbs.ValueInfo
 */
 nodeArgs(index, obj) {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? (obj || new onnxruntime2.experimental.fbs.ValueInfo()).__init(
 this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
 this.bb
 ) : null;
 }
 /**
 * @returns number
 */
 nodeArgsLength() {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @param number index
 * @param onnxruntime.experimental.fbs.Node= obj
 * @returns onnxruntime.experimental.fbs.Node
 */
 nodes(index, obj) {
 let offset = this.bb.__offset(this.bb_pos, 8);
 return offset ? (obj || new onnxruntime2.experimental.fbs.Node()).__init(
 this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
 this.bb
 ) : null;
 }
 /**
 * @returns number
 */
 nodesLength() {
 let offset = this.bb.__offset(this.bb_pos, 8);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @returns number
 */
 maxNodeIndex() {
 let offset = this.bb.__offset(this.bb_pos, 10);
 return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
 }
 /**
 * @param number index
 * @param onnxruntime.experimental.fbs.NodeEdge= obj
 * @returns onnxruntime.experimental.fbs.NodeEdge
 */
 nodeEdges(index, obj) {
 let offset = this.bb.__offset(this.bb_pos, 12);
 return offset ? (obj || new onnxruntime2.experimental.fbs.NodeEdge()).__init(
 this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
 this.bb
 ) : null;
 }
 /**
 * @returns number
 */
 nodeEdgesLength() {
 let offset = this.bb.__offset(this.bb_pos, 12);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 inputs(index, optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 14);
 return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
 }
 /**
 * @returns number
 */
 inputsLength() {
 let offset = this.bb.__offset(this.bb_pos, 14);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 outputs(index, optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 16);
 return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
 }
 /**
 * @returns number
 */
 outputsLength() {
 let offset = this.bb.__offset(this.bb_pos, 16);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @param number index
 * @param onnxruntime.experimental.fbs.SparseTensor= obj
 * @returns onnxruntime.experimental.fbs.SparseTensor
 */
 sparseInitializers(index, obj) {
 let offset = this.bb.__offset(this.bb_pos, 18);
 return offset ? (obj || new onnxruntime2.experimental.fbs.SparseTensor()).__init(
 this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
 this.bb
 ) : null;
 }
 /**
 * @returns number
 */
 sparseInitializersLength() {
 let offset = this.bb.__offset(this.bb_pos, 18);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startGraph(builder) {
 builder.startObject(8);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset initializersOffset
 */
 static addInitializers(builder, initializersOffset) {
 builder.addFieldOffset(0, initializersOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createInitializersVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startInitializersVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset nodeArgsOffset
 */
 static addNodeArgs(builder, nodeArgsOffset) {
 builder.addFieldOffset(1, nodeArgsOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createNodeArgsVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startNodeArgsVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset nodesOffset
 */
 static addNodes(builder, nodesOffset) {
 builder.addFieldOffset(2, nodesOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createNodesVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startNodesVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number maxNodeIndex
 */
 static addMaxNodeIndex(builder, maxNodeIndex) {
 builder.addFieldInt32(3, maxNodeIndex, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset nodeEdgesOffset
 */
 static addNodeEdges(builder, nodeEdgesOffset) {
 builder.addFieldOffset(4, nodeEdgesOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createNodeEdgesVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startNodeEdgesVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset inputsOffset
 */
 static addInputs(builder, inputsOffset) {
 builder.addFieldOffset(5, inputsOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createInputsVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startInputsVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset outputsOffset
 */
 static addOutputs(builder, outputsOffset) {
 builder.addFieldOffset(6, outputsOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createOutputsVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startOutputsVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset sparseInitializersOffset
 */
 static addSparseInitializers(builder, sparseInitializersOffset) {
 builder.addFieldOffset(7, sparseInitializersOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createSparseInitializersVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startSparseInitializersVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endGraph(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createGraph(builder, initializersOffset, nodeArgsOffset, nodesOffset, maxNodeIndex, nodeEdgesOffset, inputsOffset, outputsOffset, sparseInitializersOffset) {
 Graph2.startGraph(builder);
 Graph2.addInitializers(builder, initializersOffset);
 Graph2.addNodeArgs(builder, nodeArgsOffset);
 Graph2.addNodes(builder, nodesOffset);
 Graph2.addMaxNodeIndex(builder, maxNodeIndex);
 Graph2.addNodeEdges(builder, nodeEdgesOffset);
 Graph2.addInputs(builder, inputsOffset);
 Graph2.addOutputs(builder, outputsOffset);
 Graph2.addSparseInitializers(builder, sparseInitializersOffset);
 return Graph2.endGraph(builder);
 }
 }
 fbs2.Graph = Graph2;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class Model2 {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns Model
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param Model= obj
 * @returns Model
 */
 static getRootAsModel(bb, obj) {
 return (obj || new Model2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param Model= obj
 * @returns Model
 */
 static getSizePrefixedRootAsModel(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new Model2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @returns flatbuffers.Long
 */
 irVersion() {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0);
 }
 /**
 * @param number index
 * @param onnxruntime.experimental.fbs.OperatorSetId= obj
 * @returns onnxruntime.experimental.fbs.OperatorSetId
 */
 opsetImport(index, obj) {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? (obj || new onnxruntime2.experimental.fbs.OperatorSetId()).__init(
 this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
 this.bb
 ) : null;
 }
 /**
 * @returns number
 */
 opsetImportLength() {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 producerName(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 8);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 producerVersion(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 10);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 domain(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 12);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 /**
 * @returns flatbuffers.Long
 */
 modelVersion() {
 let offset = this.bb.__offset(this.bb_pos, 14);
 return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0);
 }
 docString(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 16);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 /**
 * @param onnxruntime.experimental.fbs.Graph= obj
 * @returns onnxruntime.experimental.fbs.Graph|null
 */
 graph(obj) {
 let offset = this.bb.__offset(this.bb_pos, 18);
 return offset ? (obj || new onnxruntime2.experimental.fbs.Graph()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
 }
 graphDocString(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 20);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startModel(builder) {
 builder.startObject(9);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Long irVersion
 */
 static addIrVersion(builder, irVersion) {
 builder.addFieldInt64(0, irVersion, builder.createLong(0, 0));
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset opsetImportOffset
 */
 static addOpsetImport(builder, opsetImportOffset) {
 builder.addFieldOffset(1, opsetImportOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createOpsetImportVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startOpsetImportVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset producerNameOffset
 */
 static addProducerName(builder, producerNameOffset) {
 builder.addFieldOffset(2, producerNameOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset producerVersionOffset
 */
 static addProducerVersion(builder, producerVersionOffset) {
 builder.addFieldOffset(3, producerVersionOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset domainOffset
 */
 static addDomain(builder, domainOffset) {
 builder.addFieldOffset(4, domainOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Long modelVersion
 */
 static addModelVersion(builder, modelVersion) {
 builder.addFieldInt64(5, modelVersion, builder.createLong(0, 0));
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset docStringOffset
 */
 static addDocString(builder, docStringOffset) {
 builder.addFieldOffset(6, docStringOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset graphOffset
 */
 static addGraph(builder, graphOffset) {
 builder.addFieldOffset(7, graphOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset graphDocStringOffset
 */
 static addGraphDocString(builder, graphDocStringOffset) {
 builder.addFieldOffset(8, graphDocStringOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endModel(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createModel(builder, irVersion, opsetImportOffset, producerNameOffset, producerVersionOffset, domainOffset, modelVersion, docStringOffset, graphOffset, graphDocStringOffset) {
 Model2.startModel(builder);
 Model2.addIrVersion(builder, irVersion);
 Model2.addOpsetImport(builder, opsetImportOffset);
 Model2.addProducerName(builder, producerNameOffset);
 Model2.addProducerVersion(builder, producerVersionOffset);
 Model2.addDomain(builder, domainOffset);
 Model2.addModelVersion(builder, modelVersion);
 Model2.addDocString(builder, docStringOffset);
 Model2.addGraph(builder, graphOffset);
 Model2.addGraphDocString(builder, graphDocStringOffset);
 return Model2.endModel(builder);
 }
 }
 fbs2.Model = Model2;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class KernelCreateInfos {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns KernelCreateInfos
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param KernelCreateInfos= obj
 * @returns KernelCreateInfos
 */
 static getRootAsKernelCreateInfos(bb, obj) {
 return (obj || new KernelCreateInfos()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param KernelCreateInfos= obj
 * @returns KernelCreateInfos
 */
 static getSizePrefixedRootAsKernelCreateInfos(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new KernelCreateInfos()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param number index
 * @returns number
 */
 nodeIndices(index) {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? this.bb.readUint32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
 }
 /**
 * @returns number
 */
 nodeIndicesLength() {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @returns Uint32Array
 */
 nodeIndicesArray() {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? new Uint32Array(
 this.bb.bytes().buffer,
 this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset),
 this.bb.__vector_len(this.bb_pos + offset)
 ) : null;
 }
 /**
 * @param number index
 * @returns flatbuffers.Long
 */
 kernelDefHashes(index) {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? this.bb.readUint64(this.bb.__vector(this.bb_pos + offset) + index * 8) : this.bb.createLong(0, 0);
 }
 /**
 * @returns number
 */
 kernelDefHashesLength() {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startKernelCreateInfos(builder) {
 builder.startObject(2);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset nodeIndicesOffset
 */
 static addNodeIndices(builder, nodeIndicesOffset) {
 builder.addFieldOffset(0, nodeIndicesOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<number> data
 * @returns flatbuffers.Offset
 */
 static createNodeIndicesVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addInt32(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startNodeIndicesVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset kernelDefHashesOffset
 */
 static addKernelDefHashes(builder, kernelDefHashesOffset) {
 builder.addFieldOffset(1, kernelDefHashesOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Long> data
 * @returns flatbuffers.Offset
 */
 static createKernelDefHashesVector(builder, data) {
 builder.startVector(8, data.length, 8);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addInt64(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startKernelDefHashesVector(builder, numElems) {
 builder.startVector(8, numElems, 8);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endKernelCreateInfos(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createKernelCreateInfos(builder, nodeIndicesOffset, kernelDefHashesOffset) {
 KernelCreateInfos.startKernelCreateInfos(builder);
 KernelCreateInfos.addNodeIndices(builder, nodeIndicesOffset);
 KernelCreateInfos.addKernelDefHashes(builder, kernelDefHashesOffset);
 return KernelCreateInfos.endKernelCreateInfos(builder);
 }
 }
 fbs2.KernelCreateInfos = KernelCreateInfos;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class SubGraphSessionState {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns SubGraphSessionState
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param SubGraphSessionState= obj
 * @returns SubGraphSessionState
 */
 static getRootAsSubGraphSessionState(bb, obj) {
 return (obj || new SubGraphSessionState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param SubGraphSessionState= obj
 * @returns SubGraphSessionState
 */
 static getSizePrefixedRootAsSubGraphSessionState(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new SubGraphSessionState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 graphId(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 /**
 * @param onnxruntime.experimental.fbs.SessionState= obj
 * @returns onnxruntime.experimental.fbs.SessionState|null
 */
 sessionState(obj) {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? (obj || new onnxruntime2.experimental.fbs.SessionState()).__init(
 this.bb.__indirect(this.bb_pos + offset),
 this.bb
 ) : null;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startSubGraphSessionState(builder) {
 builder.startObject(2);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset graphIdOffset
 */
 static addGraphId(builder, graphIdOffset) {
 builder.addFieldOffset(0, graphIdOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset sessionStateOffset
 */
 static addSessionState(builder, sessionStateOffset) {
 builder.addFieldOffset(1, sessionStateOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endSubGraphSessionState(builder) {
 let offset = builder.endObject();
 builder.requiredField(offset, 4);
 return offset;
 }
 static createSubGraphSessionState(builder, graphIdOffset, sessionStateOffset) {
 SubGraphSessionState.startSubGraphSessionState(builder);
 SubGraphSessionState.addGraphId(builder, graphIdOffset);
 SubGraphSessionState.addSessionState(builder, sessionStateOffset);
 return SubGraphSessionState.endSubGraphSessionState(builder);
 }
 }
 fbs2.SubGraphSessionState = SubGraphSessionState;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class SessionState {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns SessionState
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param SessionState= obj
 * @returns SessionState
 */
 static getRootAsSessionState(bb, obj) {
 return (obj || new SessionState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param SessionState= obj
 * @returns SessionState
 */
 static getSizePrefixedRootAsSessionState(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new SessionState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param onnxruntime.experimental.fbs.KernelCreateInfos= obj
 * @returns onnxruntime.experimental.fbs.KernelCreateInfos|null
 */
 kernels(obj) {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? (obj || new onnxruntime2.experimental.fbs.KernelCreateInfos()).__init(
 this.bb.__indirect(this.bb_pos + offset),
 this.bb
 ) : null;
 }
 /**
 * @param number index
 * @param onnxruntime.experimental.fbs.SubGraphSessionState= obj
 * @returns onnxruntime.experimental.fbs.SubGraphSessionState
 */
 subGraphSessionStates(index, obj) {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? (obj || new onnxruntime2.experimental.fbs.SubGraphSessionState()).__init(
 this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4),
 this.bb
 ) : null;
 }
 /**
 * @returns number
 */
 subGraphSessionStatesLength() {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startSessionState(builder) {
 builder.startObject(2);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset kernelsOffset
 */
 static addKernels(builder, kernelsOffset) {
 builder.addFieldOffset(0, kernelsOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset subGraphSessionStatesOffset
 */
 static addSubGraphSessionStates(builder, subGraphSessionStatesOffset) {
 builder.addFieldOffset(1, subGraphSessionStatesOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param Array.<flatbuffers.Offset> data
 * @returns flatbuffers.Offset
 */
 static createSubGraphSessionStatesVector(builder, data) {
 builder.startVector(4, data.length, 4);
 for (let i = data.length - 1; i >= 0; i--) {
 builder.addOffset(data[i]);
 }
 return builder.endVector();
 }
 /**
 * @param flatbuffers.Builder builder
 * @param number numElems
 */
 static startSubGraphSessionStatesVector(builder, numElems) {
 builder.startVector(4, numElems, 4);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endSessionState(builder) {
 let offset = builder.endObject();
 return offset;
 }
 static createSessionState(builder, kernelsOffset, subGraphSessionStatesOffset) {
 SessionState.startSessionState(builder);
 SessionState.addKernels(builder, kernelsOffset);
 SessionState.addSubGraphSessionStates(builder, subGraphSessionStatesOffset);
 return SessionState.endSessionState(builder);
 }
 }
 fbs2.SessionState = SessionState;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 ((onnxruntime2) => {
 let experimental;
 ((experimental2) => {
 let fbs;
 ((fbs2) => {
 class InferenceSession7 {
 constructor() {
 this.bb = null;
 this.bb_pos = 0;
 }
 /**
 * @param number i
 * @param flatbuffers.ByteBuffer bb
 * @returns InferenceSession
 */
 __init(i, bb) {
 this.bb_pos = i;
 this.bb = bb;
 return this;
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param InferenceSession= obj
 * @returns InferenceSession
 */
 static getRootAsInferenceSession(bb, obj) {
 return (obj || new InferenceSession7()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @param InferenceSession= obj
 * @returns InferenceSession
 */
 static getSizePrefixedRootAsInferenceSession(bb, obj) {
 bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
 return (obj || new InferenceSession7()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 }
 /**
 * @param flatbuffers.ByteBuffer bb
 * @returns boolean
 */
 static bufferHasIdentifier(bb) {
 return bb.__has_identifier("ORTM");
 }
 ortVersion(optionalEncoding) {
 let offset = this.bb.__offset(this.bb_pos, 4);
 return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 }
 /**
 * @param onnxruntime.experimental.fbs.Model= obj
 * @returns onnxruntime.experimental.fbs.Model|null
 */
 model(obj) {
 let offset = this.bb.__offset(this.bb_pos, 6);
 return offset ? (obj || new onnxruntime2.experimental.fbs.Model()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
 }
 /**
 * @param onnxruntime.experimental.fbs.SessionState= obj
 * @returns onnxruntime.experimental.fbs.SessionState|null
 */
 sessionState(obj) {
 let offset = this.bb.__offset(this.bb_pos, 8);
 return offset ? (obj || new onnxruntime2.experimental.fbs.SessionState()).__init(
 this.bb.__indirect(this.bb_pos + offset),
 this.bb
 ) : null;
 }
 /**
 * @param flatbuffers.Builder builder
 */
 static startInferenceSession(builder) {
 builder.startObject(3);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset ortVersionOffset
 */
 static addOrtVersion(builder, ortVersionOffset) {
 builder.addFieldOffset(0, ortVersionOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset modelOffset
 */
 static addModel(builder, modelOffset) {
 builder.addFieldOffset(1, modelOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset sessionStateOffset
 */
 static addSessionState(builder, sessionStateOffset) {
 builder.addFieldOffset(2, sessionStateOffset, 0);
 }
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
 */
 static endInferenceSession(builder) {
 let offset = builder.endObject();
 return offset;
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset offset
 */
 static finishInferenceSessionBuffer(builder, offset) {
 builder.finish(offset, "ORTM");
 }
 /**
 * @param flatbuffers.Builder builder
 * @param flatbuffers.Offset offset
 */
 static finishSizePrefixedInferenceSessionBuffer(builder, offset) {
 builder.finish(offset, "ORTM", true);
 }
 static createInferenceSession(builder, ortVersionOffset, modelOffset, sessionStateOffset) {
 InferenceSession7.startInferenceSession(builder);
 InferenceSession7.addOrtVersion(builder, ortVersionOffset);
 InferenceSession7.addModel(builder, modelOffset);
 InferenceSession7.addSessionState(builder, sessionStateOffset);
 return InferenceSession7.endInferenceSession(builder);
 }
 }
 fbs2.InferenceSession = InferenceSession7;
 })(fbs = experimental2.fbs || (experimental2.fbs = {}));
 })(experimental = onnxruntime2.experimental || (onnxruntime2.experimental = {}));
 })(onnxruntime || (onnxruntime = {}));
 }
});

// web/node_modules/@protobufjs/aspromise/index.js
var require_aspromise = __commonJS({
 "web/node_modules/@protobufjs/aspromise/index.js"(exports2, module2) {
 "use strict";
 module2.exports = asPromise;
 function asPromise(fn, ctx) {
 var params = new Array(arguments.length - 1), offset = 0, index = 2, pending = true;
 while (index < arguments.length)
 params[offset++] = arguments[index++];
 return new Promise(function executor(resolve, reject) {
 params[offset] = function callback(err) {
 if (pending) {
 pending = false;
 if (err)
 reject(err);
 else {
 var params2 = new Array(arguments.length - 1), offset2 = 0;
 while (offset2 < params2.length)
 params2[offset2++] = arguments[offset2];
 resolve.apply(null, params2);
 }
 }
 };
 try {
 fn.apply(ctx || null, params);
 } catch (err) {
 if (pending) {
 pending = false;
 reject(err);
 }
 }
 });
 }
 }
});

// web/node_modules/@protobufjs/base64/index.js
var require_base64 = __commonJS({
 "web/node_modules/@protobufjs/base64/index.js"(exports2) {
 "use strict";
 var base64 = exports2;
 base64.length = function length(string) {
 var p = string.length;
 if (!p)
 return 0;
 var n = 0;
 while (--p % 4 > 1 && string.charAt(p) === "=")
 ++n;
 return Math.ceil(string.length * 3) / 4 - n;
 };
 var b64 = new Array(64);
 var s64 = new Array(123);
 for (i = 0; i < 64; )
 s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
 var i;
 base64.encode = function encode(buffer, start, end) {
 var parts = null, chunk = [];
 var i2 = 0, j = 0, t;
 while (start < end) {
 var b = buffer[start++];
 switch (j) {
 case 0:
 chunk[i2++] = b64[b >> 2];
 t = (b & 3) << 4;
 j = 1;
 break;
 case 1:
 chunk[i2++] = b64[t | b >> 4];
 t = (b & 15) << 2;
 j = 2;
 break;
 case 2:
 chunk[i2++] = b64[t | b >> 6];
 chunk[i2++] = b64[b & 63];
 j = 0;
 break;
 }
 if (i2 > 8191) {
 (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
 i2 = 0;
 }
 }
 if (j) {
 chunk[i2++] = b64[t];
 chunk[i2++] = 61;
 if (j === 1)
 chunk[i2++] = 61;
 }
 if (parts) {
 if (i2)
 parts.push(String.fromCharCode.apply(String, chunk.slice(0, i2)));
 return parts.join("");
 }
 return String.fromCharCode.apply(String, chunk.slice(0, i2));
 };
 var invalidEncoding = "invalid encoding";
 base64.decode = function decode(string, buffer, offset) {
 var start = offset;
 var j = 0, t;
 for (var i2 = 0; i2 < string.length; ) {
 var c = string.charCodeAt(i2++);
 if (c === 61 && j > 1)
 break;
 if ((c = s64[c]) === void 0)
 throw Error(invalidEncoding);
 switch (j) {
 case 0:
 t = c;
 j = 1;
 break;
 case 1:
 buffer[offset++] = t << 2 | (c & 48) >> 4;
 t = c;
 j = 2;
 break;
 case 2:
 buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
 t = c;
 j = 3;
 break;
 case 3:
 buffer[offset++] = (t & 3) << 6 | c;
 j = 0;
 break;
 }
 }
 if (j === 1)
 throw Error(invalidEncoding);
 return offset - start;
 };
 base64.test = function test(string) {
 return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
 };
 }
});

// web/node_modules/@protobufjs/eventemitter/index.js
var require_eventemitter = __commonJS({
 "web/node_modules/@protobufjs/eventemitter/index.js"(exports2, module2) {
 "use strict";
 module2.exports = EventEmitter;
 function EventEmitter() {
 this._listeners = {};
 }
 EventEmitter.prototype.on = function on(evt, fn, ctx) {
 (this._listeners[evt] || (this._listeners[evt] = [])).push({
 fn,
 ctx: ctx || this
 });
 return this;
 };
 EventEmitter.prototype.off = function off(evt, fn) {
 if (evt === void 0)
 this._listeners = {};
 else {
 if (fn === void 0)
 this._listeners[evt] = [];
 else {
 var listeners = this._listeners[evt];
 for (var i = 0; i < listeners.length; )
 if (listeners[i].fn === fn)
 listeners.splice(i, 1);
 else
 ++i;
 }
 }
 return this;
 };
 EventEmitter.prototype.emit = function emit(evt) {
 var listeners = this._listeners[evt];
 if (listeners) {
 var args = [], i = 1;
 for (; i < arguments.length; )
 args.push(arguments[i++]);
 for (i = 0; i < listeners.length; )
 listeners[i].fn.apply(listeners[i++].ctx, args);
 }
 return this;
 };
 }
});

// web/node_modules/@protobufjs/float/index.js
var require_float = __commonJS({
 "web/node_modules/@protobufjs/float/index.js"(exports2, module2) {
 "use strict";
 module2.exports = factory(factory);
 function factory(exports3) {
 if (typeof Float32Array !== "undefined")
 (function() {
 var f32 = new Float32Array([-0]), f8b = new Uint8Array(f32.buffer), le = f8b[3] === 128;
 function writeFloat_f32_cpy(val, buf, pos) {
 f32[0] = val;
 buf[pos] = f8b[0];
 buf[pos + 1] = f8b[1];
 buf[pos + 2] = f8b[2];
 buf[pos + 3] = f8b[3];
 }
 function writeFloat_f32_rev(val, buf, pos) {
 f32[0] = val;
 buf[pos] = f8b[3];
 buf[pos + 1] = f8b[2];
 buf[pos + 2] = f8b[1];
 buf[pos + 3] = f8b[0];
 }
 exports3.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
 exports3.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
 function readFloat_f32_cpy(buf, pos) {
 f8b[0] = buf[pos];
 f8b[1] = buf[pos + 1];
 f8b[2] = buf[pos + 2];
 f8b[3] = buf[pos + 3];
 return f32[0];
 }
 function readFloat_f32_rev(buf, pos) {
 f8b[3] = buf[pos];
 f8b[2] = buf[pos + 1];
 f8b[1] = buf[pos + 2];
 f8b[0] = buf[pos + 3];
 return f32[0];
 }
 exports3.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
 exports3.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
 })();
 else
 (function() {
 function writeFloat_ieee754(writeUint, val, buf, pos) {
 var sign = val < 0 ? 1 : 0;
 if (sign)
 val = -val;
 if (val === 0)
 writeUint(1 / val > 0 ? (
 /* positive */
 0
 ) : (
 /* negative 0 */
 2147483648
 ), buf, pos);
 else if (isNaN(val))
 writeUint(2143289344, buf, pos);
 else if (val > 34028234663852886e22)
 writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
 else if (val < 11754943508222875e-54)
 writeUint((sign << 31 | Math.round(val / 1401298464324817e-60)) >>> 0, buf, pos);
 else {
 var exponent = Math.floor(Math.log(val) / Math.LN2), mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
 writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
 }
 }
 exports3.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
 exports3.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
 function readFloat_ieee754(readUint, buf, pos) {
 var uint = readUint(buf, pos), sign = (uint >> 31) * 2 + 1, exponent = uint >>> 23 & 255, mantissa = uint & 8388607;
 return exponent === 255 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 1401298464324817e-60 * mantissa : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
 }
 exports3.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
 exports3.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
 })();
 if (typeof Float64Array !== "undefined")
 (function() {
 var f64 = new Float64Array([-0]), f8b = new Uint8Array(f64.buffer), le = f8b[7] === 128;
 function writeDouble_f64_cpy(val, buf, pos) {
 f64[0] = val;
 buf[pos] = f8b[0];
 buf[pos + 1] = f8b[1];
 buf[pos + 2] = f8b[2];
 buf[pos + 3] = f8b[3];
 buf[pos + 4] = f8b[4];
 buf[pos + 5] = f8b[5];
 buf[pos + 6] = f8b[6];
 buf[pos + 7] = f8b[7];
 }
 function writeDouble_f64_rev(val, buf, pos) {
 f64[0] = val;
 buf[pos] = f8b[7];
 buf[pos + 1] = f8b[6];
 buf[pos + 2] = f8b[5];
 buf[pos + 3] = f8b[4];
 buf[pos + 4] = f8b[3];
 buf[pos + 5] = f8b[2];
 buf[pos + 6] = f8b[1];
 buf[pos + 7] = f8b[0];
 }
 exports3.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
 exports3.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
 function readDouble_f64_cpy(buf, pos) {
 f8b[0] = buf[pos];
 f8b[1] = buf[pos + 1];
 f8b[2] = buf[pos + 2];
 f8b[3] = buf[pos + 3];
 f8b[4] = buf[pos + 4];
 f8b[5] = buf[pos + 5];
 f8b[6] = buf[pos + 6];
 f8b[7] = buf[pos + 7];
 return f64[0];
 }
 function readDouble_f64_rev(buf, pos) {
 f8b[7] = buf[pos];
 f8b[6] = buf[pos + 1];
 f8b[5] = buf[pos + 2];
 f8b[4] = buf[pos + 3];
 f8b[3] = buf[pos + 4];
 f8b[2] = buf[pos + 5];
 f8b[1] = buf[pos + 6];
 f8b[0] = buf[pos + 7];
 return f64[0];
 }
 exports3.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
 exports3.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
 })();
 else
 (function() {
 function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
 var sign = val < 0 ? 1 : 0;
 if (sign)
 val = -val;
 if (val === 0) {
 writeUint(0, buf, pos + off0);
 writeUint(1 / val > 0 ? (
 /* positive */
 0
 ) : (
 /* negative 0 */
 2147483648
 ), buf, pos + off1);
 } else if (isNaN(val)) {
 writeUint(0, buf, pos + off0);
 writeUint(2146959360, buf, pos + off1);
 } else if (val > 17976931348623157e292) {
 writeUint(0, buf, pos + off0);
 writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
 } else {
 var mantissa;
 if (val < 22250738585072014e-324) {
 mantissa = val / 5e-324;
 writeUint(mantissa >>> 0, buf, pos + off0);
 writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
 } else {
 var exponent = Math.floor(Math.log(val) / Math.LN2);
 if (exponent === 1024)
 exponent = 1023;
 mantissa = val * Math.pow(2, -exponent);
 writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
 writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
 }
 }
 }
 exports3.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
 exports3.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
 function readDouble_ieee754(readUint, off0, off1, buf, pos) {
 var lo = readUint(buf, pos + off0), hi = readUint(buf, pos + off1);
 var sign = (hi >> 31) * 2 + 1, exponent = hi >>> 20 & 2047, mantissa = 4294967296 * (hi & 1048575) + lo;
 return exponent === 2047 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 5e-324 * mantissa : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
 }
 exports3.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
 exports3.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
 })();
 return exports3;
 }
 function writeUintLE(val, buf, pos) {
 buf[pos] = val & 255;
 buf[pos + 1] = val >>> 8 & 255;
 buf[pos + 2] = val >>> 16 & 255;
 buf[pos + 3] = val >>> 24;
 }
 function writeUintBE(val, buf, pos) {
 buf[pos] = val >>> 24;
 buf[pos + 1] = val >>> 16 & 255;
 buf[pos + 2] = val >>> 8 & 255;
 buf[pos + 3] = val & 255;
 }
 function readUintLE(buf, pos) {
 return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16 | buf[pos + 3] << 24) >>> 0;
 }
 function readUintBE(buf, pos) {
 return (buf[pos] << 24 | buf[pos + 1] << 16 | buf[pos + 2] << 8 | buf[pos + 3]) >>> 0;
 }
 }
});

// web/node_modules/@protobufjs/inquire/index.js
var require_inquire = __commonJS({
 "web/node_modules/@protobufjs/inquire/index.js"(exports, module) {
 "use strict";
 module.exports = inquire;
 function inquire(moduleName) {
 try {
 var mod = eval("quire".replace(/^/, "re"))(moduleName);
 if (mod && (mod.length || Object.keys(mod).length))
 return mod;
 } catch (e) {
 }
 return null;
 }
 }
});

// web/node_modules/@protobufjs/utf8/index.js
var require_utf8 = __commonJS({
 "web/node_modules/@protobufjs/utf8/index.js"(exports2) {
 "use strict";
 var utf8 = exports2;
 utf8.length = function utf8_length(string) {
 var len = 0, c = 0;
 for (var i = 0; i < string.length; ++i) {
 c = string.charCodeAt(i);
 if (c < 128)
 len += 1;
 else if (c < 2048)
 len += 2;
 else if ((c & 64512) === 55296 && (string.charCodeAt(i + 1) & 64512) === 56320) {
 ++i;
 len += 4;
 } else
 len += 3;
 }
 return len;
 };
 utf8.read = function utf8_read(buffer, start, end) {
 var len = end - start;
 if (len < 1)
 return "";
 var parts = null, chunk = [], i = 0, t;
 while (start < end) {
 t = buffer[start++];
 if (t < 128)
 chunk[i++] = t;
 else if (t > 191 && t < 224)
 chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
 else if (t > 239 && t < 365) {
 t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 65536;
 chunk[i++] = 55296 + (t >> 10);
 chunk[i++] = 56320 + (t & 1023);
 } else
 chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
 if (i > 8191) {
 (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
 i = 0;
 }
 }
 if (parts) {
 if (i)
 parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
 return parts.join("");
 }
 return String.fromCharCode.apply(String, chunk.slice(0, i));
 };
 utf8.write = function utf8_write(string, buffer, offset) {
 var start = offset, c1, c2;
 for (var i = 0; i < string.length; ++i) {
 c1 = string.charCodeAt(i);
 if (c1 < 128) {
 buffer[offset++] = c1;
 } else if (c1 < 2048) {
 buffer[offset++] = c1 >> 6 | 192;
 buffer[offset++] = c1 & 63 | 128;
 } else if ((c1 & 64512) === 55296 && ((c2 = string.charCodeAt(i + 1)) & 64512) === 56320) {
 c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
 ++i;
 buffer[offset++] = c1 >> 18 | 240;
 buffer[offset++] = c1 >> 12 & 63 | 128;
 buffer[offset++] = c1 >> 6 & 63 | 128;
 buffer[offset++] = c1 & 63 | 128;
 } else {
 buffer[offset++] = c1 >> 12 | 224;
 buffer[offset++] = c1 >> 6 & 63 | 128;
 buffer[offset++] = c1 & 63 | 128;
 }
 }
 return offset - start;
 };
 }
});

// web/node_modules/@protobufjs/pool/index.js
var require_pool = __commonJS({
 "web/node_modules/@protobufjs/pool/index.js"(exports2, module2) {
 "use strict";
 module2.exports = pool;
 function pool(alloc, slice2, size) {
 var SIZE = size || 8192;
 var MAX = SIZE >>> 1;
 var slab = null;
 var offset = SIZE;
 return function pool_alloc(size2) {
 if (size2 < 1 || size2 > MAX)
 return alloc(size2);
 if (offset + size2 > SIZE) {
 slab = alloc(SIZE);
 offset = 0;
 }
 var buf = slice2.call(slab, offset, offset += size2);
 if (offset & 7)
 offset = (offset | 7) + 1;
 return buf;
 };
 }
 }
});

// web/node_modules/protobufjs/src/util/longbits.js
var require_longbits = __commonJS({
 "web/node_modules/protobufjs/src/util/longbits.js"(exports2, module2) {
 "use strict";
 module2.exports = LongBits;
 var util = require_minimal();
 function LongBits(lo, hi) {
 this.lo = lo >>> 0;
 this.hi = hi >>> 0;
 }
 var zero = LongBits.zero = new LongBits(0, 0);
 zero.toNumber = function() {
 return 0;
 };
 zero.zzEncode = zero.zzDecode = function() {
 return this;
 };
 zero.length = function() {
 return 1;
 };
 var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0";
 LongBits.fromNumber = function fromNumber2(value) {
 if (value === 0)
 return zero;
 var sign = value < 0;
 if (sign)
 value = -value;
 var lo = value >>> 0, hi = (value - lo) / 4294967296 >>> 0;
 if (sign) {
 hi = ~hi >>> 0;
 lo = ~lo >>> 0;
 if (++lo > 4294967295) {
 lo = 0;
 if (++hi > 4294967295)
 hi = 0;
 }
 }
 return new LongBits(lo, hi);
 };
 LongBits.from = function from(value) {
 if (typeof value === "number")
 return LongBits.fromNumber(value);
 if (util.isString(value)) {
 if (util.Long)
 value = util.Long.fromString(value);
 else
 return LongBits.fromNumber(parseInt(value, 10));
 }
 return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
 };
 LongBits.prototype.toNumber = function toNumber2(unsigned) {
 if (!unsigned && this.hi >>> 31) {
 var lo = ~this.lo + 1 >>> 0, hi = ~this.hi >>> 0;
 if (!lo)
 hi = hi + 1 >>> 0;
 return -(lo + hi * 4294967296);
 }
 return this.lo + this.hi * 4294967296;
 };
 LongBits.prototype.toLong = function toLong(unsigned) {
 return util.Long ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned)) : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };
 };
 var charCodeAt = String.prototype.charCodeAt;
 LongBits.fromHash = function fromHash(hash) {
 if (hash === zeroHash)
 return zero;
 return new LongBits(
 (charCodeAt.call(hash, 0) | charCodeAt.call(hash, 1) << 8 | charCodeAt.call(hash, 2) << 16 | charCodeAt.call(hash, 3) << 24) >>> 0,
 (charCodeAt.call(hash, 4) | charCodeAt.call(hash, 5) << 8 | charCodeAt.call(hash, 6) << 16 | charCodeAt.call(hash, 7) << 24) >>> 0
 );
 };
 LongBits.prototype.toHash = function toHash() {
 return String.fromCharCode(
 this.lo & 255,
 this.lo >>> 8 & 255,
 this.lo >>> 16 & 255,
 this.lo >>> 24,
 this.hi & 255,
 this.hi >>> 8 & 255,
 this.hi >>> 16 & 255,
 this.hi >>> 24
 );
 };
 LongBits.prototype.zzEncode = function zzEncode() {
 var mask = this.hi >> 31;
 this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
 this.lo = (this.lo << 1 ^ mask) >>> 0;
 return this;
 };
 LongBits.prototype.zzDecode = function zzDecode() {
 var mask = -(this.lo & 1);
 this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
 this.hi = (this.hi >>> 1 ^ mask) >>> 0;
 return this;
 };
 LongBits.prototype.length = function length() {
 var part0 = this.lo, part1 = (this.lo >>> 28 | this.hi << 4) >>> 0, part2 = this.hi >>> 24;
 return part2 === 0 ? part1 === 0 ? part0 < 16384 ? part0 < 128 ? 1 : 2 : part0 < 2097152 ? 3 : 4 : part1 < 16384 ? part1 < 128 ? 5 : 6 : part1 < 2097152 ? 7 : 8 : part2 < 128 ? 9 : 10;
 };
 }
});

// web/node_modules/protobufjs/src/util/minimal.js
var require_minimal = __commonJS({
 "web/node_modules/protobufjs/src/util/minimal.js"(exports2) {
 "use strict";
 var util = exports2;
 util.asPromise = require_aspromise();
 util.base64 = require_base64();
 util.EventEmitter = require_eventemitter();
 util.float = require_float();
 util.inquire = require_inquire();
 util.utf8 = require_utf8();
 util.pool = require_pool();
 util.LongBits = require_longbits();
 util.isNode = Boolean(typeof global !== "undefined" && global && global.process && global.process.versions && global.process.versions.node);
 util.global = util.isNode && global || typeof window !== "undefined" && window || typeof self !== "undefined" && self || exports2;
 util.emptyArray = Object.freeze ? Object.freeze([]) : (
 /* istanbul ignore next */
 []
 );
 util.emptyObject = Object.freeze ? Object.freeze({}) : (
 /* istanbul ignore next */
 {}
 );
 util.isInteger = Number.isInteger || /* istanbul ignore next */
 function isInteger(value) {
 return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
 };
 util.isString = function isString(value) {
 return typeof value === "string" || value instanceof String;
 };
 util.isObject = function isObject(value) {
 return value && typeof value === "object";
 };
 util.isset = /**
 * Checks if a property on a message is considered to be present.
 * @param {Object} obj Plain object or message instance
 * @param {string} prop Property name
 * @returns {boolean} `true` if considered to be present, otherwise `false`
 */
 util.isSet = function isSet(obj, prop) {
 var value = obj[prop];
 if (value != null && obj.hasOwnProperty(prop))
 return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
 return false;
 };
 util.Buffer = function() {
 try {
 var Buffer2 = util.inquire("buffer").Buffer;
 return Buffer2.prototype.utf8Write ? Buffer2 : (
 /* istanbul ignore next */
 null
 );
 } catch (e) {
 return null;
 }
 }();
 util._Buffer_from = null;
 util._Buffer_allocUnsafe = null;
 util.newBuffer = function newBuffer(sizeOrArray) {
 return typeof sizeOrArray === "number" ? util.Buffer ? util._Buffer_allocUnsafe(sizeOrArray) : new util.Array(sizeOrArray) : util.Buffer ? util._Buffer_from(sizeOrArray) : typeof Uint8Array === "undefined" ? sizeOrArray : new Uint8Array(sizeOrArray);
 };
 util.Array = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
 util.Long = /* istanbul ignore next */
 util.global.dcodeIO && /* istanbul ignore next */
 util.global.dcodeIO.Long || /* istanbul ignore next */
 util.global.Long || util.inquire("long");
 util.key2Re = /^true|false|0|1$/;
 util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
 util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
 util.longToHash = function longToHash(value) {
 return value ? util.LongBits.from(value).toHash() : util.LongBits.zeroHash;
 };
 util.longFromHash = function longFromHash(hash, unsigned) {
 var bits = util.LongBits.fromHash(hash);
 if (util.Long)
 return util.Long.fromBits(bits.lo, bits.hi, unsigned);
 return bits.toNumber(Boolean(unsigned));
 };
 function merge(dst, src, ifNotSet) {
 for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)
 if (dst[keys[i]] === void 0 || !ifNotSet)
 dst[keys[i]] = src[keys[i]];
 return dst;
 }
 util.merge = merge;
 util.lcFirst = function lcFirst(str) {
 return str.charAt(0).toLowerCase() + str.substring(1);
 };
 function newError(name2) {
 function CustomError(message, properties) {
 if (!(this instanceof CustomError))
 return new CustomError(message, properties);
 Object.defineProperty(this, "message", { get: function() {
 return message;
 } });
 if (Error.captureStackTrace)
 Error.captureStackTrace(this, CustomError);
 else
 Object.defineProperty(this, "stack", { value: new Error().stack || "" });
 if (properties)
 merge(this, properties);
 }
 CustomError.prototype = Object.create(Error.prototype, {
 constructor: {
 value: CustomError,
 writable: true,
 enumerable: false,
 configurable: true
 },
 name: {
 get: function get() {
 return name2;
 },
 set: void 0,
 enumerable: false,
 // configurable: false would accurately preserve the behavior of
 // the original, but I'm guessing that was not intentional.
 // For an actual error subclass, this property would
 // be configurable.
 configurable: true
 },
 toString: {
 value: function value() {
 return this.name + ": " + this.message;
 },
 writable: true,
 enumerable: false,
 configurable: true
 }
 });
 return CustomError;
 }
 util.newError = newError;
 util.ProtocolError = newError("ProtocolError");
 util.oneOfGetter = function getOneOf(fieldNames) {
 var fieldMap = {};
 for (var i = 0; i < fieldNames.length; ++i)
 fieldMap[fieldNames[i]] = 1;
 return function() {
 for (var keys = Object.keys(this), i2 = keys.length - 1; i2 > -1; --i2)
 if (fieldMap[keys[i2]] === 1 && this[keys[i2]] !== void 0 && this[keys[i2]] !== null)
 return keys[i2];
 };
 };
 util.oneOfSetter = function setOneOf(fieldNames) {
 return function(name2) {
 for (var i = 0; i < fieldNames.length; ++i)
 if (fieldNames[i] !== name2)
 delete this[fieldNames[i]];
 };
 };
 util.toJSONOptions = {
 longs: String,
 enums: String,
 bytes: String,
 json: true
 };
 util._configure = function() {
 var Buffer2 = util.Buffer;
 if (!Buffer2) {
 util._Buffer_from = util._Buffer_allocUnsafe = null;
 return;
 }
 util._Buffer_from = Buffer2.from !== Uint8Array.from && Buffer2.from || /* istanbul ignore next */
 function Buffer_from(value, encoding) {
 return new Buffer2(value, encoding);
 };
 util._Buffer_allocUnsafe = Buffer2.allocUnsafe || /* istanbul ignore next */
 function Buffer_allocUnsafe(size) {
 return new Buffer2(size);
 };
 };
 }
});

// web/node_modules/protobufjs/src/writer.js
var require_writer = __commonJS({
 "web/node_modules/protobufjs/src/writer.js"(exports2, module2) {
 "use strict";
 module2.exports = Writer;
 var util = require_minimal();
 var BufferWriter;
 var LongBits = util.LongBits;
 var base64 = util.base64;
 var utf8 = util.utf8;
 function Op(fn, len, val) {
 this.fn = fn;
 this.len = len;
 this.next = void 0;
 this.val = val;
 }
 function noop() {
 }
 function State(writer) {
 this.head = writer.head;
 this.tail = writer.tail;
 this.len = writer.len;
 this.next = writer.states;
 }
 function Writer() {
 this.len = 0;
 this.head = new Op(noop, 0, 0);
 this.tail = this.head;
 this.states = null;
 }
 var create = function create2() {
 return util.Buffer ? function create_buffer_setup() {
 return (Writer.create = function create_buffer() {
 return new BufferWriter();
 })();
 } : function create_array() {
 return new Writer();
 };
 };
 Writer.create = create();
 Writer.alloc = function alloc(size) {
 return new util.Array(size);
 };
 if (util.Array !== Array)
 Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);
 Writer.prototype._push = function push(fn, len, val) {
 this.tail = this.tail.next = new Op(fn, len, val);
 this.len += len;
 return this;
 };
 function writeByte(val, buf, pos) {
 buf[pos] = val & 255;
 }
 function writeVarint32(val, buf, pos) {
 while (val > 127) {
 buf[pos++] = val & 127 | 128;
 val >>>= 7;
 }
 buf[pos] = val;
 }
 function VarintOp(len, val) {
 this.len = len;
 this.next = void 0;
 this.val = val;
 }
 VarintOp.prototype = Object.create(Op.prototype);
 VarintOp.prototype.fn = writeVarint32;
 Writer.prototype.uint32 = function write_uint32(value) {
 this.len += (this.tail = this.tail.next = new VarintOp(
 (value = value >>> 0) < 128 ? 1 : value < 16384 ? 2 : value < 2097152 ? 3 : value < 268435456 ? 4 : 5,
 value
 )).len;
 return this;
 };
 Writer.prototype.int32 = function write_int32(value) {
 return value < 0 ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) : this.uint32(value);
 };
 Writer.prototype.sint32 = function write_sint32(value) {
 return this.uint32((value << 1 ^ value >> 31) >>> 0);
 };
 function writeVarint64(val, buf, pos) {
 while (val.hi) {
 buf[pos++] = val.lo & 127 | 128;
 val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
 val.hi >>>= 7;
 }
 while (val.lo > 127) {
 buf[pos++] = val.lo & 127 | 128;
 val.lo = val.lo >>> 7;
 }
 buf[pos++] = val.lo;
 }
 Writer.prototype.uint64 = function write_uint64(value) {
 var bits = LongBits.from(value);
 return this._push(writeVarint64, bits.length(), bits);
 };
 Writer.prototype.int64 = Writer.prototype.uint64;
 Writer.prototype.sint64 = function write_sint64(value) {
 var bits = LongBits.from(value).zzEncode();
 return this._push(writeVarint64, bits.length(), bits);
 };
 Writer.prototype.bool = function write_bool(value) {
 return this._push(writeByte, 1, value ? 1 : 0);
 };
 function writeFixed32(val, buf, pos) {
 buf[pos] = val & 255;
 buf[pos + 1] = val >>> 8 & 255;
 buf[pos + 2] = val >>> 16 & 255;
 buf[pos + 3] = val >>> 24;
 }
 Writer.prototype.fixed32 = function write_fixed32(value) {
 return this._push(writeFixed32, 4, value >>> 0);
 };
 Writer.prototype.sfixed32 = Writer.prototype.fixed32;
 Writer.prototype.fixed64 = function write_fixed64(value) {
 var bits = LongBits.from(value);
 return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
 };
 Writer.prototype.sfixed64 = Writer.prototype.fixed64;
 Writer.prototype.float = function write_float(value) {
 return this._push(util.float.writeFloatLE, 4, value);
 };
 Writer.prototype.double = function write_double(value) {
 return this._push(util.float.writeDoubleLE, 8, value);
 };
 var writeBytes = util.Array.prototype.set ? function writeBytes_set(val, buf, pos) {
 buf.set(val, pos);
 } : function writeBytes_for(val, buf, pos) {
 for (var i = 0; i < val.length; ++i)
 buf[pos + i] = val[i];
 };
 Writer.prototype.bytes = function write_bytes(value) {
 var len = value.length >>> 0;
 if (!len)
 return this._push(writeByte, 1, 0);
 if (util.isString(value)) {
 var buf = Writer.alloc(len = base64.length(value));
 base64.decode(value, buf, 0);
 value = buf;
 }
 return this.uint32(len)._push(writeBytes, len, value);
 };
 Writer.prototype.string = function write_string(value) {
 var len = utf8.length(value);
 return len ? this.uint32(len)._push(utf8.write, len, value) : this._push(writeByte, 1, 0);
 };
 Writer.prototype.fork = function fork() {
 this.states = new State(this);
 this.head = this.tail = new Op(noop, 0, 0);
 this.len = 0;
 return this;
 };
 Writer.prototype.reset = function reset() {
 if (this.states) {
 this.head = this.states.head;
 this.tail = this.states.tail;
 this.len = this.states.len;
 this.states = this.states.next;
 } else {
 this.head = this.tail = new Op(noop, 0, 0);
 this.len = 0;
 }
 return this;
 };
 Writer.prototype.ldelim = function ldelim() {
 var head = this.head, tail = this.tail, len = this.len;
 this.reset().uint32(len);
 if (len) {
 this.tail.next = head.next;
 this.tail = tail;
 this.len += len;
 }
 return this;
 };
 Writer.prototype.finish = function finish() {
 var head = this.head.next, buf = this.constructor.alloc(this.len), pos = 0;
 while (head) {
 head.fn(head.val, buf, pos);
 pos += head.len;
 head = head.next;
 }
 return buf;
 };
 Writer._configure = function(BufferWriter_) {
 BufferWriter = BufferWriter_;
 Writer.create = create();
 BufferWriter._configure();
 };
 }
});

// web/node_modules/protobufjs/src/writer_buffer.js
var require_writer_buffer = __commonJS({
 "web/node_modules/protobufjs/src/writer_buffer.js"(exports2, module2) {
 "use strict";
 module2.exports = BufferWriter;
 var Writer = require_writer();
 (BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
 var util = require_minimal();
 function BufferWriter() {
 Writer.call(this);
 }
 BufferWriter._configure = function() {
 BufferWriter.alloc = util._Buffer_allocUnsafe;
 BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === "set" ? function writeBytesBuffer_set(val, buf, pos) {
 buf.set(val, pos);
 } : function writeBytesBuffer_copy(val, buf, pos) {
 if (val.copy)
 val.copy(buf, pos, 0, val.length);
 else
 for (var i = 0; i < val.length; )
 buf[pos++] = val[i++];
 };
 };
 BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
 if (util.isString(value))
 value = util._Buffer_from(value, "base64");
 var len = value.length >>> 0;
 this.uint32(len);
 if (len)
 this._push(BufferWriter.writeBytesBuffer, len, value);
 return this;
 };
 function writeStringBuffer(val, buf, pos) {
 if (val.length < 40)
 util.utf8.write(val, buf, pos);
 else if (buf.utf8Write)
 buf.utf8Write(val, pos);
 else
 buf.write(val, pos);
 }
 BufferWriter.prototype.string = function write_string_buffer(value) {
 var len = util.Buffer.byteLength(value);
 this.uint32(len);
 if (len)
 this._push(writeStringBuffer, len, value);
 return this;
 };
 BufferWriter._configure();
 }
});

// web/node_modules/protobufjs/src/reader.js
var require_reader = __commonJS({
 "web/node_modules/protobufjs/src/reader.js"(exports2, module2) {
 "use strict";
 module2.exports = Reader;
 var util = require_minimal();
 var BufferReader;
 var LongBits = util.LongBits;
 var utf8 = util.utf8;
 function indexOutOfRange(reader, writeLength) {
 return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
 }
 function Reader(buffer) {
 this.buf = buffer;
 this.pos = 0;
 this.len = buffer.length;
 }
 var create_array = typeof Uint8Array !== "undefined" ? function create_typed_array(buffer) {
 if (buffer instanceof Uint8Array || Array.isArray(buffer))
 return new Reader(buffer);
 throw Error("illegal buffer");
 } : function create_array2(buffer) {
 if (Array.isArray(buffer))
 return new Reader(buffer);
 throw Error("illegal buffer");
 };
 var create = function create2() {
 return util.Buffer ? function create_buffer_setup(buffer) {
 return (Reader.create = function create_buffer(buffer2) {
 return util.Buffer.isBuffer(buffer2) ? new BufferReader(buffer2) : create_array(buffer2);
 })(buffer);
 } : create_array;
 };
 Reader.create = create();
 Reader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */
 util.Array.prototype.slice;
 Reader.prototype.uint32 = function read_uint32_setup() {
 var value = 4294967295;
 return function read_uint32() {
 value = (this.buf[this.pos] & 127) >>> 0;
 if (this.buf[this.pos++] < 128)
 return value;
 value = (value | (this.buf[this.pos] & 127) << 7) >>> 0;
 if (this.buf[this.pos++] < 128)
 return value;
 value = (value | (this.buf[this.pos] & 127) << 14) >>> 0;
 if (this.buf[this.pos++] < 128)
 return value;
 value = (value | (this.buf[this.pos] & 127) << 21) >>> 0;
 if (this.buf[this.pos++] < 128)
 return value;
 value = (value | (this.buf[this.pos] & 15) << 28) >>> 0;
 if (this.buf[this.pos++] < 128)
 return value;
 if ((this.pos += 5) > this.len) {
 this.pos = this.len;
 throw indexOutOfRange(this, 10);
 }
 return value;
 };
 }();
 Reader.prototype.int32 = function read_int32() {
 return this.uint32() | 0;
 };
 Reader.prototype.sint32 = function read_sint32() {
 var value = this.uint32();
 return value >>> 1 ^ -(value & 1) | 0;
 };
 function readLongVarint() {
 var bits = new LongBits(0, 0);
 var i = 0;
 if (this.len - this.pos > 4) {
 for (; i < 4; ++i) {
 bits.lo = (bits.lo | (this.buf[this.pos] & 127) <>> 0;
 if (this.buf[this.pos++] < 128)
 return bits;
 }
 bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
 bits.hi = (bits.hi | (this.buf[this.pos] & 127) >> 4) >>> 0;
 if (this.buf[this.pos++] < 128)
 return bits;
 i = 0;
 } else {
 for (; i < 3; ++i) {
 if (this.pos >= this.len)
 throw indexOutOfRange(this);
 bits.lo = (bits.lo | (this.buf[this.pos] & 127) <>> 0;
 if (this.buf[this.pos++] < 128)
 return bits;
 }
 bits.lo = (bits.lo | (this.buf[this.pos++] & 127) <>> 0;
 return bits;
 }
 if (this.len - this.pos > 4) {
 for (; i < 5; ++i) {
 bits.hi = (bits.hi | (this.buf[this.pos] & 127) <>> 0;
 if (this.buf[this.pos++] < 128)
 return bits;
 }
 } else {
 for (; i < 5; ++i) {
 if (this.pos >= this.len)
 throw indexOutOfRange(this);
 bits.hi = (bits.hi | (this.buf[this.pos] & 127) <>> 0;
 if (this.buf[this.pos++] < 128)
 return bits;
 }
 }
 throw Error("invalid varint encoding");
 }
 Reader.prototype.bool = function read_bool() {
 return this.uint32() !== 0;
 };
 function readFixed32_end(buf, end) {
 return (buf[end - 4] | buf[end - 3] << 8 | buf[end - 2] << 16 | buf[end - 1] << 24) >>> 0;
 }
 Reader.prototype.fixed32 = function read_fixed32() {
 if (this.pos + 4 > this.len)
 throw indexOutOfRange(this, 4);
 return readFixed32_end(this.buf, this.pos += 4);
 };
 Reader.prototype.sfixed32 = function read_sfixed32() {
 if (this.pos + 4 > this.len)
 throw indexOutOfRange(this, 4);
 return readFixed32_end(this.buf, this.pos += 4) | 0;
 };
 function readFixed64() {
 if (this.pos + 8 > this.len)
 throw indexOutOfRange(this, 8);
 return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));
 }
 Reader.prototype.float = function read_float() {
 if (this.pos + 4 > this.len)
 throw indexOutOfRange(this, 4);
 var value = util.float.readFloatLE(this.buf, this.pos);
 this.pos += 4;
 return value;
 };
 Reader.prototype.double = function read_double() {
 if (this.pos + 8 > this.len)
 throw indexOutOfRange(this, 4);
 var value = util.float.readDoubleLE(this.buf, this.pos);
 this.pos += 8;
 return value;
 };
 Reader.prototype.bytes = function read_bytes() {
 var length = this.uint32(), start = this.pos, end = this.pos + length;
 if (end > this.len)
 throw indexOutOfRange(this, length);
 this.pos += length;
 if (Array.isArray(this.buf))
 return this.buf.slice(start, end);
 if (start === end) {
 var nativeBuffer = util.Buffer;
 return nativeBuffer ? nativeBuffer.alloc(0) : new this.buf.constructor(0);
 }
 return this._slice.call(this.buf, start, end);
 };
 Reader.prototype.string = function read_string() {
 var bytes = this.bytes();
 return utf8.read(bytes, 0, bytes.length);
 };
 Reader.prototype.skip = function skip(length) {
 if (typeof length === "number") {
 if (this.pos + length > this.len)
 throw indexOutOfRange(this, length);
 this.pos += length;
 } else {
 do {
 if (this.pos >= this.len)
 throw indexOutOfRange(this);
 } while (this.buf[this.pos++] & 128);
 }
 return this;
 };
 Reader.prototype.skipType = function(wireType) {
 switch (wireType) {
 case 0:
 this.skip();
 break;
 case 1:
 this.skip(8);
 break;
 case 2:
 this.skip(this.uint32());
 break;
 case 3:
 while ((wireType = this.uint32() & 7) !== 4) {
 this.skipType(wireType);
 }
 break;
 case 5:
 this.skip(4);
 break;
 default:
 throw Error("invalid wire type " + wireType + " at offset " + this.pos);
 }
 return this;
 };
 Reader._configure = function(BufferReader_) {
 BufferReader = BufferReader_;
 Reader.create = create();
 BufferReader._configure();
 var fn = util.Long ? "toLong" : (
 /* istanbul ignore next */
 "toNumber"
 );
 util.merge(Reader.prototype, {
 int64: function read_int64() {
 return readLongVarint.call(this)[fn](false);
 },
 uint64: function read_uint64() {
 return readLongVarint.call(this)[fn](true);
 },
 sint64: function read_sint64() {
 return readLongVarint.call(this).zzDecode()[fn](false);
 },
 fixed64: function read_fixed64() {
 return readFixed64.call(this)[fn](true);
 },
 sfixed64: function read_sfixed64() {
 return readFixed64.call(this)[fn](false);
 }
 });
 };
 }
});

// web/node_modules/protobufjs/src/reader_buffer.js
var require_reader_buffer = __commonJS({
 "web/node_modules/protobufjs/src/reader_buffer.js"(exports2, module2) {
 "use strict";
 module2.exports = BufferReader;
 var Reader = require_reader();
 (BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
 var util = require_minimal();
 function BufferReader(buffer) {
 Reader.call(this, buffer);
 }
 BufferReader._configure = function() {
 if (util.Buffer)
 BufferReader.prototype._slice = util.Buffer.prototype.slice;
 };
 BufferReader.prototype.string = function read_string_buffer() {
 var len = this.uint32();
 return this.buf.utf8Slice ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len)) : this.buf.toString("utf-8", this.pos, this.pos = Math.min(this.pos + len, this.len));
 };
 BufferReader._configure();
 }
});

// web/node_modules/protobufjs/src/rpc/service.js
var require_service = __commonJS({
 "web/node_modules/protobufjs/src/rpc/service.js"(exports2, module2) {
 "use strict";
 module2.exports = Service;
 var util = require_minimal();
 (Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
 function Service(rpcImpl, requestDelimited, responseDelimited) {
 if (typeof rpcImpl !== "function")
 throw TypeError("rpcImpl must be a function");
 util.EventEmitter.call(this);
 this.rpcImpl = rpcImpl;
 this.requestDelimited = Boolean(requestDelimited);
 this.responseDelimited = Boolean(responseDelimited);
 }
 Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {
 if (!request)
 throw TypeError("request must be specified");
 var self2 = this;
 if (!callback)
 return util.asPromise(rpcCall, self2, method, requestCtor, responseCtor, request);
 if (!self2.rpcImpl) {
 setTimeout(function() {
 callback(Error("already ended"));
 }, 0);
 return void 0;
 }
 try {
 return self2.rpcImpl(
 method,
 requestCtor[self2.requestDelimited ? "encodeDelimited" : "encode"](request).finish(),
 function rpcCallback(err, response) {
 if (err) {
 self2.emit("error", err, method);
 return callback(err);
 }
 if (response === null) {
 self2.end(
 /* endedByRPC */
 true
 );
 return void 0;
 }
 if (!(response instanceof responseCtor)) {
 try {
 response = responseCtor[self2.responseDelimited ? "decodeDelimited" : "decode"](response);
 } catch (err2) {
 self2.emit("error", err2, method);
 return callback(err2);
 }
 }
 self2.emit("data", response, method);
 return callback(null, response);
 }
 );
 } catch (err) {
 self2.emit("error", err, method);
 setTimeout(function() {
 callback(err);
 }, 0);
 return void 0;
 }
 };
 Service.prototype.end = function end(endedByRPC) {
 if (this.rpcImpl) {
 if (!endedByRPC)
 this.rpcImpl(null, null, null);
 this.rpcImpl = null;
 this.emit("end").off();
 }
 return this;
 };
 }
});

// web/node_modules/protobufjs/src/rpc.js
var require_rpc = __commonJS({
 "web/node_modules/protobufjs/src/rpc.js"(exports2) {
 "use strict";
 var rpc = exports2;
 rpc.Service = require_service();
 }
});

// web/node_modules/protobufjs/src/roots.js
var require_roots = __commonJS({
 "web/node_modules/protobufjs/src/roots.js"(exports2, module2) {
 "use strict";
 module2.exports = {};
 }
});

// web/node_modules/protobufjs/src/index-minimal.js
var require_index_minimal = __commonJS({
 "web/node_modules/protobufjs/src/index-minimal.js"(exports2) {
 "use strict";
 var protobuf = exports2;
 protobuf.build = "minimal";
 protobuf.Writer = require_writer();
 protobuf.BufferWriter = require_writer_buffer();
 protobuf.Reader = require_reader();
 protobuf.BufferReader = require_reader_buffer();
 protobuf.util = require_minimal();
 protobuf.rpc = require_rpc();
 protobuf.roots = require_roots();
 protobuf.configure = configure;
 function configure() {
 protobuf.util._configure();
 protobuf.Writer._configure(protobuf.BufferWriter);
 protobuf.Reader._configure(protobuf.BufferReader);
 }
 configure();
 }
});

// web/node_modules/protobufjs/minimal.js
var require_minimal2 = __commonJS({
 "web/node_modules/protobufjs/minimal.js"(exports2, module2) {
 "use strict";
 module2.exports = require_index_minimal();
 }
});

// web/lib/onnxjs/ort-schema/protobuf/onnx.js
var require_onnx = __commonJS({
 "web/lib/onnxjs/ort-schema/protobuf/onnx.js"(exports2, module2) {
 "use strict";
 var $protobuf = require_minimal2();
 var $Reader = $protobuf.Reader;
 var $Writer = $protobuf.Writer;
 var $util = $protobuf.util;
 var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});
 $root.onnx = function() {
 var onnx6 = {};
 onnx6.Version = function() {
 var valuesById = {}, values = Object.create(valuesById);
 values[valuesById[0] = "_START_VERSION"] = 0;
 values[valuesById[1] = "IR_VERSION_2017_10_10"] = 1;
 values[valuesById[2] = "IR_VERSION_2017_10_30"] = 2;
 values[valuesById[3] = "IR_VERSION_2017_11_3"] = 3;
 values[valuesById[4] = "IR_VERSION_2019_1_22"] = 4;
 values[valuesById[5] = "IR_VERSION_2019_3_18"] = 5;
 values[valuesById[6] = "IR_VERSION_2019_9_19"] = 6;
 values[valuesById[7] = "IR_VERSION_2020_5_8"] = 7;
 values[valuesById[8] = "IR_VERSION_2021_7_30"] = 8;
 values[valuesById[9] = "IR_VERSION"] = 9;
 return values;
 }();
 onnx6.AttributeProto = function() {
 function AttributeProto(properties) {
 this.floats = [];
 this.ints = [];
 this.strings = [];
 this.tensors = [];
 this.graphs = [];
 this.sparseTensors = [];
 this.typeProtos = [];
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 AttributeProto.prototype.name = "";
 AttributeProto.prototype.refAttrName = "";
 AttributeProto.prototype.docString = "";
 AttributeProto.prototype.type = 0;
 AttributeProto.prototype.f = 0;
 AttributeProto.prototype.i = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
 AttributeProto.prototype.s = $util.newBuffer([]);
 AttributeProto.prototype.t = null;
 AttributeProto.prototype.g = null;
 AttributeProto.prototype.sparseTensor = null;
 AttributeProto.prototype.tp = null;
 AttributeProto.prototype.floats = $util.emptyArray;
 AttributeProto.prototype.ints = $util.emptyArray;
 AttributeProto.prototype.strings = $util.emptyArray;
 AttributeProto.prototype.tensors = $util.emptyArray;
 AttributeProto.prototype.graphs = $util.emptyArray;
 AttributeProto.prototype.sparseTensors = $util.emptyArray;
 AttributeProto.prototype.typeProtos = $util.emptyArray;
 AttributeProto.create = function create(properties) {
 return new AttributeProto(properties);
 };
 AttributeProto.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.name != null && Object.hasOwnProperty.call(message, "name"))
 writer.uint32(
 /* id 1, wireType 2 =*/
 10
 ).string(message.name);
 if (message.f != null && Object.hasOwnProperty.call(message, "f"))
 writer.uint32(
 /* id 2, wireType 5 =*/
 21
 ).float(message.f);
 if (message.i != null && Object.hasOwnProperty.call(message, "i"))
 writer.uint32(
 /* id 3, wireType 0 =*/
 24
 ).int64(message.i);
 if (message.s != null && Object.hasOwnProperty.call(message, "s"))
 writer.uint32(
 /* id 4, wireType 2 =*/
 34
 ).bytes(message.s);
 if (message.t != null && Object.hasOwnProperty.call(message, "t"))
 $root.onnx.TensorProto.encode(message.t, writer.uint32(
 /* id 5, wireType 2 =*/
 42
 ).fork()).ldelim();
 if (message.g != null && Object.hasOwnProperty.call(message, "g"))
 $root.onnx.GraphProto.encode(message.g, writer.uint32(
 /* id 6, wireType 2 =*/
 50
 ).fork()).ldelim();
 if (message.floats != null && message.floats.length) {
 writer.uint32(
 /* id 7, wireType 2 =*/
 58
 ).fork();
 for (var i = 0; i < message.floats.length; ++i)
 writer.float(message.floats[i]);
 writer.ldelim();
 }
 if (message.ints != null && message.ints.length) {
 writer.uint32(
 /* id 8, wireType 2 =*/
 66
 ).fork();
 for (var i = 0; i < message.ints.length; ++i)
 writer.int64(message.ints[i]);
 writer.ldelim();
 }
 if (message.strings != null && message.strings.length)
 for (var i = 0; i < message.strings.length; ++i)
 writer.uint32(
 /* id 9, wireType 2 =*/
 74
 ).bytes(message.strings[i]);
 if (message.tensors != null && message.tensors.length)
 for (var i = 0; i < message.tensors.length; ++i)
 $root.onnx.TensorProto.encode(message.tensors[i], writer.uint32(
 /* id 10, wireType 2 =*/
 82
 ).fork()).ldelim();
 if (message.graphs != null && message.graphs.length)
 for (var i = 0; i < message.graphs.length; ++i)
 $root.onnx.GraphProto.encode(message.graphs[i], writer.uint32(
 /* id 11, wireType 2 =*/
 90
 ).fork()).ldelim();
 if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
 writer.uint32(
 /* id 13, wireType 2 =*/
 106
 ).string(message.docString);
 if (message.tp != null && Object.hasOwnProperty.call(message, "tp"))
 $root.onnx.TypeProto.encode(message.tp, writer.uint32(
 /* id 14, wireType 2 =*/
 114
 ).fork()).ldelim();
 if (message.typeProtos != null && message.typeProtos.length)
 for (var i = 0; i < message.typeProtos.length; ++i)
 $root.onnx.TypeProto.encode(
 message.typeProtos[i],
 writer.uint32(
 /* id 15, wireType 2 =*/
 122
 ).fork()
 ).ldelim();
 if (message.type != null && Object.hasOwnProperty.call(message, "type"))
 writer.uint32(
 /* id 20, wireType 0 =*/
 160
 ).int32(message.type);
 if (message.refAttrName != null && Object.hasOwnProperty.call(message, "refAttrName"))
 writer.uint32(
 /* id 21, wireType 2 =*/
 170
 ).string(message.refAttrName);
 if (message.sparseTensor != null && Object.hasOwnProperty.call(message, "sparseTensor"))
 $root.onnx.SparseTensorProto.encode(
 message.sparseTensor,
 writer.uint32(
 /* id 22, wireType 2 =*/
 178
 ).fork()
 ).ldelim();
 if (message.sparseTensors != null && message.sparseTensors.length)
 for (var i = 0; i < message.sparseTensors.length; ++i)
 $root.onnx.SparseTensorProto.encode(
 message.sparseTensors[i],
 writer.uint32(
 /* id 23, wireType 2 =*/
 186
 ).fork()
 ).ldelim();
 return writer;
 };
 AttributeProto.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 AttributeProto.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.AttributeProto();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 message.name = reader.string();
 break;
 }
 case 21: {
 message.refAttrName = reader.string();
 break;
 }
 case 13: {
 message.docString = reader.string();
 break;
 }
 case 20: {
 message.type = reader.int32();
 break;
 }
 case 2: {
 message.f = reader.float();
 break;
 }
 case 3: {
 message.i = reader.int64();
 break;
 }
 case 4: {
 message.s = reader.bytes();
 break;
 }
 case 5: {
 message.t = $root.onnx.TensorProto.decode(reader, reader.uint32());
 break;
 }
 case 6: {
 message.g = $root.onnx.GraphProto.decode(reader, reader.uint32());
 break;
 }
 case 22: {
 message.sparseTensor = $root.onnx.SparseTensorProto.decode(reader, reader.uint32());
 break;
 }
 case 14: {
 message.tp = $root.onnx.TypeProto.decode(reader, reader.uint32());
 break;
 }
 case 7: {
 if (!(message.floats && message.floats.length))
 message.floats = [];
 if ((tag & 7) === 2) {
 var end2 = reader.uint32() + reader.pos;
 while (reader.pos < end2)
 message.floats.push(reader.float());
 } else
 message.floats.push(reader.float());
 break;
 }
 case 8: {
 if (!(message.ints && message.ints.length))
 message.ints = [];
 if ((tag & 7) === 2) {
 var end2 = reader.uint32() + reader.pos;
 while (reader.pos < end2)
 message.ints.push(reader.int64());
 } else
 message.ints.push(reader.int64());
 break;
 }
 case 9: {
 if (!(message.strings && message.strings.length))
 message.strings = [];
 message.strings.push(reader.bytes());
 break;
 }
 case 10: {
 if (!(message.tensors && message.tensors.length))
 message.tensors = [];
 message.tensors.push($root.onnx.TensorProto.decode(reader, reader.uint32()));
 break;
 }
 case 11: {
 if (!(message.graphs && message.graphs.length))
 message.graphs = [];
 message.graphs.push($root.onnx.GraphProto.decode(reader, reader.uint32()));
 break;
 }
 case 23: {
 if (!(message.sparseTensors && message.sparseTensors.length))
 message.sparseTensors = [];
 message.sparseTensors.push($root.onnx.SparseTensorProto.decode(reader, reader.uint32()));
 break;
 }
 case 15: {
 if (!(message.typeProtos && message.typeProtos.length))
 message.typeProtos = [];
 message.typeProtos.push($root.onnx.TypeProto.decode(reader, reader.uint32()));
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 AttributeProto.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 AttributeProto.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.name != null && message.hasOwnProperty("name")) {
 if (!$util.isString(message.name))
 return "name: string expected";
 }
 if (message.refAttrName != null && message.hasOwnProperty("refAttrName")) {
 if (!$util.isString(message.refAttrName))
 return "refAttrName: string expected";
 }
 if (message.docString != null && message.hasOwnProperty("docString")) {
 if (!$util.isString(message.docString))
 return "docString: string expected";
 }
 if (message.type != null && message.hasOwnProperty("type"))
 switch (message.type) {
 default:
 return "type: enum value expected";
 case 0:
 case 1:
 case 2:
 case 3:
 case 4:
 case 5:
 case 11:
 case 13:
 case 6:
 case 7:
 case 8:
 case 9:
 case 10:
 case 12:
 case 14:
 break;
 }
 if (message.f != null && message.hasOwnProperty("f")) {
 if (typeof message.f !== "number")
 return "f: number expected";
 }
 if (message.i != null && message.hasOwnProperty("i")) {
 if (!$util.isInteger(message.i) && !(message.i && $util.isInteger(message.i.low) && $util.isInteger(message.i.high)))
 return "i: integer|Long expected";
 }
 if (message.s != null && message.hasOwnProperty("s")) {
 if (!(message.s && typeof message.s.length === "number" || $util.isString(message.s)))
 return "s: buffer expected";
 }
 if (message.t != null && message.hasOwnProperty("t")) {
 var error = $root.onnx.TensorProto.verify(message.t);
 if (error)
 return "t." + error;
 }
 if (message.g != null && message.hasOwnProperty("g")) {
 var error = $root.onnx.GraphProto.verify(message.g);
 if (error)
 return "g." + error;
 }
 if (message.sparseTensor != null && message.hasOwnProperty("sparseTensor")) {
 var error = $root.onnx.SparseTensorProto.verify(message.sparseTensor);
 if (error)
 return "sparseTensor." + error;
 }
 if (message.tp != null && message.hasOwnProperty("tp")) {
 var error = $root.onnx.TypeProto.verify(message.tp);
 if (error)
 return "tp." + error;
 }
 if (message.floats != null && message.hasOwnProperty("floats")) {
 if (!Array.isArray(message.floats))
 return "floats: array expected";
 for (var i = 0; i < message.floats.length; ++i)
 if (typeof message.floats[i] !== "number")
 return "floats: number[] expected";
 }
 if (message.ints != null && message.hasOwnProperty("ints")) {
 if (!Array.isArray(message.ints))
 return "ints: array expected";
 for (var i = 0; i < message.ints.length; ++i)
 if (!$util.isInteger(message.ints[i]) && !(message.ints[i] && $util.isInteger(message.ints[i].low) && $util.isInteger(message.ints[i].high)))
 return "ints: integer|Long[] expected";
 }
 if (message.strings != null && message.hasOwnProperty("strings")) {
 if (!Array.isArray(message.strings))
 return "strings: array expected";
 for (var i = 0; i < message.strings.length; ++i)
 if (!(message.strings[i] && typeof message.strings[i].length === "number" || $util.isString(message.strings[i])))
 return "strings: buffer[] expected";
 }
 if (message.tensors != null && message.hasOwnProperty("tensors")) {
 if (!Array.isArray(message.tensors))
 return "tensors: array expected";
 for (var i = 0; i < message.tensors.length; ++i) {
 var error = $root.onnx.TensorProto.verify(message.tensors[i]);
 if (error)
 return "tensors." + error;
 }
 }
 if (message.graphs != null && message.hasOwnProperty("graphs")) {
 if (!Array.isArray(message.graphs))
 return "graphs: array expected";
 for (var i = 0; i < message.graphs.length; ++i) {
 var error = $root.onnx.GraphProto.verify(message.graphs[i]);
 if (error)
 return "graphs." + error;
 }
 }
 if (message.sparseTensors != null && message.hasOwnProperty("sparseTensors")) {
 if (!Array.isArray(message.sparseTensors))
 return "sparseTensors: array expected";
 for (var i = 0; i < message.sparseTensors.length; ++i) {
 var error = $root.onnx.SparseTensorProto.verify(message.sparseTensors[i]);
 if (error)
 return "sparseTensors." + error;
 }
 }
 if (message.typeProtos != null && message.hasOwnProperty("typeProtos")) {
 if (!Array.isArray(message.typeProtos))
 return "typeProtos: array expected";
 for (var i = 0; i < message.typeProtos.length; ++i) {
 var error = $root.onnx.TypeProto.verify(message.typeProtos[i]);
 if (error)
 return "typeProtos." + error;
 }
 }
 return null;
 };
 AttributeProto.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.AttributeProto)
 return object;
 var message = new $root.onnx.AttributeProto();
 if (object.name != null)
 message.name = String(object.name);
 if (object.refAttrName != null)
 message.refAttrName = String(object.refAttrName);
 if (object.docString != null)
 message.docString = String(object.docString);
 switch (object.type) {
 default:
 if (typeof object.type === "number") {
 message.type = object.type;
 break;
 }
 break;
 case "UNDEFINED":
 case 0:
 message.type = 0;
 break;
 case "FLOAT":
 case 1:
 message.type = 1;
 break;
 case "INT":
 case 2:
 message.type = 2;
 break;
 case "STRING":
 case 3:
 message.type = 3;
 break;
 case "TENSOR":
 case 4:
 message.type = 4;
 break;
 case "GRAPH":
 case 5:
 message.type = 5;
 break;
 case "SPARSE_TENSOR":
 case 11:
 message.type = 11;
 break;
 case "TYPE_PROTO":
 case 13:
 message.type = 13;
 break;
 case "FLOATS":
 case 6:
 message.type = 6;
 break;
 case "INTS":
 case 7:
 message.type = 7;
 break;
 case "STRINGS":
 case 8:
 message.type = 8;
 break;
 case "TENSORS":
 case 9:
 message.type = 9;
 break;
 case "GRAPHS":
 case 10:
 message.type = 10;
 break;
 case "SPARSE_TENSORS":
 case 12:
 message.type = 12;
 break;
 case "TYPE_PROTOS":
 case 14:
 message.type = 14;
 break;
 }
 if (object.f != null)
 message.f = Number(object.f);
 if (object.i != null) {
 if ($util.Long)
 (message.i = $util.Long.fromValue(object.i)).unsigned = false;
 else if (typeof object.i === "string")
 message.i = parseInt(object.i, 10);
 else if (typeof object.i === "number")
 message.i = object.i;
 else if (typeof object.i === "object")
 message.i = new $util.LongBits(object.i.low >>> 0, object.i.high >>> 0).toNumber();
 }
 if (object.s != null) {
 if (typeof object.s === "string")
 $util.base64.decode(object.s, message.s = $util.newBuffer($util.base64.length(object.s)), 0);
 else if (object.s.length >= 0)
 message.s = object.s;
 }
 if (object.t != null) {
 if (typeof object.t !== "object")
 throw TypeError(".onnx.AttributeProto.t: object expected");
 message.t = $root.onnx.TensorProto.fromObject(object.t);
 }
 if (object.g != null) {
 if (typeof object.g !== "object")
 throw TypeError(".onnx.AttributeProto.g: object expected");
 message.g = $root.onnx.GraphProto.fromObject(object.g);
 }
 if (object.sparseTensor != null) {
 if (typeof object.sparseTensor !== "object")
 throw TypeError(".onnx.AttributeProto.sparseTensor: object expected");
 message.sparseTensor = $root.onnx.SparseTensorProto.fromObject(object.sparseTensor);
 }
 if (object.tp != null) {
 if (typeof object.tp !== "object")
 throw TypeError(".onnx.AttributeProto.tp: object expected");
 message.tp = $root.onnx.TypeProto.fromObject(object.tp);
 }
 if (object.floats) {
 if (!Array.isArray(object.floats))
 throw TypeError(".onnx.AttributeProto.floats: array expected");
 message.floats = [];
 for (var i = 0; i < object.floats.length; ++i)
 message.floats[i] = Number(object.floats[i]);
 }
 if (object.ints) {
 if (!Array.isArray(object.ints))
 throw TypeError(".onnx.AttributeProto.ints: array expected");
 message.ints = [];
 for (var i = 0; i < object.ints.length; ++i)
 if ($util.Long)
 (message.ints[i] = $util.Long.fromValue(object.ints[i])).unsigned = false;
 else if (typeof object.ints[i] === "string")
 message.ints[i] = parseInt(object.ints[i], 10);
 else if (typeof object.ints[i] === "number")
 message.ints[i] = object.ints[i];
 else if (typeof object.ints[i] === "object")
 message.ints[i] = new $util.LongBits(object.ints[i].low >>> 0, object.ints[i].high >>> 0).toNumber();
 }
 if (object.strings) {
 if (!Array.isArray(object.strings))
 throw TypeError(".onnx.AttributeProto.strings: array expected");
 message.strings = [];
 for (var i = 0; i < object.strings.length; ++i)
 if (typeof object.strings[i] === "string")
 $util.base64.decode(
 object.strings[i],
 message.strings[i] = $util.newBuffer($util.base64.length(object.strings[i])),
 0
 );
 else if (object.strings[i].length >= 0)
 message.strings[i] = object.strings[i];
 }
 if (object.tensors) {
 if (!Array.isArray(object.tensors))
 throw TypeError(".onnx.AttributeProto.tensors: array expected");
 message.tensors = [];
 for (var i = 0; i < object.tensors.length; ++i) {
 if (typeof object.tensors[i] !== "object")
 throw TypeError(".onnx.AttributeProto.tensors: object expected");
 message.tensors[i] = $root.onnx.TensorProto.fromObject(object.tensors[i]);
 }
 }
 if (object.graphs) {
 if (!Array.isArray(object.graphs))
 throw TypeError(".onnx.AttributeProto.graphs: array expected");
 message.graphs = [];
 for (var i = 0; i < object.graphs.length; ++i) {
 if (typeof object.graphs[i] !== "object")
 throw TypeError(".onnx.AttributeProto.graphs: object expected");
 message.graphs[i] = $root.onnx.GraphProto.fromObject(object.graphs[i]);
 }
 }
 if (object.sparseTensors) {
 if (!Array.isArray(object.sparseTensors))
 throw TypeError(".onnx.AttributeProto.sparseTensors: array expected");
 message.sparseTensors = [];
 for (var i = 0; i < object.sparseTensors.length; ++i) {
 if (typeof object.sparseTensors[i] !== "object")
 throw TypeError(".onnx.AttributeProto.sparseTensors: object expected");
 message.sparseTensors[i] = $root.onnx.SparseTensorProto.fromObject(object.sparseTensors[i]);
 }
 }
 if (object.typeProtos) {
 if (!Array.isArray(object.typeProtos))
 throw TypeError(".onnx.AttributeProto.typeProtos: array expected");
 message.typeProtos = [];
 for (var i = 0; i < object.typeProtos.length; ++i) {
 if (typeof object.typeProtos[i] !== "object")
 throw TypeError(".onnx.AttributeProto.typeProtos: object expected");
 message.typeProtos[i] = $root.onnx.TypeProto.fromObject(object.typeProtos[i]);
 }
 }
 return message;
 };
 AttributeProto.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.arrays || options.defaults) {
 object.floats = [];
 object.ints = [];
 object.strings = [];
 object.tensors = [];
 object.graphs = [];
 object.typeProtos = [];
 object.sparseTensors = [];
 }
 if (options.defaults) {
 object.name = "";
 object.f = 0;
 if ($util.Long) {
 var long = new $util.Long(0, 0, false);
 object.i = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
 } else
 object.i = options.longs === String ? "0" : 0;
 if (options.bytes === String)
 object.s = "";
 else {
 object.s = [];
 if (options.bytes !== Array)
 object.s = $util.newBuffer(object.s);
 }
 object.t = null;
 object.g = null;
 object.docString = "";
 object.tp = null;
 object.type = options.enums === String ? "UNDEFINED" : 0;
 object.refAttrName = "";
 object.sparseTensor = null;
 }
 if (message.name != null && message.hasOwnProperty("name"))
 object.name = message.name;
 if (message.f != null && message.hasOwnProperty("f"))
 object.f = options.json && !isFinite(message.f) ? String(message.f) : message.f;
 if (message.i != null && message.hasOwnProperty("i"))
 if (typeof message.i === "number")
 object.i = options.longs === String ? String(message.i) : message.i;
 else
 object.i = options.longs === String ? $util.Long.prototype.toString.call(message.i) : options.longs === Number ? new $util.LongBits(message.i.low >>> 0, message.i.high >>> 0).toNumber() : message.i;
 if (message.s != null && message.hasOwnProperty("s"))
 object.s = options.bytes === String ? $util.base64.encode(message.s, 0, message.s.length) : options.bytes === Array ? Array.prototype.slice.call(message.s) : message.s;
 if (message.t != null && message.hasOwnProperty("t"))
 object.t = $root.onnx.TensorProto.toObject(message.t, options);
 if (message.g != null && message.hasOwnProperty("g"))
 object.g = $root.onnx.GraphProto.toObject(message.g, options);
 if (message.floats && message.floats.length) {
 object.floats = [];
 for (var j = 0; j < message.floats.length; ++j)
 object.floats[j] = options.json && !isFinite(message.floats[j]) ? String(message.floats[j]) : message.floats[j];
 }
 if (message.ints && message.ints.length) {
 object.ints = [];
 for (var j = 0; j < message.ints.length; ++j)
 if (typeof message.ints[j] === "number")
 object.ints[j] = options.longs === String ? String(message.ints[j]) : message.ints[j];
 else
 object.ints[j] = options.longs === String ? $util.Long.prototype.toString.call(message.ints[j]) : options.longs === Number ? new $util.LongBits(message.ints[j].low >>> 0, message.ints[j].high >>> 0).toNumber() : message.ints[j];
 }
 if (message.strings && message.strings.length) {
 object.strings = [];
 for (var j = 0; j < message.strings.length; ++j)
 object.strings[j] = options.bytes === String ? $util.base64.encode(message.strings[j], 0, message.strings[j].length) : options.bytes === Array ? Array.prototype.slice.call(message.strings[j]) : message.strings[j];
 }
 if (message.tensors && message.tensors.length) {
 object.tensors = [];
 for (var j = 0; j < message.tensors.length; ++j)
 object.tensors[j] = $root.onnx.TensorProto.toObject(message.tensors[j], options);
 }
 if (message.graphs && message.graphs.length) {
 object.graphs = [];
 for (var j = 0; j < message.graphs.length; ++j)
 object.graphs[j] = $root.onnx.GraphProto.toObject(message.graphs[j], options);
 }
 if (message.docString != null && message.hasOwnProperty("docString"))
 object.docString = message.docString;
 if (message.tp != null && message.hasOwnProperty("tp"))
 object.tp = $root.onnx.TypeProto.toObject(message.tp, options);
 if (message.typeProtos && message.typeProtos.length) {
 object.typeProtos = [];
 for (var j = 0; j < message.typeProtos.length; ++j)
 object.typeProtos[j] = $root.onnx.TypeProto.toObject(message.typeProtos[j], options);
 }
 if (message.type != null && message.hasOwnProperty("type"))
 object.type = options.enums === String ? $root.onnx.AttributeProto.AttributeType[message.type] === void 0 ? message.type : $root.onnx.AttributeProto.AttributeType[message.type] : message.type;
 if (message.refAttrName != null && message.hasOwnProperty("refAttrName"))
 object.refAttrName = message.refAttrName;
 if (message.sparseTensor != null && message.hasOwnProperty("sparseTensor"))
 object.sparseTensor = $root.onnx.SparseTensorProto.toObject(message.sparseTensor, options);
 if (message.sparseTensors && message.sparseTensors.length) {
 object.sparseTensors = [];
 for (var j = 0; j < message.sparseTensors.length; ++j)
 object.sparseTensors[j] = $root.onnx.SparseTensorProto.toObject(message.sparseTensors[j], options);
 }
 return object;
 };
 AttributeProto.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 AttributeProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.AttributeProto";
 };
 AttributeProto.AttributeType = function() {
 var valuesById = {}, values = Object.create(valuesById);
 values[valuesById[0] = "UNDEFINED"] = 0;
 values[valuesById[1] = "FLOAT"] = 1;
 values[valuesById[2] = "INT"] = 2;
 values[valuesById[3] = "STRING"] = 3;
 values[valuesById[4] = "TENSOR"] = 4;
 values[valuesById[5] = "GRAPH"] = 5;
 values[valuesById[11] = "SPARSE_TENSOR"] = 11;
 values[valuesById[13] = "TYPE_PROTO"] = 13;
 values[valuesById[6] = "FLOATS"] = 6;
 values[valuesById[7] = "INTS"] = 7;
 values[valuesById[8] = "STRINGS"] = 8;
 values[valuesById[9] = "TENSORS"] = 9;
 values[valuesById[10] = "GRAPHS"] = 10;
 values[valuesById[12] = "SPARSE_TENSORS"] = 12;
 values[valuesById[14] = "TYPE_PROTOS"] = 14;
 return values;
 }();
 return AttributeProto;
 }();
 onnx6.ValueInfoProto = function() {
 function ValueInfoProto(properties) {
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 ValueInfoProto.prototype.name = "";
 ValueInfoProto.prototype.type = null;
 ValueInfoProto.prototype.docString = "";
 ValueInfoProto.create = function create(properties) {
 return new ValueInfoProto(properties);
 };
 ValueInfoProto.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.name != null && Object.hasOwnProperty.call(message, "name"))
 writer.uint32(
 /* id 1, wireType 2 =*/
 10
 ).string(message.name);
 if (message.type != null && Object.hasOwnProperty.call(message, "type"))
 $root.onnx.TypeProto.encode(message.type, writer.uint32(
 /* id 2, wireType 2 =*/
 18
 ).fork()).ldelim();
 if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
 writer.uint32(
 /* id 3, wireType 2 =*/
 26
 ).string(message.docString);
 return writer;
 };
 ValueInfoProto.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 ValueInfoProto.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.ValueInfoProto();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 message.name = reader.string();
 break;
 }
 case 2: {
 message.type = $root.onnx.TypeProto.decode(reader, reader.uint32());
 break;
 }
 case 3: {
 message.docString = reader.string();
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 ValueInfoProto.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 ValueInfoProto.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.name != null && message.hasOwnProperty("name")) {
 if (!$util.isString(message.name))
 return "name: string expected";
 }
 if (message.type != null && message.hasOwnProperty("type")) {
 var error = $root.onnx.TypeProto.verify(message.type);
 if (error)
 return "type." + error;
 }
 if (message.docString != null && message.hasOwnProperty("docString")) {
 if (!$util.isString(message.docString))
 return "docString: string expected";
 }
 return null;
 };
 ValueInfoProto.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.ValueInfoProto)
 return object;
 var message = new $root.onnx.ValueInfoProto();
 if (object.name != null)
 message.name = String(object.name);
 if (object.type != null) {
 if (typeof object.type !== "object")
 throw TypeError(".onnx.ValueInfoProto.type: object expected");
 message.type = $root.onnx.TypeProto.fromObject(object.type);
 }
 if (object.docString != null)
 message.docString = String(object.docString);
 return message;
 };
 ValueInfoProto.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.defaults) {
 object.name = "";
 object.type = null;
 object.docString = "";
 }
 if (message.name != null && message.hasOwnProperty("name"))
 object.name = message.name;
 if (message.type != null && message.hasOwnProperty("type"))
 object.type = $root.onnx.TypeProto.toObject(message.type, options);
 if (message.docString != null && message.hasOwnProperty("docString"))
 object.docString = message.docString;
 return object;
 };
 ValueInfoProto.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 ValueInfoProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.ValueInfoProto";
 };
 return ValueInfoProto;
 }();
 onnx6.NodeProto = function() {
 function NodeProto(properties) {
 this.input = [];
 this.output = [];
 this.attribute = [];
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 NodeProto.prototype.input = $util.emptyArray;
 NodeProto.prototype.output = $util.emptyArray;
 NodeProto.prototype.name = "";
 NodeProto.prototype.opType = "";
 NodeProto.prototype.domain = "";
 NodeProto.prototype.attribute = $util.emptyArray;
 NodeProto.prototype.docString = "";
 NodeProto.create = function create(properties) {
 return new NodeProto(properties);
 };
 NodeProto.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.input != null && message.input.length)
 for (var i = 0; i < message.input.length; ++i)
 writer.uint32(
 /* id 1, wireType 2 =*/
 10
 ).string(message.input[i]);
 if (message.output != null && message.output.length)
 for (var i = 0; i < message.output.length; ++i)
 writer.uint32(
 /* id 2, wireType 2 =*/
 18
 ).string(message.output[i]);
 if (message.name != null && Object.hasOwnProperty.call(message, "name"))
 writer.uint32(
 /* id 3, wireType 2 =*/
 26
 ).string(message.name);
 if (message.opType != null && Object.hasOwnProperty.call(message, "opType"))
 writer.uint32(
 /* id 4, wireType 2 =*/
 34
 ).string(message.opType);
 if (message.attribute != null && message.attribute.length)
 for (var i = 0; i < message.attribute.length; ++i)
 $root.onnx.AttributeProto.encode(
 message.attribute[i],
 writer.uint32(
 /* id 5, wireType 2 =*/
 42
 ).fork()
 ).ldelim();
 if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
 writer.uint32(
 /* id 6, wireType 2 =*/
 50
 ).string(message.docString);
 if (message.domain != null && Object.hasOwnProperty.call(message, "domain"))
 writer.uint32(
 /* id 7, wireType 2 =*/
 58
 ).string(message.domain);
 return writer;
 };
 NodeProto.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 NodeProto.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.NodeProto();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 if (!(message.input && message.input.length))
 message.input = [];
 message.input.push(reader.string());
 break;
 }
 case 2: {
 if (!(message.output && message.output.length))
 message.output = [];
 message.output.push(reader.string());
 break;
 }
 case 3: {
 message.name = reader.string();
 break;
 }
 case 4: {
 message.opType = reader.string();
 break;
 }
 case 7: {
 message.domain = reader.string();
 break;
 }
 case 5: {
 if (!(message.attribute && message.attribute.length))
 message.attribute = [];
 message.attribute.push($root.onnx.AttributeProto.decode(reader, reader.uint32()));
 break;
 }
 case 6: {
 message.docString = reader.string();
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 NodeProto.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 NodeProto.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.input != null && message.hasOwnProperty("input")) {
 if (!Array.isArray(message.input))
 return "input: array expected";
 for (var i = 0; i < message.input.length; ++i)
 if (!$util.isString(message.input[i]))
 return "input: string[] expected";
 }
 if (message.output != null && message.hasOwnProperty("output")) {
 if (!Array.isArray(message.output))
 return "output: array expected";
 for (var i = 0; i < message.output.length; ++i)
 if (!$util.isString(message.output[i]))
 return "output: string[] expected";
 }
 if (message.name != null && message.hasOwnProperty("name")) {
 if (!$util.isString(message.name))
 return "name: string expected";
 }
 if (message.opType != null && message.hasOwnProperty("opType")) {
 if (!$util.isString(message.opType))
 return "opType: string expected";
 }
 if (message.domain != null && message.hasOwnProperty("domain")) {
 if (!$util.isString(message.domain))
 return "domain: string expected";
 }
 if (message.attribute != null && message.hasOwnProperty("attribute")) {
 if (!Array.isArray(message.attribute))
 return "attribute: array expected";
 for (var i = 0; i < message.attribute.length; ++i) {
 var error = $root.onnx.AttributeProto.verify(message.attribute[i]);
 if (error)
 return "attribute." + error;
 }
 }
 if (message.docString != null && message.hasOwnProperty("docString")) {
 if (!$util.isString(message.docString))
 return "docString: string expected";
 }
 return null;
 };
 NodeProto.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.NodeProto)
 return object;
 var message = new $root.onnx.NodeProto();
 if (object.input) {
 if (!Array.isArray(object.input))
 throw TypeError(".onnx.NodeProto.input: array expected");
 message.input = [];
 for (var i = 0; i < object.input.length; ++i)
 message.input[i] = String(object.input[i]);
 }
 if (object.output) {
 if (!Array.isArray(object.output))
 throw TypeError(".onnx.NodeProto.output: array expected");
 message.output = [];
 for (var i = 0; i < object.output.length; ++i)
 message.output[i] = String(object.output[i]);
 }
 if (object.name != null)
 message.name = String(object.name);
 if (object.opType != null)
 message.opType = String(object.opType);
 if (object.domain != null)
 message.domain = String(object.domain);
 if (object.attribute) {
 if (!Array.isArray(object.attribute))
 throw TypeError(".onnx.NodeProto.attribute: array expected");
 message.attribute = [];
 for (var i = 0; i < object.attribute.length; ++i) {
 if (typeof object.attribute[i] !== "object")
 throw TypeError(".onnx.NodeProto.attribute: object expected");
 message.attribute[i] = $root.onnx.AttributeProto.fromObject(object.attribute[i]);
 }
 }
 if (object.docString != null)
 message.docString = String(object.docString);
 return message;
 };
 NodeProto.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.arrays || options.defaults) {
 object.input = [];
 object.output = [];
 object.attribute = [];
 }
 if (options.defaults) {
 object.name = "";
 object.opType = "";
 object.docString = "";
 object.domain = "";
 }
 if (message.input && message.input.length) {
 object.input = [];
 for (var j = 0; j < message.input.length; ++j)
 object.input[j] = message.input[j];
 }
 if (message.output && message.output.length) {
 object.output = [];
 for (var j = 0; j < message.output.length; ++j)
 object.output[j] = message.output[j];
 }
 if (message.name != null && message.hasOwnProperty("name"))
 object.name = message.name;
 if (message.opType != null && message.hasOwnProperty("opType"))
 object.opType = message.opType;
 if (message.attribute && message.attribute.length) {
 object.attribute = [];
 for (var j = 0; j < message.attribute.length; ++j)
 object.attribute[j] = $root.onnx.AttributeProto.toObject(message.attribute[j], options);
 }
 if (message.docString != null && message.hasOwnProperty("docString"))
 object.docString = message.docString;
 if (message.domain != null && message.hasOwnProperty("domain"))
 object.domain = message.domain;
 return object;
 };
 NodeProto.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 NodeProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.NodeProto";
 };
 return NodeProto;
 }();
 onnx6.TrainingInfoProto = function() {
 function TrainingInfoProto(properties) {
 this.initializationBinding = [];
 this.updateBinding = [];
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 TrainingInfoProto.prototype.initialization = null;
 TrainingInfoProto.prototype.algorithm = null;
 TrainingInfoProto.prototype.initializationBinding = $util.emptyArray;
 TrainingInfoProto.prototype.updateBinding = $util.emptyArray;
 TrainingInfoProto.create = function create(properties) {
 return new TrainingInfoProto(properties);
 };
 TrainingInfoProto.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.initialization != null && Object.hasOwnProperty.call(message, "initialization"))
 $root.onnx.GraphProto.encode(message.initialization, writer.uint32(
 /* id 1, wireType 2 =*/
 10
 ).fork()).ldelim();
 if (message.algorithm != null && Object.hasOwnProperty.call(message, "algorithm"))
 $root.onnx.GraphProto.encode(message.algorithm, writer.uint32(
 /* id 2, wireType 2 =*/
 18
 ).fork()).ldelim();
 if (message.initializationBinding != null && message.initializationBinding.length)
 for (var i = 0; i < message.initializationBinding.length; ++i)
 $root.onnx.StringStringEntryProto.encode(
 message.initializationBinding[i],
 writer.uint32(
 /* id 3, wireType 2 =*/
 26
 ).fork()
 ).ldelim();
 if (message.updateBinding != null && message.updateBinding.length)
 for (var i = 0; i < message.updateBinding.length; ++i)
 $root.onnx.StringStringEntryProto.encode(
 message.updateBinding[i],
 writer.uint32(
 /* id 4, wireType 2 =*/
 34
 ).fork()
 ).ldelim();
 return writer;
 };
 TrainingInfoProto.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 TrainingInfoProto.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.TrainingInfoProto();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 message.initialization = $root.onnx.GraphProto.decode(reader, reader.uint32());
 break;
 }
 case 2: {
 message.algorithm = $root.onnx.GraphProto.decode(reader, reader.uint32());
 break;
 }
 case 3: {
 if (!(message.initializationBinding && message.initializationBinding.length))
 message.initializationBinding = [];
 message.initializationBinding.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));
 break;
 }
 case 4: {
 if (!(message.updateBinding && message.updateBinding.length))
 message.updateBinding = [];
 message.updateBinding.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 TrainingInfoProto.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 TrainingInfoProto.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.initialization != null && message.hasOwnProperty("initialization")) {
 var error = $root.onnx.GraphProto.verify(message.initialization);
 if (error)
 return "initialization." + error;
 }
 if (message.algorithm != null && message.hasOwnProperty("algorithm")) {
 var error = $root.onnx.GraphProto.verify(message.algorithm);
 if (error)
 return "algorithm." + error;
 }
 if (message.initializationBinding != null && message.hasOwnProperty("initializationBinding")) {
 if (!Array.isArray(message.initializationBinding))
 return "initializationBinding: array expected";
 for (var i = 0; i < message.initializationBinding.length; ++i) {
 var error = $root.onnx.StringStringEntryProto.verify(message.initializationBinding[i]);
 if (error)
 return "initializationBinding." + error;
 }
 }
 if (message.updateBinding != null && message.hasOwnProperty("updateBinding")) {
 if (!Array.isArray(message.updateBinding))
 return "updateBinding: array expected";
 for (var i = 0; i < message.updateBinding.length; ++i) {
 var error = $root.onnx.StringStringEntryProto.verify(message.updateBinding[i]);
 if (error)
 return "updateBinding." + error;
 }
 }
 return null;
 };
 TrainingInfoProto.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.TrainingInfoProto)
 return object;
 var message = new $root.onnx.TrainingInfoProto();
 if (object.initialization != null) {
 if (typeof object.initialization !== "object")
 throw TypeError(".onnx.TrainingInfoProto.initialization: object expected");
 message.initialization = $root.onnx.GraphProto.fromObject(object.initialization);
 }
 if (object.algorithm != null) {
 if (typeof object.algorithm !== "object")
 throw TypeError(".onnx.TrainingInfoProto.algorithm: object expected");
 message.algorithm = $root.onnx.GraphProto.fromObject(object.algorithm);
 }
 if (object.initializationBinding) {
 if (!Array.isArray(object.initializationBinding))
 throw TypeError(".onnx.TrainingInfoProto.initializationBinding: array expected");
 message.initializationBinding = [];
 for (var i = 0; i < object.initializationBinding.length; ++i) {
 if (typeof object.initializationBinding[i] !== "object")
 throw TypeError(".onnx.TrainingInfoProto.initializationBinding: object expected");
 message.initializationBinding[i] = $root.onnx.StringStringEntryProto.fromObject(
 object.initializationBinding[i]
 );
 }
 }
 if (object.updateBinding) {
 if (!Array.isArray(object.updateBinding))
 throw TypeError(".onnx.TrainingInfoProto.updateBinding: array expected");
 message.updateBinding = [];
 for (var i = 0; i < object.updateBinding.length; ++i) {
 if (typeof object.updateBinding[i] !== "object")
 throw TypeError(".onnx.TrainingInfoProto.updateBinding: object expected");
 message.updateBinding[i] = $root.onnx.StringStringEntryProto.fromObject(object.updateBinding[i]);
 }
 }
 return message;
 };
 TrainingInfoProto.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.arrays || options.defaults) {
 object.initializationBinding = [];
 object.updateBinding = [];
 }
 if (options.defaults) {
 object.initialization = null;
 object.algorithm = null;
 }
 if (message.initialization != null && message.hasOwnProperty("initialization"))
 object.initialization = $root.onnx.GraphProto.toObject(message.initialization, options);
 if (message.algorithm != null && message.hasOwnProperty("algorithm"))
 object.algorithm = $root.onnx.GraphProto.toObject(message.algorithm, options);
 if (message.initializationBinding && message.initializationBinding.length) {
 object.initializationBinding = [];
 for (var j = 0; j < message.initializationBinding.length; ++j)
 object.initializationBinding[j] = $root.onnx.StringStringEntryProto.toObject(
 message.initializationBinding[j],
 options
 );
 }
 if (message.updateBinding && message.updateBinding.length) {
 object.updateBinding = [];
 for (var j = 0; j < message.updateBinding.length; ++j)
 object.updateBinding[j] = $root.onnx.StringStringEntryProto.toObject(message.updateBinding[j], options);
 }
 return object;
 };
 TrainingInfoProto.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 TrainingInfoProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.TrainingInfoProto";
 };
 return TrainingInfoProto;
 }();
 onnx6.ModelProto = function() {
 function ModelProto(properties) {
 this.opsetImport = [];
 this.metadataProps = [];
 this.trainingInfo = [];
 this.functions = [];
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 ModelProto.prototype.irVersion = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
 ModelProto.prototype.opsetImport = $util.emptyArray;
 ModelProto.prototype.producerName = "";
 ModelProto.prototype.producerVersion = "";
 ModelProto.prototype.domain = "";
 ModelProto.prototype.modelVersion = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
 ModelProto.prototype.docString = "";
 ModelProto.prototype.graph = null;
 ModelProto.prototype.metadataProps = $util.emptyArray;
 ModelProto.prototype.trainingInfo = $util.emptyArray;
 ModelProto.prototype.functions = $util.emptyArray;
 ModelProto.create = function create(properties) {
 return new ModelProto(properties);
 };
 ModelProto.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.irVersion != null && Object.hasOwnProperty.call(message, "irVersion"))
 writer.uint32(
 /* id 1, wireType 0 =*/
 8
 ).int64(message.irVersion);
 if (message.producerName != null && Object.hasOwnProperty.call(message, "producerName"))
 writer.uint32(
 /* id 2, wireType 2 =*/
 18
 ).string(message.producerName);
 if (message.producerVersion != null && Object.hasOwnProperty.call(message, "producerVersion"))
 writer.uint32(
 /* id 3, wireType 2 =*/
 26
 ).string(message.producerVersion);
 if (message.domain != null && Object.hasOwnProperty.call(message, "domain"))
 writer.uint32(
 /* id 4, wireType 2 =*/
 34
 ).string(message.domain);
 if (message.modelVersion != null && Object.hasOwnProperty.call(message, "modelVersion"))
 writer.uint32(
 /* id 5, wireType 0 =*/
 40
 ).int64(message.modelVersion);
 if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
 writer.uint32(
 /* id 6, wireType 2 =*/
 50
 ).string(message.docString);
 if (message.graph != null && Object.hasOwnProperty.call(message, "graph"))
 $root.onnx.GraphProto.encode(message.graph, writer.uint32(
 /* id 7, wireType 2 =*/
 58
 ).fork()).ldelim();
 if (message.opsetImport != null && message.opsetImport.length)
 for (var i = 0; i < message.opsetImport.length; ++i)
 $root.onnx.OperatorSetIdProto.encode(
 message.opsetImport[i],
 writer.uint32(
 /* id 8, wireType 2 =*/
 66
 ).fork()
 ).ldelim();
 if (message.metadataProps != null && message.metadataProps.length)
 for (var i = 0; i < message.metadataProps.length; ++i)
 $root.onnx.StringStringEntryProto.encode(
 message.metadataProps[i],
 writer.uint32(
 /* id 14, wireType 2 =*/
 114
 ).fork()
 ).ldelim();
 if (message.trainingInfo != null && message.trainingInfo.length)
 for (var i = 0; i < message.trainingInfo.length; ++i)
 $root.onnx.TrainingInfoProto.encode(
 message.trainingInfo[i],
 writer.uint32(
 /* id 20, wireType 2 =*/
 162
 ).fork()
 ).ldelim();
 if (message.functions != null && message.functions.length)
 for (var i = 0; i < message.functions.length; ++i)
 $root.onnx.FunctionProto.encode(
 message.functions[i],
 writer.uint32(
 /* id 25, wireType 2 =*/
 202
 ).fork()
 ).ldelim();
 return writer;
 };
 ModelProto.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 ModelProto.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.ModelProto();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 message.irVersion = reader.int64();
 break;
 }
 case 8: {
 if (!(message.opsetImport && message.opsetImport.length))
 message.opsetImport = [];
 message.opsetImport.push($root.onnx.OperatorSetIdProto.decode(reader, reader.uint32()));
 break;
 }
 case 2: {
 message.producerName = reader.string();
 break;
 }
 case 3: {
 message.producerVersion = reader.string();
 break;
 }
 case 4: {
 message.domain = reader.string();
 break;
 }
 case 5: {
 message.modelVersion = reader.int64();
 break;
 }
 case 6: {
 message.docString = reader.string();
 break;
 }
 case 7: {
 message.graph = $root.onnx.GraphProto.decode(reader, reader.uint32());
 break;
 }
 case 14: {
 if (!(message.metadataProps && message.metadataProps.length))
 message.metadataProps = [];
 message.metadataProps.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));
 break;
 }
 case 20: {
 if (!(message.trainingInfo && message.trainingInfo.length))
 message.trainingInfo = [];
 message.trainingInfo.push($root.onnx.TrainingInfoProto.decode(reader, reader.uint32()));
 break;
 }
 case 25: {
 if (!(message.functions && message.functions.length))
 message.functions = [];
 message.functions.push($root.onnx.FunctionProto.decode(reader, reader.uint32()));
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 ModelProto.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 ModelProto.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.irVersion != null && message.hasOwnProperty("irVersion")) {
 if (!$util.isInteger(message.irVersion) && !(message.irVersion && $util.isInteger(message.irVersion.low) && $util.isInteger(message.irVersion.high)))
 return "irVersion: integer|Long expected";
 }
 if (message.opsetImport != null && message.hasOwnProperty("opsetImport")) {
 if (!Array.isArray(message.opsetImport))
 return "opsetImport: array expected";
 for (var i = 0; i < message.opsetImport.length; ++i) {
 var error = $root.onnx.OperatorSetIdProto.verify(message.opsetImport[i]);
 if (error)
 return "opsetImport." + error;
 }
 }
 if (message.producerName != null && message.hasOwnProperty("producerName")) {
 if (!$util.isString(message.producerName))
 return "producerName: string expected";
 }
 if (message.producerVersion != null && message.hasOwnProperty("producerVersion")) {
 if (!$util.isString(message.producerVersion))
 return "producerVersion: string expected";
 }
 if (message.domain != null && message.hasOwnProperty("domain")) {
 if (!$util.isString(message.domain))
 return "domain: string expected";
 }
 if (message.modelVersion != null && message.hasOwnProperty("modelVersion")) {
 if (!$util.isInteger(message.modelVersion) && !(message.modelVersion && $util.isInteger(message.modelVersion.low) && $util.isInteger(message.modelVersion.high)))
 return "modelVersion: integer|Long expected";
 }
 if (message.docString != null && message.hasOwnProperty("docString")) {
 if (!$util.isString(message.docString))
 return "docString: string expected";
 }
 if (message.graph != null && message.hasOwnProperty("graph")) {
 var error = $root.onnx.GraphProto.verify(message.graph);
 if (error)
 return "graph." + error;
 }
 if (message.metadataProps != null && message.hasOwnProperty("metadataProps")) {
 if (!Array.isArray(message.metadataProps))
 return "metadataProps: array expected";
 for (var i = 0; i < message.metadataProps.length; ++i) {
 var error = $root.onnx.StringStringEntryProto.verify(message.metadataProps[i]);
 if (error)
 return "metadataProps." + error;
 }
 }
 if (message.trainingInfo != null && message.hasOwnProperty("trainingInfo")) {
 if (!Array.isArray(message.trainingInfo))
 return "trainingInfo: array expected";
 for (var i = 0; i < message.trainingInfo.length; ++i) {
 var error = $root.onnx.TrainingInfoProto.verify(message.trainingInfo[i]);
 if (error)
 return "trainingInfo." + error;
 }
 }
 if (message.functions != null && message.hasOwnProperty("functions")) {
 if (!Array.isArray(message.functions))
 return "functions: array expected";
 for (var i = 0; i < message.functions.length; ++i) {
 var error = $root.onnx.FunctionProto.verify(message.functions[i]);
 if (error)
 return "functions." + error;
 }
 }
 return null;
 };
 ModelProto.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.ModelProto)
 return object;
 var message = new $root.onnx.ModelProto();
 if (object.irVersion != null) {
 if ($util.Long)
 (message.irVersion = $util.Long.fromValue(object.irVersion)).unsigned = false;
 else if (typeof object.irVersion === "string")
 message.irVersion = parseInt(object.irVersion, 10);
 else if (typeof object.irVersion === "number")
 message.irVersion = object.irVersion;
 else if (typeof object.irVersion === "object")
 message.irVersion = new $util.LongBits(object.irVersion.low >>> 0, object.irVersion.high >>> 0).toNumber();
 }
 if (object.opsetImport) {
 if (!Array.isArray(object.opsetImport))
 throw TypeError(".onnx.ModelProto.opsetImport: array expected");
 message.opsetImport = [];
 for (var i = 0; i < object.opsetImport.length; ++i) {
 if (typeof object.opsetImport[i] !== "object")
 throw TypeError(".onnx.ModelProto.opsetImport: object expected");
 message.opsetImport[i] = $root.onnx.OperatorSetIdProto.fromObject(object.opsetImport[i]);
 }
 }
 if (object.producerName != null)
 message.producerName = String(object.producerName);
 if (object.producerVersion != null)
 message.producerVersion = String(object.producerVersion);
 if (object.domain != null)
 message.domain = String(object.domain);
 if (object.modelVersion != null) {
 if ($util.Long)
 (message.modelVersion = $util.Long.fromValue(object.modelVersion)).unsigned = false;
 else if (typeof object.modelVersion === "string")
 message.modelVersion = parseInt(object.modelVersion, 10);
 else if (typeof object.modelVersion === "number")
 message.modelVersion = object.modelVersion;
 else if (typeof object.modelVersion === "object")
 message.modelVersion = new $util.LongBits(
 object.modelVersion.low >>> 0,
 object.modelVersion.high >>> 0
 ).toNumber();
 }
 if (object.docString != null)
 message.docString = String(object.docString);
 if (object.graph != null) {
 if (typeof object.graph !== "object")
 throw TypeError(".onnx.ModelProto.graph: object expected");
 message.graph = $root.onnx.GraphProto.fromObject(object.graph);
 }
 if (object.metadataProps) {
 if (!Array.isArray(object.metadataProps))
 throw TypeError(".onnx.ModelProto.metadataProps: array expected");
 message.metadataProps = [];
 for (var i = 0; i < object.metadataProps.length; ++i) {
 if (typeof object.metadataProps[i] !== "object")
 throw TypeError(".onnx.ModelProto.metadataProps: object expected");
 message.metadataProps[i] = $root.onnx.StringStringEntryProto.fromObject(object.metadataProps[i]);
 }
 }
 if (object.trainingInfo) {
 if (!Array.isArray(object.trainingInfo))
 throw TypeError(".onnx.ModelProto.trainingInfo: array expected");
 message.trainingInfo = [];
 for (var i = 0; i < object.trainingInfo.length; ++i) {
 if (typeof object.trainingInfo[i] !== "object")
 throw TypeError(".onnx.ModelProto.trainingInfo: object expected");
 message.trainingInfo[i] = $root.onnx.TrainingInfoProto.fromObject(object.trainingInfo[i]);
 }
 }
 if (object.functions) {
 if (!Array.isArray(object.functions))
 throw TypeError(".onnx.ModelProto.functions: array expected");
 message.functions = [];
 for (var i = 0; i < object.functions.length; ++i) {
 if (typeof object.functions[i] !== "object")
 throw TypeError(".onnx.ModelProto.functions: object expected");
 message.functions[i] = $root.onnx.FunctionProto.fromObject(object.functions[i]);
 }
 }
 return message;
 };
 ModelProto.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.arrays || options.defaults) {
 object.opsetImport = [];
 object.metadataProps = [];
 object.trainingInfo = [];
 object.functions = [];
 }
 if (options.defaults) {
 if ($util.Long) {
 var long = new $util.Long(0, 0, false);
 object.irVersion = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
 } else
 object.irVersion = options.longs === String ? "0" : 0;
 object.producerName = "";
 object.producerVersion = "";
 object.domain = "";
 if ($util.Long) {
 var long = new $util.Long(0, 0, false);
 object.modelVersion = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
 } else
 object.modelVersion = options.longs === String ? "0" : 0;
 object.docString = "";
 object.graph = null;
 }
 if (message.irVersion != null && message.hasOwnProperty("irVersion"))
 if (typeof message.irVersion === "number")
 object.irVersion = options.longs === String ? String(message.irVersion) : message.irVersion;
 else
 object.irVersion = options.longs === String ? $util.Long.prototype.toString.call(message.irVersion) : options.longs === Number ? new $util.LongBits(message.irVersion.low >>> 0, message.irVersion.high >>> 0).toNumber() : message.irVersion;
 if (message.producerName != null && message.hasOwnProperty("producerName"))
 object.producerName = message.producerName;
 if (message.producerVersion != null && message.hasOwnProperty("producerVersion"))
 object.producerVersion = message.producerVersion;
 if (message.domain != null && message.hasOwnProperty("domain"))
 object.domain = message.domain;
 if (message.modelVersion != null && message.hasOwnProperty("modelVersion"))
 if (typeof message.modelVersion === "number")
 object.modelVersion = options.longs === String ? String(message.modelVersion) : message.modelVersion;
 else
 object.modelVersion = options.longs === String ? $util.Long.prototype.toString.call(message.modelVersion) : options.longs === Number ? new $util.LongBits(message.modelVersion.low >>> 0, message.modelVersion.high >>> 0).toNumber() : message.modelVersion;
 if (message.docString != null && message.hasOwnProperty("docString"))
 object.docString = message.docString;
 if (message.graph != null && message.hasOwnProperty("graph"))
 object.graph = $root.onnx.GraphProto.toObject(message.graph, options);
 if (message.opsetImport && message.opsetImport.length) {
 object.opsetImport = [];
 for (var j = 0; j < message.opsetImport.length; ++j)
 object.opsetImport[j] = $root.onnx.OperatorSetIdProto.toObject(message.opsetImport[j], options);
 }
 if (message.metadataProps && message.metadataProps.length) {
 object.metadataProps = [];
 for (var j = 0; j < message.metadataProps.length; ++j)
 object.metadataProps[j] = $root.onnx.StringStringEntryProto.toObject(message.metadataProps[j], options);
 }
 if (message.trainingInfo && message.trainingInfo.length) {
 object.trainingInfo = [];
 for (var j = 0; j < message.trainingInfo.length; ++j)
 object.trainingInfo[j] = $root.onnx.TrainingInfoProto.toObject(message.trainingInfo[j], options);
 }
 if (message.functions && message.functions.length) {
 object.functions = [];
 for (var j = 0; j < message.functions.length; ++j)
 object.functions[j] = $root.onnx.FunctionProto.toObject(message.functions[j], options);
 }
 return object;
 };
 ModelProto.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 ModelProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.ModelProto";
 };
 return ModelProto;
 }();
 onnx6.StringStringEntryProto = function() {
 function StringStringEntryProto(properties) {
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 StringStringEntryProto.prototype.key = "";
 StringStringEntryProto.prototype.value = "";
 StringStringEntryProto.create = function create(properties) {
 return new StringStringEntryProto(properties);
 };
 StringStringEntryProto.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.key != null && Object.hasOwnProperty.call(message, "key"))
 writer.uint32(
 /* id 1, wireType 2 =*/
 10
 ).string(message.key);
 if (message.value != null && Object.hasOwnProperty.call(message, "value"))
 writer.uint32(
 /* id 2, wireType 2 =*/
 18
 ).string(message.value);
 return writer;
 };
 StringStringEntryProto.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 StringStringEntryProto.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.StringStringEntryProto();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 message.key = reader.string();
 break;
 }
 case 2: {
 message.value = reader.string();
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 StringStringEntryProto.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 StringStringEntryProto.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.key != null && message.hasOwnProperty("key")) {
 if (!$util.isString(message.key))
 return "key: string expected";
 }
 if (message.value != null && message.hasOwnProperty("value")) {
 if (!$util.isString(message.value))
 return "value: string expected";
 }
 return null;
 };
 StringStringEntryProto.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.StringStringEntryProto)
 return object;
 var message = new $root.onnx.StringStringEntryProto();
 if (object.key != null)
 message.key = String(object.key);
 if (object.value != null)
 message.value = String(object.value);
 return message;
 };
 StringStringEntryProto.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.defaults) {
 object.key = "";
 object.value = "";
 }
 if (message.key != null && message.hasOwnProperty("key"))
 object.key = message.key;
 if (message.value != null && message.hasOwnProperty("value"))
 object.value = message.value;
 return object;
 };
 StringStringEntryProto.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 StringStringEntryProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.StringStringEntryProto";
 };
 return StringStringEntryProto;
 }();
 onnx6.TensorAnnotation = function() {
 function TensorAnnotation(properties) {
 this.quantParameterTensorNames = [];
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 TensorAnnotation.prototype.tensorName = "";
 TensorAnnotation.prototype.quantParameterTensorNames = $util.emptyArray;
 TensorAnnotation.create = function create(properties) {
 return new TensorAnnotation(properties);
 };
 TensorAnnotation.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.tensorName != null && Object.hasOwnProperty.call(message, "tensorName"))
 writer.uint32(
 /* id 1, wireType 2 =*/
 10
 ).string(message.tensorName);
 if (message.quantParameterTensorNames != null && message.quantParameterTensorNames.length)
 for (var i = 0; i < message.quantParameterTensorNames.length; ++i)
 $root.onnx.StringStringEntryProto.encode(
 message.quantParameterTensorNames[i],
 writer.uint32(
 /* id 2, wireType 2 =*/
 18
 ).fork()
 ).ldelim();
 return writer;
 };
 TensorAnnotation.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 TensorAnnotation.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.TensorAnnotation();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 message.tensorName = reader.string();
 break;
 }
 case 2: {
 if (!(message.quantParameterTensorNames && message.quantParameterTensorNames.length))
 message.quantParameterTensorNames = [];
 message.quantParameterTensorNames.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 TensorAnnotation.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 TensorAnnotation.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.tensorName != null && message.hasOwnProperty("tensorName")) {
 if (!$util.isString(message.tensorName))
 return "tensorName: string expected";
 }
 if (message.quantParameterTensorNames != null && message.hasOwnProperty("quantParameterTensorNames")) {
 if (!Array.isArray(message.quantParameterTensorNames))
 return "quantParameterTensorNames: array expected";
 for (var i = 0; i < message.quantParameterTensorNames.length; ++i) {
 var error = $root.onnx.StringStringEntryProto.verify(message.quantParameterTensorNames[i]);
 if (error)
 return "quantParameterTensorNames." + error;
 }
 }
 return null;
 };
 TensorAnnotation.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.TensorAnnotation)
 return object;
 var message = new $root.onnx.TensorAnnotation();
 if (object.tensorName != null)
 message.tensorName = String(object.tensorName);
 if (object.quantParameterTensorNames) {
 if (!Array.isArray(object.quantParameterTensorNames))
 throw TypeError(".onnx.TensorAnnotation.quantParameterTensorNames: array expected");
 message.quantParameterTensorNames = [];
 for (var i = 0; i < object.quantParameterTensorNames.length; ++i) {
 if (typeof object.quantParameterTensorNames[i] !== "object")
 throw TypeError(".onnx.TensorAnnotation.quantParameterTensorNames: object expected");
 message.quantParameterTensorNames[i] = $root.onnx.StringStringEntryProto.fromObject(
 object.quantParameterTensorNames[i]
 );
 }
 }
 return message;
 };
 TensorAnnotation.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.arrays || options.defaults)
 object.quantParameterTensorNames = [];
 if (options.defaults)
 object.tensorName = "";
 if (message.tensorName != null && message.hasOwnProperty("tensorName"))
 object.tensorName = message.tensorName;
 if (message.quantParameterTensorNames && message.quantParameterTensorNames.length) {
 object.quantParameterTensorNames = [];
 for (var j = 0; j < message.quantParameterTensorNames.length; ++j)
 object.quantParameterTensorNames[j] = $root.onnx.StringStringEntryProto.toObject(
 message.quantParameterTensorNames[j],
 options
 );
 }
 return object;
 };
 TensorAnnotation.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 TensorAnnotation.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.TensorAnnotation";
 };
 return TensorAnnotation;
 }();
 onnx6.GraphProto = function() {
 function GraphProto(properties) {
 this.node = [];
 this.initializer = [];
 this.sparseInitializer = [];
 this.input = [];
 this.output = [];
 this.valueInfo = [];
 this.quantizationAnnotation = [];
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 GraphProto.prototype.node = $util.emptyArray;
 GraphProto.prototype.name = "";
 GraphProto.prototype.initializer = $util.emptyArray;
 GraphProto.prototype.sparseInitializer = $util.emptyArray;
 GraphProto.prototype.docString = "";
 GraphProto.prototype.input = $util.emptyArray;
 GraphProto.prototype.output = $util.emptyArray;
 GraphProto.prototype.valueInfo = $util.emptyArray;
 GraphProto.prototype.quantizationAnnotation = $util.emptyArray;
 GraphProto.create = function create(properties) {
 return new GraphProto(properties);
 };
 GraphProto.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.node != null && message.node.length)
 for (var i = 0; i < message.node.length; ++i)
 $root.onnx.NodeProto.encode(message.node[i], writer.uint32(
 /* id 1, wireType 2 =*/
 10
 ).fork()).ldelim();
 if (message.name != null && Object.hasOwnProperty.call(message, "name"))
 writer.uint32(
 /* id 2, wireType 2 =*/
 18
 ).string(message.name);
 if (message.initializer != null && message.initializer.length)
 for (var i = 0; i < message.initializer.length; ++i)
 $root.onnx.TensorProto.encode(
 message.initializer[i],
 writer.uint32(
 /* id 5, wireType 2 =*/
 42
 ).fork()
 ).ldelim();
 if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
 writer.uint32(
 /* id 10, wireType 2 =*/
 82
 ).string(message.docString);
 if (message.input != null && message.input.length)
 for (var i = 0; i < message.input.length; ++i)
 $root.onnx.ValueInfoProto.encode(
 message.input[i],
 writer.uint32(
 /* id 11, wireType 2 =*/
 90
 ).fork()
 ).ldelim();
 if (message.output != null && message.output.length)
 for (var i = 0; i < message.output.length; ++i)
 $root.onnx.ValueInfoProto.encode(
 message.output[i],
 writer.uint32(
 /* id 12, wireType 2 =*/
 98
 ).fork()
 ).ldelim();
 if (message.valueInfo != null && message.valueInfo.length)
 for (var i = 0; i < message.valueInfo.length; ++i)
 $root.onnx.ValueInfoProto.encode(
 message.valueInfo[i],
 writer.uint32(
 /* id 13, wireType 2 =*/
 106
 ).fork()
 ).ldelim();
 if (message.quantizationAnnotation != null && message.quantizationAnnotation.length)
 for (var i = 0; i < message.quantizationAnnotation.length; ++i)
 $root.onnx.TensorAnnotation.encode(
 message.quantizationAnnotation[i],
 writer.uint32(
 /* id 14, wireType 2 =*/
 114
 ).fork()
 ).ldelim();
 if (message.sparseInitializer != null && message.sparseInitializer.length)
 for (var i = 0; i < message.sparseInitializer.length; ++i)
 $root.onnx.SparseTensorProto.encode(
 message.sparseInitializer[i],
 writer.uint32(
 /* id 15, wireType 2 =*/
 122
 ).fork()
 ).ldelim();
 return writer;
 };
 GraphProto.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 GraphProto.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.GraphProto();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 if (!(message.node && message.node.length))
 message.node = [];
 message.node.push($root.onnx.NodeProto.decode(reader, reader.uint32()));
 break;
 }
 case 2: {
 message.name = reader.string();
 break;
 }
 case 5: {
 if (!(message.initializer && message.initializer.length))
 message.initializer = [];
 message.initializer.push($root.onnx.TensorProto.decode(reader, reader.uint32()));
 break;
 }
 case 15: {
 if (!(message.sparseInitializer && message.sparseInitializer.length))
 message.sparseInitializer = [];
 message.sparseInitializer.push($root.onnx.SparseTensorProto.decode(reader, reader.uint32()));
 break;
 }
 case 10: {
 message.docString = reader.string();
 break;
 }
 case 11: {
 if (!(message.input && message.input.length))
 message.input = [];
 message.input.push($root.onnx.ValueInfoProto.decode(reader, reader.uint32()));
 break;
 }
 case 12: {
 if (!(message.output && message.output.length))
 message.output = [];
 message.output.push($root.onnx.ValueInfoProto.decode(reader, reader.uint32()));
 break;
 }
 case 13: {
 if (!(message.valueInfo && message.valueInfo.length))
 message.valueInfo = [];
 message.valueInfo.push($root.onnx.ValueInfoProto.decode(reader, reader.uint32()));
 break;
 }
 case 14: {
 if (!(message.quantizationAnnotation && message.quantizationAnnotation.length))
 message.quantizationAnnotation = [];
 message.quantizationAnnotation.push($root.onnx.TensorAnnotation.decode(reader, reader.uint32()));
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 GraphProto.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 GraphProto.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.node != null && message.hasOwnProperty("node")) {
 if (!Array.isArray(message.node))
 return "node: array expected";
 for (var i = 0; i < message.node.length; ++i) {
 var error = $root.onnx.NodeProto.verify(message.node[i]);
 if (error)
 return "node." + error;
 }
 }
 if (message.name != null && message.hasOwnProperty("name")) {
 if (!$util.isString(message.name))
 return "name: string expected";
 }
 if (message.initializer != null && message.hasOwnProperty("initializer")) {
 if (!Array.isArray(message.initializer))
 return "initializer: array expected";
 for (var i = 0; i < message.initializer.length; ++i) {
 var error = $root.onnx.TensorProto.verify(message.initializer[i]);
 if (error)
 return "initializer." + error;
 }
 }
 if (message.sparseInitializer != null && message.hasOwnProperty("sparseInitializer")) {
 if (!Array.isArray(message.sparseInitializer))
 return "sparseInitializer: array expected";
 for (var i = 0; i < message.sparseInitializer.length; ++i) {
 var error = $root.onnx.SparseTensorProto.verify(message.sparseInitializer[i]);
 if (error)
 return "sparseInitializer." + error;
 }
 }
 if (message.docString != null && message.hasOwnProperty("docString")) {
 if (!$util.isString(message.docString))
 return "docString: string expected";
 }
 if (message.input != null && message.hasOwnProperty("input")) {
 if (!Array.isArray(message.input))
 return "input: array expected";
 for (var i = 0; i < message.input.length; ++i) {
 var error = $root.onnx.ValueInfoProto.verify(message.input[i]);
 if (error)
 return "input." + error;
 }
 }
 if (message.output != null && message.hasOwnProperty("output")) {
 if (!Array.isArray(message.output))
 return "output: array expected";
 for (var i = 0; i < message.output.length; ++i) {
 var error = $root.onnx.ValueInfoProto.verify(message.output[i]);
 if (error)
 return "output." + error;
 }
 }
 if (message.valueInfo != null && message.hasOwnProperty("valueInfo")) {
 if (!Array.isArray(message.valueInfo))
 return "valueInfo: array expected";
 for (var i = 0; i < message.valueInfo.length; ++i) {
 var error = $root.onnx.ValueInfoProto.verify(message.valueInfo[i]);
 if (error)
 return "valueInfo." + error;
 }
 }
 if (message.quantizationAnnotation != null && message.hasOwnProperty("quantizationAnnotation")) {
 if (!Array.isArray(message.quantizationAnnotation))
 return "quantizationAnnotation: array expected";
 for (var i = 0; i < message.quantizationAnnotation.length; ++i) {
 var error = $root.onnx.TensorAnnotation.verify(message.quantizationAnnotation[i]);
 if (error)
 return "quantizationAnnotation." + error;
 }
 }
 return null;
 };
 GraphProto.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.GraphProto)
 return object;
 var message = new $root.onnx.GraphProto();
 if (object.node) {
 if (!Array.isArray(object.node))
 throw TypeError(".onnx.GraphProto.node: array expected");
 message.node = [];
 for (var i = 0; i < object.node.length; ++i) {
 if (typeof object.node[i] !== "object")
 throw TypeError(".onnx.GraphProto.node: object expected");
 message.node[i] = $root.onnx.NodeProto.fromObject(object.node[i]);
 }
 }
 if (object.name != null)
 message.name = String(object.name);
 if (object.initializer) {
 if (!Array.isArray(object.initializer))
 throw TypeError(".onnx.GraphProto.initializer: array expected");
 message.initializer = [];
 for (var i = 0; i < object.initializer.length; ++i) {
 if (typeof object.initializer[i] !== "object")
 throw TypeError(".onnx.GraphProto.initializer: object expected");
 message.initializer[i] = $root.onnx.TensorProto.fromObject(object.initializer[i]);
 }
 }
 if (object.sparseInitializer) {
 if (!Array.isArray(object.sparseInitializer))
 throw TypeError(".onnx.GraphProto.sparseInitializer: array expected");
 message.sparseInitializer = [];
 for (var i = 0; i < object.sparseInitializer.length; ++i) {
 if (typeof object.sparseInitializer[i] !== "object")
 throw TypeError(".onnx.GraphProto.sparseInitializer: object expected");
 message.sparseInitializer[i] = $root.onnx.SparseTensorProto.fromObject(object.sparseInitializer[i]);
 }
 }
 if (object.docString != null)
 message.docString = String(object.docString);
 if (object.input) {
 if (!Array.isArray(object.input))
 throw TypeError(".onnx.GraphProto.input: array expected");
 message.input = [];
 for (var i = 0; i < object.input.length; ++i) {
 if (typeof object.input[i] !== "object")
 throw TypeError(".onnx.GraphProto.input: object expected");
 message.input[i] = $root.onnx.ValueInfoProto.fromObject(object.input[i]);
 }
 }
 if (object.output) {
 if (!Array.isArray(object.output))
 throw TypeError(".onnx.GraphProto.output: array expected");
 message.output = [];
 for (var i = 0; i < object.output.length; ++i) {
 if (typeof object.output[i] !== "object")
 throw TypeError(".onnx.GraphProto.output: object expected");
 message.output[i] = $root.onnx.ValueInfoProto.fromObject(object.output[i]);
 }
 }
 if (object.valueInfo) {
 if (!Array.isArray(object.valueInfo))
 throw TypeError(".onnx.GraphProto.valueInfo: array expected");
 message.valueInfo = [];
 for (var i = 0; i < object.valueInfo.length; ++i) {
 if (typeof object.valueInfo[i] !== "object")
 throw TypeError(".onnx.GraphProto.valueInfo: object expected");
 message.valueInfo[i] = $root.onnx.ValueInfoProto.fromObject(object.valueInfo[i]);
 }
 }
 if (object.quantizationAnnotation) {
 if (!Array.isArray(object.quantizationAnnotation))
 throw TypeError(".onnx.GraphProto.quantizationAnnotation: array expected");
 message.quantizationAnnotation = [];
 for (var i = 0; i < object.quantizationAnnotation.length; ++i) {
 if (typeof object.quantizationAnnotation[i] !== "object")
 throw TypeError(".onnx.GraphProto.quantizationAnnotation: object expected");
 message.quantizationAnnotation[i] = $root.onnx.TensorAnnotation.fromObject(object.quantizationAnnotation[i]);
 }
 }
 return message;
 };
 GraphProto.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.arrays || options.defaults) {
 object.node = [];
 object.initializer = [];
 object.input = [];
 object.output = [];
 object.valueInfo = [];
 object.quantizationAnnotation = [];
 object.sparseInitializer = [];
 }
 if (options.defaults) {
 object.name = "";
 object.docString = "";
 }
 if (message.node && message.node.length) {
 object.node = [];
 for (var j = 0; j < message.node.length; ++j)
 object.node[j] = $root.onnx.NodeProto.toObject(message.node[j], options);
 }
 if (message.name != null && message.hasOwnProperty("name"))
 object.name = message.name;
 if (message.initializer && message.initializer.length) {
 object.initializer = [];
 for (var j = 0; j < message.initializer.length; ++j)
 object.initializer[j] = $root.onnx.TensorProto.toObject(message.initializer[j], options);
 }
 if (message.docString != null && message.hasOwnProperty("docString"))
 object.docString = message.docString;
 if (message.input && message.input.length) {
 object.input = [];
 for (var j = 0; j < message.input.length; ++j)
 object.input[j] = $root.onnx.ValueInfoProto.toObject(message.input[j], options);
 }
 if (message.output && message.output.length) {
 object.output = [];
 for (var j = 0; j < message.output.length; ++j)
 object.output[j] = $root.onnx.ValueInfoProto.toObject(message.output[j], options);
 }
 if (message.valueInfo && message.valueInfo.length) {
 object.valueInfo = [];
 for (var j = 0; j < message.valueInfo.length; ++j)
 object.valueInfo[j] = $root.onnx.ValueInfoProto.toObject(message.valueInfo[j], options);
 }
 if (message.quantizationAnnotation && message.quantizationAnnotation.length) {
 object.quantizationAnnotation = [];
 for (var j = 0; j < message.quantizationAnnotation.length; ++j)
 object.quantizationAnnotation[j] = $root.onnx.TensorAnnotation.toObject(
 message.quantizationAnnotation[j],
 options
 );
 }
 if (message.sparseInitializer && message.sparseInitializer.length) {
 object.sparseInitializer = [];
 for (var j = 0; j < message.sparseInitializer.length; ++j)
 object.sparseInitializer[j] = $root.onnx.SparseTensorProto.toObject(message.sparseInitializer[j], options);
 }
 return object;
 };
 GraphProto.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 GraphProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.GraphProto";
 };
 return GraphProto;
 }();
 onnx6.TensorProto = function() {
 function TensorProto(properties) {
 this.dims = [];
 this.floatData = [];
 this.int32Data = [];
 this.stringData = [];
 this.int64Data = [];
 this.externalData = [];
 this.doubleData = [];
 this.uint64Data = [];
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 TensorProto.prototype.dims = $util.emptyArray;
 TensorProto.prototype.dataType = 0;
 TensorProto.prototype.segment = null;
 TensorProto.prototype.floatData = $util.emptyArray;
 TensorProto.prototype.int32Data = $util.emptyArray;
 TensorProto.prototype.stringData = $util.emptyArray;
 TensorProto.prototype.int64Data = $util.emptyArray;
 TensorProto.prototype.name = "";
 TensorProto.prototype.docString = "";
 TensorProto.prototype.rawData = $util.newBuffer([]);
 TensorProto.prototype.externalData = $util.emptyArray;
 TensorProto.prototype.dataLocation = 0;
 TensorProto.prototype.doubleData = $util.emptyArray;
 TensorProto.prototype.uint64Data = $util.emptyArray;
 TensorProto.create = function create(properties) {
 return new TensorProto(properties);
 };
 TensorProto.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.dims != null && message.dims.length) {
 writer.uint32(
 /* id 1, wireType 2 =*/
 10
 ).fork();
 for (var i = 0; i < message.dims.length; ++i)
 writer.int64(message.dims[i]);
 writer.ldelim();
 }
 if (message.dataType != null && Object.hasOwnProperty.call(message, "dataType"))
 writer.uint32(
 /* id 2, wireType 0 =*/
 16
 ).int32(message.dataType);
 if (message.segment != null && Object.hasOwnProperty.call(message, "segment"))
 $root.onnx.TensorProto.Segment.encode(
 message.segment,
 writer.uint32(
 /* id 3, wireType 2 =*/
 26
 ).fork()
 ).ldelim();
 if (message.floatData != null && message.floatData.length) {
 writer.uint32(
 /* id 4, wireType 2 =*/
 34
 ).fork();
 for (var i = 0; i < message.floatData.length; ++i)
 writer.float(message.floatData[i]);
 writer.ldelim();
 }
 if (message.int32Data != null && message.int32Data.length) {
 writer.uint32(
 /* id 5, wireType 2 =*/
 42
 ).fork();
 for (var i = 0; i < message.int32Data.length; ++i)
 writer.int32(message.int32Data[i]);
 writer.ldelim();
 }
 if (message.stringData != null && message.stringData.length)
 for (var i = 0; i < message.stringData.length; ++i)
 writer.uint32(
 /* id 6, wireType 2 =*/
 50
 ).bytes(message.stringData[i]);
 if (message.int64Data != null && message.int64Data.length) {
 writer.uint32(
 /* id 7, wireType 2 =*/
 58
 ).fork();
 for (var i = 0; i < message.int64Data.length; ++i)
 writer.int64(message.int64Data[i]);
 writer.ldelim();
 }
 if (message.name != null && Object.hasOwnProperty.call(message, "name"))
 writer.uint32(
 /* id 8, wireType 2 =*/
 66
 ).string(message.name);
 if (message.rawData != null && Object.hasOwnProperty.call(message, "rawData"))
 writer.uint32(
 /* id 9, wireType 2 =*/
 74
 ).bytes(message.rawData);
 if (message.doubleData != null && message.doubleData.length) {
 writer.uint32(
 /* id 10, wireType 2 =*/
 82
 ).fork();
 for (var i = 0; i < message.doubleData.length; ++i)
 writer.double(message.doubleData[i]);
 writer.ldelim();
 }
 if (message.uint64Data != null && message.uint64Data.length) {
 writer.uint32(
 /* id 11, wireType 2 =*/
 90
 ).fork();
 for (var i = 0; i < message.uint64Data.length; ++i)
 writer.uint64(message.uint64Data[i]);
 writer.ldelim();
 }
 if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
 writer.uint32(
 /* id 12, wireType 2 =*/
 98
 ).string(message.docString);
 if (message.externalData != null && message.externalData.length)
 for (var i = 0; i < message.externalData.length; ++i)
 $root.onnx.StringStringEntryProto.encode(
 message.externalData[i],
 writer.uint32(
 /* id 13, wireType 2 =*/
 106
 ).fork()
 ).ldelim();
 if (message.dataLocation != null && Object.hasOwnProperty.call(message, "dataLocation"))
 writer.uint32(
 /* id 14, wireType 0 =*/
 112
 ).int32(message.dataLocation);
 return writer;
 };
 TensorProto.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 TensorProto.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.TensorProto();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 if (!(message.dims && message.dims.length))
 message.dims = [];
 if ((tag & 7) === 2) {
 var end2 = reader.uint32() + reader.pos;
 while (reader.pos < end2)
 message.dims.push(reader.int64());
 } else
 message.dims.push(reader.int64());
 break;
 }
 case 2: {
 message.dataType = reader.int32();
 break;
 }
 case 3: {
 message.segment = $root.onnx.TensorProto.Segment.decode(reader, reader.uint32());
 break;
 }
 case 4: {
 if (!(message.floatData && message.floatData.length))
 message.floatData = [];
 if ((tag & 7) === 2) {
 var end2 = reader.uint32() + reader.pos;
 while (reader.pos < end2)
 message.floatData.push(reader.float());
 } else
 message.floatData.push(reader.float());
 break;
 }
 case 5: {
 if (!(message.int32Data && message.int32Data.length))
 message.int32Data = [];
 if ((tag & 7) === 2) {
 var end2 = reader.uint32() + reader.pos;
 while (reader.pos < end2)
 message.int32Data.push(reader.int32());
 } else
 message.int32Data.push(reader.int32());
 break;
 }
 case 6: {
 if (!(message.stringData && message.stringData.length))
 message.stringData = [];
 message.stringData.push(reader.bytes());
 break;
 }
 case 7: {
 if (!(message.int64Data && message.int64Data.length))
 message.int64Data = [];
 if ((tag & 7) === 2) {
 var end2 = reader.uint32() + reader.pos;
 while (reader.pos < end2)
 message.int64Data.push(reader.int64());
 } else
 message.int64Data.push(reader.int64());
 break;
 }
 case 8: {
 message.name = reader.string();
 break;
 }
 case 12: {
 message.docString = reader.string();
 break;
 }
 case 9: {
 message.rawData = reader.bytes();
 break;
 }
 case 13: {
 if (!(message.externalData && message.externalData.length))
 message.externalData = [];
 message.externalData.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));
 break;
 }
 case 14: {
 message.dataLocation = reader.int32();
 break;
 }
 case 10: {
 if (!(message.doubleData && message.doubleData.length))
 message.doubleData = [];
 if ((tag & 7) === 2) {
 var end2 = reader.uint32() + reader.pos;
 while (reader.pos < end2)
 message.doubleData.push(reader.double());
 } else
 message.doubleData.push(reader.double());
 break;
 }
 case 11: {
 if (!(message.uint64Data && message.uint64Data.length))
 message.uint64Data = [];
 if ((tag & 7) === 2) {
 var end2 = reader.uint32() + reader.pos;
 while (reader.pos < end2)
 message.uint64Data.push(reader.uint64());
 } else
 message.uint64Data.push(reader.uint64());
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 TensorProto.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 TensorProto.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.dims != null && message.hasOwnProperty("dims")) {
 if (!Array.isArray(message.dims))
 return "dims: array expected";
 for (var i = 0; i < message.dims.length; ++i)
 if (!$util.isInteger(message.dims[i]) && !(message.dims[i] && $util.isInteger(message.dims[i].low) && $util.isInteger(message.dims[i].high)))
 return "dims: integer|Long[] expected";
 }
 if (message.dataType != null && message.hasOwnProperty("dataType")) {
 if (!$util.isInteger(message.dataType))
 return "dataType: integer expected";
 }
 if (message.segment != null && message.hasOwnProperty("segment")) {
 var error = $root.onnx.TensorProto.Segment.verify(message.segment);
 if (error)
 return "segment." + error;
 }
 if (message.floatData != null && message.hasOwnProperty("floatData")) {
 if (!Array.isArray(message.floatData))
 return "floatData: array expected";
 for (var i = 0; i < message.floatData.length; ++i)
 if (typeof message.floatData[i] !== "number")
 return "floatData: number[] expected";
 }
 if (message.int32Data != null && message.hasOwnProperty("int32Data")) {
 if (!Array.isArray(message.int32Data))
 return "int32Data: array expected";
 for (var i = 0; i < message.int32Data.length; ++i)
 if (!$util.isInteger(message.int32Data[i]))
 return "int32Data: integer[] expected";
 }
 if (message.stringData != null && message.hasOwnProperty("stringData")) {
 if (!Array.isArray(message.stringData))
 return "stringData: array expected";
 for (var i = 0; i < message.stringData.length; ++i)
 if (!(message.stringData[i] && typeof message.stringData[i].length === "number" || $util.isString(message.stringData[i])))
 return "stringData: buffer[] expected";
 }
 if (message.int64Data != null && message.hasOwnProperty("int64Data")) {
 if (!Array.isArray(message.int64Data))
 return "int64Data: array expected";
 for (var i = 0; i < message.int64Data.length; ++i)
 if (!$util.isInteger(message.int64Data[i]) && !(message.int64Data[i] && $util.isInteger(message.int64Data[i].low) && $util.isInteger(message.int64Data[i].high)))
 return "int64Data: integer|Long[] expected";
 }
 if (message.name != null && message.hasOwnProperty("name")) {
 if (!$util.isString(message.name))
 return "name: string expected";
 }
 if (message.docString != null && message.hasOwnProperty("docString")) {
 if (!$util.isString(message.docString))
 return "docString: string expected";
 }
 if (message.rawData != null && message.hasOwnProperty("rawData")) {
 if (!(message.rawData && typeof message.rawData.length === "number" || $util.isString(message.rawData)))
 return "rawData: buffer expected";
 }
 if (message.externalData != null && message.hasOwnProperty("externalData")) {
 if (!Array.isArray(message.externalData))
 return "externalData: array expected";
 for (var i = 0; i < message.externalData.length; ++i) {
 var error = $root.onnx.StringStringEntryProto.verify(message.externalData[i]);
 if (error)
 return "externalData." + error;
 }
 }
 if (message.dataLocation != null && message.hasOwnProperty("dataLocation"))
 switch (message.dataLocation) {
 default:
 return "dataLocation: enum value expected";
 case 0:
 case 1:
 break;
 }
 if (message.doubleData != null && message.hasOwnProperty("doubleData")) {
 if (!Array.isArray(message.doubleData))
 return "doubleData: array expected";
 for (var i = 0; i < message.doubleData.length; ++i)
 if (typeof message.doubleData[i] !== "number")
 return "doubleData: number[] expected";
 }
 if (message.uint64Data != null && message.hasOwnProperty("uint64Data")) {
 if (!Array.isArray(message.uint64Data))
 return "uint64Data: array expected";
 for (var i = 0; i < message.uint64Data.length; ++i)
 if (!$util.isInteger(message.uint64Data[i]) && !(message.uint64Data[i] && $util.isInteger(message.uint64Data[i].low) && $util.isInteger(message.uint64Data[i].high)))
 return "uint64Data: integer|Long[] expected";
 }
 return null;
 };
 TensorProto.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.TensorProto)
 return object;
 var message = new $root.onnx.TensorProto();
 if (object.dims) {
 if (!Array.isArray(object.dims))
 throw TypeError(".onnx.TensorProto.dims: array expected");
 message.dims = [];
 for (var i = 0; i < object.dims.length; ++i)
 if ($util.Long)
 (message.dims[i] = $util.Long.fromValue(object.dims[i])).unsigned = false;
 else if (typeof object.dims[i] === "string")
 message.dims[i] = parseInt(object.dims[i], 10);
 else if (typeof object.dims[i] === "number")
 message.dims[i] = object.dims[i];
 else if (typeof object.dims[i] === "object")
 message.dims[i] = new $util.LongBits(object.dims[i].low >>> 0, object.dims[i].high >>> 0).toNumber();
 }
 if (object.dataType != null)
 message.dataType = object.dataType | 0;
 if (object.segment != null) {
 if (typeof object.segment !== "object")
 throw TypeError(".onnx.TensorProto.segment: object expected");
 message.segment = $root.onnx.TensorProto.Segment.fromObject(object.segment);
 }
 if (object.floatData) {
 if (!Array.isArray(object.floatData))
 throw TypeError(".onnx.TensorProto.floatData: array expected");
 message.floatData = [];
 for (var i = 0; i < object.floatData.length; ++i)
 message.floatData[i] = Number(object.floatData[i]);
 }
 if (object.int32Data) {
 if (!Array.isArray(object.int32Data))
 throw TypeError(".onnx.TensorProto.int32Data: array expected");
 message.int32Data = [];
 for (var i = 0; i < object.int32Data.length; ++i)
 message.int32Data[i] = object.int32Data[i] | 0;
 }
 if (object.stringData) {
 if (!Array.isArray(object.stringData))
 throw TypeError(".onnx.TensorProto.stringData: array expected");
 message.stringData = [];
 for (var i = 0; i < object.stringData.length; ++i)
 if (typeof object.stringData[i] === "string")
 $util.base64.decode(
 object.stringData[i],
 message.stringData[i] = $util.newBuffer($util.base64.length(object.stringData[i])),
 0
 );
 else if (object.stringData[i].length >= 0)
 message.stringData[i] = object.stringData[i];
 }
 if (object.int64Data) {
 if (!Array.isArray(object.int64Data))
 throw TypeError(".onnx.TensorProto.int64Data: array expected");
 message.int64Data = [];
 for (var i = 0; i < object.int64Data.length; ++i)
 if ($util.Long)
 (message.int64Data[i] = $util.Long.fromValue(object.int64Data[i])).unsigned = false;
 else if (typeof object.int64Data[i] === "string")
 message.int64Data[i] = parseInt(object.int64Data[i], 10);
 else if (typeof object.int64Data[i] === "number")
 message.int64Data[i] = object.int64Data[i];
 else if (typeof object.int64Data[i] === "object")
 message.int64Data[i] = new $util.LongBits(
 object.int64Data[i].low >>> 0,
 object.int64Data[i].high >>> 0
 ).toNumber();
 }
 if (object.name != null)
 message.name = String(object.name);
 if (object.docString != null)
 message.docString = String(object.docString);
 if (object.rawData != null) {
 if (typeof object.rawData === "string")
 $util.base64.decode(
 object.rawData,
 message.rawData = $util.newBuffer($util.base64.length(object.rawData)),
 0
 );
 else if (object.rawData.length >= 0)
 message.rawData = object.rawData;
 }
 if (object.externalData) {
 if (!Array.isArray(object.externalData))
 throw TypeError(".onnx.TensorProto.externalData: array expected");
 message.externalData = [];
 for (var i = 0; i < object.externalData.length; ++i) {
 if (typeof object.externalData[i] !== "object")
 throw TypeError(".onnx.TensorProto.externalData: object expected");
 message.externalData[i] = $root.onnx.StringStringEntryProto.fromObject(object.externalData[i]);
 }
 }
 switch (object.dataLocation) {
 default:
 if (typeof object.dataLocation === "number") {
 message.dataLocation = object.dataLocation;
 break;
 }
 break;
 case "DEFAULT":
 case 0:
 message.dataLocation = 0;
 break;
 case "EXTERNAL":
 case 1:
 message.dataLocation = 1;
 break;
 }
 if (object.doubleData) {
 if (!Array.isArray(object.doubleData))
 throw TypeError(".onnx.TensorProto.doubleData: array expected");
 message.doubleData = [];
 for (var i = 0; i < object.doubleData.length; ++i)
 message.doubleData[i] = Number(object.doubleData[i]);
 }
 if (object.uint64Data) {
 if (!Array.isArray(object.uint64Data))
 throw TypeError(".onnx.TensorProto.uint64Data: array expected");
 message.uint64Data = [];
 for (var i = 0; i < object.uint64Data.length; ++i)
 if ($util.Long)
 (message.uint64Data[i] = $util.Long.fromValue(object.uint64Data[i])).unsigned = true;
 else if (typeof object.uint64Data[i] === "string")
 message.uint64Data[i] = parseInt(object.uint64Data[i], 10);
 else if (typeof object.uint64Data[i] === "number")
 message.uint64Data[i] = object.uint64Data[i];
 else if (typeof object.uint64Data[i] === "object")
 message.uint64Data[i] = new $util.LongBits(
 object.uint64Data[i].low >>> 0,
 object.uint64Data[i].high >>> 0
 ).toNumber(true);
 }
 return message;
 };
 TensorProto.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.arrays || options.defaults) {
 object.dims = [];
 object.floatData = [];
 object.int32Data = [];
 object.stringData = [];
 object.int64Data = [];
 object.doubleData = [];
 object.uint64Data = [];
 object.externalData = [];
 }
 if (options.defaults) {
 object.dataType = 0;
 object.segment = null;
 object.name = "";
 if (options.bytes === String)
 object.rawData = "";
 else {
 object.rawData = [];
 if (options.bytes !== Array)
 object.rawData = $util.newBuffer(object.rawData);
 }
 object.docString = "";
 object.dataLocation = options.enums === String ? "DEFAULT" : 0;
 }
 if (message.dims && message.dims.length) {
 object.dims = [];
 for (var j = 0; j < message.dims.length; ++j)
 if (typeof message.dims[j] === "number")
 object.dims[j] = options.longs === String ? String(message.dims[j]) : message.dims[j];
 else
 object.dims[j] = options.longs === String ? $util.Long.prototype.toString.call(message.dims[j]) : options.longs === Number ? new $util.LongBits(message.dims[j].low >>> 0, message.dims[j].high >>> 0).toNumber() : message.dims[j];
 }
 if (message.dataType != null && message.hasOwnProperty("dataType"))
 object.dataType = message.dataType;
 if (message.segment != null && message.hasOwnProperty("segment"))
 object.segment = $root.onnx.TensorProto.Segment.toObject(message.segment, options);
 if (message.floatData && message.floatData.length) {
 object.floatData = [];
 for (var j = 0; j < message.floatData.length; ++j)
 object.floatData[j] = options.json && !isFinite(message.floatData[j]) ? String(message.floatData[j]) : message.floatData[j];
 }
 if (message.int32Data && message.int32Data.length) {
 object.int32Data = [];
 for (var j = 0; j < message.int32Data.length; ++j)
 object.int32Data[j] = message.int32Data[j];
 }
 if (message.stringData && message.stringData.length) {
 object.stringData = [];
 for (var j = 0; j < message.stringData.length; ++j)
 object.stringData[j] = options.bytes === String ? $util.base64.encode(message.stringData[j], 0, message.stringData[j].length) : options.bytes === Array ? Array.prototype.slice.call(message.stringData[j]) : message.stringData[j];
 }
 if (message.int64Data && message.int64Data.length) {
 object.int64Data = [];
 for (var j = 0; j < message.int64Data.length; ++j)
 if (typeof message.int64Data[j] === "number")
 object.int64Data[j] = options.longs === String ? String(message.int64Data[j]) : message.int64Data[j];
 else
 object.int64Data[j] = options.longs === String ? $util.Long.prototype.toString.call(message.int64Data[j]) : options.longs === Number ? new $util.LongBits(message.int64Data[j].low >>> 0, message.int64Data[j].high >>> 0).toNumber() : message.int64Data[j];
 }
 if (message.name != null && message.hasOwnProperty("name"))
 object.name = message.name;
 if (message.rawData != null && message.hasOwnProperty("rawData"))
 object.rawData = options.bytes === String ? $util.base64.encode(message.rawData, 0, message.rawData.length) : options.bytes === Array ? Array.prototype.slice.call(message.rawData) : message.rawData;
 if (message.doubleData && message.doubleData.length) {
 object.doubleData = [];
 for (var j = 0; j < message.doubleData.length; ++j)
 object.doubleData[j] = options.json && !isFinite(message.doubleData[j]) ? String(message.doubleData[j]) : message.doubleData[j];
 }
 if (message.uint64Data && message.uint64Data.length) {
 object.uint64Data = [];
 for (var j = 0; j < message.uint64Data.length; ++j)
 if (typeof message.uint64Data[j] === "number")
 object.uint64Data[j] = options.longs === String ? String(message.uint64Data[j]) : message.uint64Data[j];
 else
 object.uint64Data[j] = options.longs === String ? $util.Long.prototype.toString.call(message.uint64Data[j]) : options.longs === Number ? new $util.LongBits(message.uint64Data[j].low >>> 0, message.uint64Data[j].high >>> 0).toNumber(true) : message.uint64Data[j];
 }
 if (message.docString != null && message.hasOwnProperty("docString"))
 object.docString = message.docString;
 if (message.externalData && message.externalData.length) {
 object.externalData = [];
 for (var j = 0; j < message.externalData.length; ++j)
 object.externalData[j] = $root.onnx.StringStringEntryProto.toObject(message.externalData[j], options);
 }
 if (message.dataLocation != null && message.hasOwnProperty("dataLocation"))
 object.dataLocation = options.enums === String ? $root.onnx.TensorProto.DataLocation[message.dataLocation] === void 0 ? message.dataLocation : $root.onnx.TensorProto.DataLocation[message.dataLocation] : message.dataLocation;
 return object;
 };
 TensorProto.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 TensorProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.TensorProto";
 };
 TensorProto.DataType = function() {
 var valuesById = {}, values = Object.create(valuesById);
 values[valuesById[0] = "UNDEFINED"] = 0;
 values[valuesById[1] = "FLOAT"] = 1;
 values[valuesById[2] = "UINT8"] = 2;
 values[valuesById[3] = "INT8"] = 3;
 values[valuesById[4] = "UINT16"] = 4;
 values[valuesById[5] = "INT16"] = 5;
 values[valuesById[6] = "INT32"] = 6;
 values[valuesById[7] = "INT64"] = 7;
 values[valuesById[8] = "STRING"] = 8;
 values[valuesById[9] = "BOOL"] = 9;
 values[valuesById[10] = "FLOAT16"] = 10;
 values[valuesById[11] = "DOUBLE"] = 11;
 values[valuesById[12] = "UINT32"] = 12;
 values[valuesById[13] = "UINT64"] = 13;
 values[valuesById[14] = "COMPLEX64"] = 14;
 values[valuesById[15] = "COMPLEX128"] = 15;
 values[valuesById[16] = "BFLOAT16"] = 16;
 values[valuesById[17] = "FLOAT8E4M3FN"] = 17;
 values[valuesById[18] = "FLOAT8E4M3FNUZ"] = 18;
 values[valuesById[19] = "FLOAT8E5M2"] = 19;
 values[valuesById[20] = "FLOAT8E5M2FNUZ"] = 20;
 return values;
 }();
 TensorProto.Segment = function() {
 function Segment(properties) {
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 Segment.prototype.begin = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
 Segment.prototype.end = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
 Segment.create = function create(properties) {
 return new Segment(properties);
 };
 Segment.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.begin != null && Object.hasOwnProperty.call(message, "begin"))
 writer.uint32(
 /* id 1, wireType 0 =*/
 8
 ).int64(message.begin);
 if (message.end != null && Object.hasOwnProperty.call(message, "end"))
 writer.uint32(
 /* id 2, wireType 0 =*/
 16
 ).int64(message.end);
 return writer;
 };
 Segment.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 Segment.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.TensorProto.Segment();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 message.begin = reader.int64();
 break;
 }
 case 2: {
 message.end = reader.int64();
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 Segment.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 Segment.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.begin != null && message.hasOwnProperty("begin")) {
 if (!$util.isInteger(message.begin) && !(message.begin && $util.isInteger(message.begin.low) && $util.isInteger(message.begin.high)))
 return "begin: integer|Long expected";
 }
 if (message.end != null && message.hasOwnProperty("end")) {
 if (!$util.isInteger(message.end) && !(message.end && $util.isInteger(message.end.low) && $util.isInteger(message.end.high)))
 return "end: integer|Long expected";
 }
 return null;
 };
 Segment.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.TensorProto.Segment)
 return object;
 var message = new $root.onnx.TensorProto.Segment();
 if (object.begin != null) {
 if ($util.Long)
 (message.begin = $util.Long.fromValue(object.begin)).unsigned = false;
 else if (typeof object.begin === "string")
 message.begin = parseInt(object.begin, 10);
 else if (typeof object.begin === "number")
 message.begin = object.begin;
 else if (typeof object.begin === "object")
 message.begin = new $util.LongBits(object.begin.low >>> 0, object.begin.high >>> 0).toNumber();
 }
 if (object.end != null) {
 if ($util.Long)
 (message.end = $util.Long.fromValue(object.end)).unsigned = false;
 else if (typeof object.end === "string")
 message.end = parseInt(object.end, 10);
 else if (typeof object.end === "number")
 message.end = object.end;
 else if (typeof object.end === "object")
 message.end = new $util.LongBits(object.end.low >>> 0, object.end.high >>> 0).toNumber();
 }
 return message;
 };
 Segment.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.defaults) {
 if ($util.Long) {
 var long = new $util.Long(0, 0, false);
 object.begin = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
 } else
 object.begin = options.longs === String ? "0" : 0;
 if ($util.Long) {
 var long = new $util.Long(0, 0, false);
 object.end = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
 } else
 object.end = options.longs === String ? "0" : 0;
 }
 if (message.begin != null && message.hasOwnProperty("begin"))
 if (typeof message.begin === "number")
 object.begin = options.longs === String ? String(message.begin) : message.begin;
 else
 object.begin = options.longs === String ? $util.Long.prototype.toString.call(message.begin) : options.longs === Number ? new $util.LongBits(message.begin.low >>> 0, message.begin.high >>> 0).toNumber() : message.begin;
 if (message.end != null && message.hasOwnProperty("end"))
 if (typeof message.end === "number")
 object.end = options.longs === String ? String(message.end) : message.end;
 else
 object.end = options.longs === String ? $util.Long.prototype.toString.call(message.end) : options.longs === Number ? new $util.LongBits(message.end.low >>> 0, message.end.high >>> 0).toNumber() : message.end;
 return object;
 };
 Segment.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 Segment.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.TensorProto.Segment";
 };
 return Segment;
 }();
 TensorProto.DataLocation = function() {
 var valuesById = {}, values = Object.create(valuesById);
 values[valuesById[0] = "DEFAULT"] = 0;
 values[valuesById[1] = "EXTERNAL"] = 1;
 return values;
 }();
 return TensorProto;
 }();
 onnx6.SparseTensorProto = function() {
 function SparseTensorProto(properties) {
 this.dims = [];
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 SparseTensorProto.prototype.values = null;
 SparseTensorProto.prototype.indices = null;
 SparseTensorProto.prototype.dims = $util.emptyArray;
 SparseTensorProto.create = function create(properties) {
 return new SparseTensorProto(properties);
 };
 SparseTensorProto.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.values != null && Object.hasOwnProperty.call(message, "values"))
 $root.onnx.TensorProto.encode(message.values, writer.uint32(
 /* id 1, wireType 2 =*/
 10
 ).fork()).ldelim();
 if (message.indices != null && Object.hasOwnProperty.call(message, "indices"))
 $root.onnx.TensorProto.encode(message.indices, writer.uint32(
 /* id 2, wireType 2 =*/
 18
 ).fork()).ldelim();
 if (message.dims != null && message.dims.length) {
 writer.uint32(
 /* id 3, wireType 2 =*/
 26
 ).fork();
 for (var i = 0; i < message.dims.length; ++i)
 writer.int64(message.dims[i]);
 writer.ldelim();
 }
 return writer;
 };
 SparseTensorProto.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 SparseTensorProto.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.SparseTensorProto();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 message.values = $root.onnx.TensorProto.decode(reader, reader.uint32());
 break;
 }
 case 2: {
 message.indices = $root.onnx.TensorProto.decode(reader, reader.uint32());
 break;
 }
 case 3: {
 if (!(message.dims && message.dims.length))
 message.dims = [];
 if ((tag & 7) === 2) {
 var end2 = reader.uint32() + reader.pos;
 while (reader.pos < end2)
 message.dims.push(reader.int64());
 } else
 message.dims.push(reader.int64());
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 SparseTensorProto.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 SparseTensorProto.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.values != null && message.hasOwnProperty("values")) {
 var error = $root.onnx.TensorProto.verify(message.values);
 if (error)
 return "values." + error;
 }
 if (message.indices != null && message.hasOwnProperty("indices")) {
 var error = $root.onnx.TensorProto.verify(message.indices);
 if (error)
 return "indices." + error;
 }
 if (message.dims != null && message.hasOwnProperty("dims")) {
 if (!Array.isArray(message.dims))
 return "dims: array expected";
 for (var i = 0; i < message.dims.length; ++i)
 if (!$util.isInteger(message.dims[i]) && !(message.dims[i] && $util.isInteger(message.dims[i].low) && $util.isInteger(message.dims[i].high)))
 return "dims: integer|Long[] expected";
 }
 return null;
 };
 SparseTensorProto.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.SparseTensorProto)
 return object;
 var message = new $root.onnx.SparseTensorProto();
 if (object.values != null) {
 if (typeof object.values !== "object")
 throw TypeError(".onnx.SparseTensorProto.values: object expected");
 message.values = $root.onnx.TensorProto.fromObject(object.values);
 }
 if (object.indices != null) {
 if (typeof object.indices !== "object")
 throw TypeError(".onnx.SparseTensorProto.indices: object expected");
 message.indices = $root.onnx.TensorProto.fromObject(object.indices);
 }
 if (object.dims) {
 if (!Array.isArray(object.dims))
 throw TypeError(".onnx.SparseTensorProto.dims: array expected");
 message.dims = [];
 for (var i = 0; i < object.dims.length; ++i)
 if ($util.Long)
 (message.dims[i] = $util.Long.fromValue(object.dims[i])).unsigned = false;
 else if (typeof object.dims[i] === "string")
 message.dims[i] = parseInt(object.dims[i], 10);
 else if (typeof object.dims[i] === "number")
 message.dims[i] = object.dims[i];
 else if (typeof object.dims[i] === "object")
 message.dims[i] = new $util.LongBits(object.dims[i].low >>> 0, object.dims[i].high >>> 0).toNumber();
 }
 return message;
 };
 SparseTensorProto.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.arrays || options.defaults)
 object.dims = [];
 if (options.defaults) {
 object.values = null;
 object.indices = null;
 }
 if (message.values != null && message.hasOwnProperty("values"))
 object.values = $root.onnx.TensorProto.toObject(message.values, options);
 if (message.indices != null && message.hasOwnProperty("indices"))
 object.indices = $root.onnx.TensorProto.toObject(message.indices, options);
 if (message.dims && message.dims.length) {
 object.dims = [];
 for (var j = 0; j < message.dims.length; ++j)
 if (typeof message.dims[j] === "number")
 object.dims[j] = options.longs === String ? String(message.dims[j]) : message.dims[j];
 else
 object.dims[j] = options.longs === String ? $util.Long.prototype.toString.call(message.dims[j]) : options.longs === Number ? new $util.LongBits(message.dims[j].low >>> 0, message.dims[j].high >>> 0).toNumber() : message.dims[j];
 }
 return object;
 };
 SparseTensorProto.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 SparseTensorProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.SparseTensorProto";
 };
 return SparseTensorProto;
 }();
 onnx6.TensorShapeProto = function() {
 function TensorShapeProto(properties) {
 this.dim = [];
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 TensorShapeProto.prototype.dim = $util.emptyArray;
 TensorShapeProto.create = function create(properties) {
 return new TensorShapeProto(properties);
 };
 TensorShapeProto.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.dim != null && message.dim.length)
 for (var i = 0; i < message.dim.length; ++i)
 $root.onnx.TensorShapeProto.Dimension.encode(
 message.dim[i],
 writer.uint32(
 /* id 1, wireType 2 =*/
 10
 ).fork()
 ).ldelim();
 return writer;
 };
 TensorShapeProto.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 TensorShapeProto.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.TensorShapeProto();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 if (!(message.dim && message.dim.length))
 message.dim = [];
 message.dim.push($root.onnx.TensorShapeProto.Dimension.decode(reader, reader.uint32()));
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 TensorShapeProto.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 TensorShapeProto.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.dim != null && message.hasOwnProperty("dim")) {
 if (!Array.isArray(message.dim))
 return "dim: array expected";
 for (var i = 0; i < message.dim.length; ++i) {
 var error = $root.onnx.TensorShapeProto.Dimension.verify(message.dim[i]);
 if (error)
 return "dim." + error;
 }
 }
 return null;
 };
 TensorShapeProto.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.TensorShapeProto)
 return object;
 var message = new $root.onnx.TensorShapeProto();
 if (object.dim) {
 if (!Array.isArray(object.dim))
 throw TypeError(".onnx.TensorShapeProto.dim: array expected");
 message.dim = [];
 for (var i = 0; i < object.dim.length; ++i) {
 if (typeof object.dim[i] !== "object")
 throw TypeError(".onnx.TensorShapeProto.dim: object expected");
 message.dim[i] = $root.onnx.TensorShapeProto.Dimension.fromObject(object.dim[i]);
 }
 }
 return message;
 };
 TensorShapeProto.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.arrays || options.defaults)
 object.dim = [];
 if (message.dim && message.dim.length) {
 object.dim = [];
 for (var j = 0; j < message.dim.length; ++j)
 object.dim[j] = $root.onnx.TensorShapeProto.Dimension.toObject(message.dim[j], options);
 }
 return object;
 };
 TensorShapeProto.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 TensorShapeProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.TensorShapeProto";
 };
 TensorShapeProto.Dimension = function() {
 function Dimension(properties) {
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 Dimension.prototype.dimValue = null;
 Dimension.prototype.dimParam = null;
 Dimension.prototype.denotation = "";
 var $oneOfFields;
 Object.defineProperty(Dimension.prototype, "value", {
 get: $util.oneOfGetter($oneOfFields = ["dimValue", "dimParam"]),
 set: $util.oneOfSetter($oneOfFields)
 });
 Dimension.create = function create(properties) {
 return new Dimension(properties);
 };
 Dimension.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.dimValue != null && Object.hasOwnProperty.call(message, "dimValue"))
 writer.uint32(
 /* id 1, wireType 0 =*/
 8
 ).int64(message.dimValue);
 if (message.dimParam != null && Object.hasOwnProperty.call(message, "dimParam"))
 writer.uint32(
 /* id 2, wireType 2 =*/
 18
 ).string(message.dimParam);
 if (message.denotation != null && Object.hasOwnProperty.call(message, "denotation"))
 writer.uint32(
 /* id 3, wireType 2 =*/
 26
 ).string(message.denotation);
 return writer;
 };
 Dimension.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 Dimension.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.TensorShapeProto.Dimension();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 message.dimValue = reader.int64();
 break;
 }
 case 2: {
 message.dimParam = reader.string();
 break;
 }
 case 3: {
 message.denotation = reader.string();
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 Dimension.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 Dimension.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 var properties = {};
 if (message.dimValue != null && message.hasOwnProperty("dimValue")) {
 properties.value = 1;
 if (!$util.isInteger(message.dimValue) && !(message.dimValue && $util.isInteger(message.dimValue.low) && $util.isInteger(message.dimValue.high)))
 return "dimValue: integer|Long expected";
 }
 if (message.dimParam != null && message.hasOwnProperty("dimParam")) {
 if (properties.value === 1)
 return "value: multiple values";
 properties.value = 1;
 if (!$util.isString(message.dimParam))
 return "dimParam: string expected";
 }
 if (message.denotation != null && message.hasOwnProperty("denotation")) {
 if (!$util.isString(message.denotation))
 return "denotation: string expected";
 }
 return null;
 };
 Dimension.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.TensorShapeProto.Dimension)
 return object;
 var message = new $root.onnx.TensorShapeProto.Dimension();
 if (object.dimValue != null) {
 if ($util.Long)
 (message.dimValue = $util.Long.fromValue(object.dimValue)).unsigned = false;
 else if (typeof object.dimValue === "string")
 message.dimValue = parseInt(object.dimValue, 10);
 else if (typeof object.dimValue === "number")
 message.dimValue = object.dimValue;
 else if (typeof object.dimValue === "object")
 message.dimValue = new $util.LongBits(object.dimValue.low >>> 0, object.dimValue.high >>> 0).toNumber();
 }
 if (object.dimParam != null)
 message.dimParam = String(object.dimParam);
 if (object.denotation != null)
 message.denotation = String(object.denotation);
 return message;
 };
 Dimension.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.defaults)
 object.denotation = "";
 if (message.dimValue != null && message.hasOwnProperty("dimValue")) {
 if (typeof message.dimValue === "number")
 object.dimValue = options.longs === String ? String(message.dimValue) : message.dimValue;
 else
 object.dimValue = options.longs === String ? $util.Long.prototype.toString.call(message.dimValue) : options.longs === Number ? new $util.LongBits(message.dimValue.low >>> 0, message.dimValue.high >>> 0).toNumber() : message.dimValue;
 if (options.oneofs)
 object.value = "dimValue";
 }
 if (message.dimParam != null && message.hasOwnProperty("dimParam")) {
 object.dimParam = message.dimParam;
 if (options.oneofs)
 object.value = "dimParam";
 }
 if (message.denotation != null && message.hasOwnProperty("denotation"))
 object.denotation = message.denotation;
 return object;
 };
 Dimension.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 Dimension.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.TensorShapeProto.Dimension";
 };
 return Dimension;
 }();
 return TensorShapeProto;
 }();
 onnx6.TypeProto = function() {
 function TypeProto(properties) {
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 TypeProto.prototype.tensorType = null;
 TypeProto.prototype.sequenceType = null;
 TypeProto.prototype.mapType = null;
 TypeProto.prototype.optionalType = null;
 TypeProto.prototype.sparseTensorType = null;
 TypeProto.prototype.denotation = "";
 var $oneOfFields;
 Object.defineProperty(TypeProto.prototype, "value", {
 get: $util.oneOfGetter(
 $oneOfFields = ["tensorType", "sequenceType", "mapType", "optionalType", "sparseTensorType"]
 ),
 set: $util.oneOfSetter($oneOfFields)
 });
 TypeProto.create = function create(properties) {
 return new TypeProto(properties);
 };
 TypeProto.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.tensorType != null && Object.hasOwnProperty.call(message, "tensorType"))
 $root.onnx.TypeProto.Tensor.encode(
 message.tensorType,
 writer.uint32(
 /* id 1, wireType 2 =*/
 10
 ).fork()
 ).ldelim();
 if (message.sequenceType != null && Object.hasOwnProperty.call(message, "sequenceType"))
 $root.onnx.TypeProto.Sequence.encode(
 message.sequenceType,
 writer.uint32(
 /* id 4, wireType 2 =*/
 34
 ).fork()
 ).ldelim();
 if (message.mapType != null && Object.hasOwnProperty.call(message, "mapType"))
 $root.onnx.TypeProto.Map.encode(message.mapType, writer.uint32(
 /* id 5, wireType 2 =*/
 42
 ).fork()).ldelim();
 if (message.denotation != null && Object.hasOwnProperty.call(message, "denotation"))
 writer.uint32(
 /* id 6, wireType 2 =*/
 50
 ).string(message.denotation);
 if (message.sparseTensorType != null && Object.hasOwnProperty.call(message, "sparseTensorType"))
 $root.onnx.TypeProto.SparseTensor.encode(
 message.sparseTensorType,
 writer.uint32(
 /* id 8, wireType 2 =*/
 66
 ).fork()
 ).ldelim();
 if (message.optionalType != null && Object.hasOwnProperty.call(message, "optionalType"))
 $root.onnx.TypeProto.Optional.encode(
 message.optionalType,
 writer.uint32(
 /* id 9, wireType 2 =*/
 74
 ).fork()
 ).ldelim();
 return writer;
 };
 TypeProto.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 TypeProto.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.TypeProto();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 message.tensorType = $root.onnx.TypeProto.Tensor.decode(reader, reader.uint32());
 break;
 }
 case 4: {
 message.sequenceType = $root.onnx.TypeProto.Sequence.decode(reader, reader.uint32());
 break;
 }
 case 5: {
 message.mapType = $root.onnx.TypeProto.Map.decode(reader, reader.uint32());
 break;
 }
 case 9: {
 message.optionalType = $root.onnx.TypeProto.Optional.decode(reader, reader.uint32());
 break;
 }
 case 8: {
 message.sparseTensorType = $root.onnx.TypeProto.SparseTensor.decode(reader, reader.uint32());
 break;
 }
 case 6: {
 message.denotation = reader.string();
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 TypeProto.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 TypeProto.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 var properties = {};
 if (message.tensorType != null && message.hasOwnProperty("tensorType")) {
 properties.value = 1;
 {
 var error = $root.onnx.TypeProto.Tensor.verify(message.tensorType);
 if (error)
 return "tensorType." + error;
 }
 }
 if (message.sequenceType != null && message.hasOwnProperty("sequenceType")) {
 if (properties.value === 1)
 return "value: multiple values";
 properties.value = 1;
 {
 var error = $root.onnx.TypeProto.Sequence.verify(message.sequenceType);
 if (error)
 return "sequenceType." + error;
 }
 }
 if (message.mapType != null && message.hasOwnProperty("mapType")) {
 if (properties.value === 1)
 return "value: multiple values";
 properties.value = 1;
 {
 var error = $root.onnx.TypeProto.Map.verify(message.mapType);
 if (error)
 return "mapType." + error;
 }
 }
 if (message.optionalType != null && message.hasOwnProperty("optionalType")) {
 if (properties.value === 1)
 return "value: multiple values";
 properties.value = 1;
 {
 var error = $root.onnx.TypeProto.Optional.verify(message.optionalType);
 if (error)
 return "optionalType." + error;
 }
 }
 if (message.sparseTensorType != null && message.hasOwnProperty("sparseTensorType")) {
 if (properties.value === 1)
 return "value: multiple values";
 properties.value = 1;
 {
 var error = $root.onnx.TypeProto.SparseTensor.verify(message.sparseTensorType);
 if (error)
 return "sparseTensorType." + error;
 }
 }
 if (message.denotation != null && message.hasOwnProperty("denotation")) {
 if (!$util.isString(message.denotation))
 return "denotation: string expected";
 }
 return null;
 };
 TypeProto.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.TypeProto)
 return object;
 var message = new $root.onnx.TypeProto();
 if (object.tensorType != null) {
 if (typeof object.tensorType !== "object")
 throw TypeError(".onnx.TypeProto.tensorType: object expected");
 message.tensorType = $root.onnx.TypeProto.Tensor.fromObject(object.tensorType);
 }
 if (object.sequenceType != null) {
 if (typeof object.sequenceType !== "object")
 throw TypeError(".onnx.TypeProto.sequenceType: object expected");
 message.sequenceType = $root.onnx.TypeProto.Sequence.fromObject(object.sequenceType);
 }
 if (object.mapType != null) {
 if (typeof object.mapType !== "object")
 throw TypeError(".onnx.TypeProto.mapType: object expected");
 message.mapType = $root.onnx.TypeProto.Map.fromObject(object.mapType);
 }
 if (object.optionalType != null) {
 if (typeof object.optionalType !== "object")
 throw TypeError(".onnx.TypeProto.optionalType: object expected");
 message.optionalType = $root.onnx.TypeProto.Optional.fromObject(object.optionalType);
 }
 if (object.sparseTensorType != null) {
 if (typeof object.sparseTensorType !== "object")
 throw TypeError(".onnx.TypeProto.sparseTensorType: object expected");
 message.sparseTensorType = $root.onnx.TypeProto.SparseTensor.fromObject(object.sparseTensorType);
 }
 if (object.denotation != null)
 message.denotation = String(object.denotation);
 return message;
 };
 TypeProto.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.defaults)
 object.denotation = "";
 if (message.tensorType != null && message.hasOwnProperty("tensorType")) {
 object.tensorType = $root.onnx.TypeProto.Tensor.toObject(message.tensorType, options);
 if (options.oneofs)
 object.value = "tensorType";
 }
 if (message.sequenceType != null && message.hasOwnProperty("sequenceType")) {
 object.sequenceType = $root.onnx.TypeProto.Sequence.toObject(message.sequenceType, options);
 if (options.oneofs)
 object.value = "sequenceType";
 }
 if (message.mapType != null && message.hasOwnProperty("mapType")) {
 object.mapType = $root.onnx.TypeProto.Map.toObject(message.mapType, options);
 if (options.oneofs)
 object.value = "mapType";
 }
 if (message.denotation != null && message.hasOwnProperty("denotation"))
 object.denotation = message.denotation;
 if (message.sparseTensorType != null && message.hasOwnProperty("sparseTensorType")) {
 object.sparseTensorType = $root.onnx.TypeProto.SparseTensor.toObject(message.sparseTensorType, options);
 if (options.oneofs)
 object.value = "sparseTensorType";
 }
 if (message.optionalType != null && message.hasOwnProperty("optionalType")) {
 object.optionalType = $root.onnx.TypeProto.Optional.toObject(message.optionalType, options);
 if (options.oneofs)
 object.value = "optionalType";
 }
 return object;
 };
 TypeProto.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 TypeProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.TypeProto";
 };
 TypeProto.Tensor = function() {
 function Tensor4(properties) {
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 Tensor4.prototype.elemType = 0;
 Tensor4.prototype.shape = null;
 Tensor4.create = function create(properties) {
 return new Tensor4(properties);
 };
 Tensor4.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.elemType != null && Object.hasOwnProperty.call(message, "elemType"))
 writer.uint32(
 /* id 1, wireType 0 =*/
 8
 ).int32(message.elemType);
 if (message.shape != null && Object.hasOwnProperty.call(message, "shape"))
 $root.onnx.TensorShapeProto.encode(message.shape, writer.uint32(
 /* id 2, wireType 2 =*/
 18
 ).fork()).ldelim();
 return writer;
 };
 Tensor4.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 Tensor4.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.TypeProto.Tensor();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 message.elemType = reader.int32();
 break;
 }
 case 2: {
 message.shape = $root.onnx.TensorShapeProto.decode(reader, reader.uint32());
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 Tensor4.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 Tensor4.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.elemType != null && message.hasOwnProperty("elemType")) {
 if (!$util.isInteger(message.elemType))
 return "elemType: integer expected";
 }
 if (message.shape != null && message.hasOwnProperty("shape")) {
 var error = $root.onnx.TensorShapeProto.verify(message.shape);
 if (error)
 return "shape." + error;
 }
 return null;
 };
 Tensor4.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.TypeProto.Tensor)
 return object;
 var message = new $root.onnx.TypeProto.Tensor();
 if (object.elemType != null)
 message.elemType = object.elemType | 0;
 if (object.shape != null) {
 if (typeof object.shape !== "object")
 throw TypeError(".onnx.TypeProto.Tensor.shape: object expected");
 message.shape = $root.onnx.TensorShapeProto.fromObject(object.shape);
 }
 return message;
 };
 Tensor4.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.defaults) {
 object.elemType = 0;
 object.shape = null;
 }
 if (message.elemType != null && message.hasOwnProperty("elemType"))
 object.elemType = message.elemType;
 if (message.shape != null && message.hasOwnProperty("shape"))
 object.shape = $root.onnx.TensorShapeProto.toObject(message.shape, options);
 return object;
 };
 Tensor4.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 Tensor4.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.TypeProto.Tensor";
 };
 return Tensor4;
 }();
 TypeProto.Sequence = function() {
 function Sequence(properties) {
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 Sequence.prototype.elemType = null;
 Sequence.create = function create(properties) {
 return new Sequence(properties);
 };
 Sequence.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.elemType != null && Object.hasOwnProperty.call(message, "elemType"))
 $root.onnx.TypeProto.encode(message.elemType, writer.uint32(
 /* id 1, wireType 2 =*/
 10
 ).fork()).ldelim();
 return writer;
 };
 Sequence.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 Sequence.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.TypeProto.Sequence();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 message.elemType = $root.onnx.TypeProto.decode(reader, reader.uint32());
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 Sequence.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 Sequence.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.elemType != null && message.hasOwnProperty("elemType")) {
 var error = $root.onnx.TypeProto.verify(message.elemType);
 if (error)
 return "elemType." + error;
 }
 return null;
 };
 Sequence.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.TypeProto.Sequence)
 return object;
 var message = new $root.onnx.TypeProto.Sequence();
 if (object.elemType != null) {
 if (typeof object.elemType !== "object")
 throw TypeError(".onnx.TypeProto.Sequence.elemType: object expected");
 message.elemType = $root.onnx.TypeProto.fromObject(object.elemType);
 }
 return message;
 };
 Sequence.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.defaults)
 object.elemType = null;
 if (message.elemType != null && message.hasOwnProperty("elemType"))
 object.elemType = $root.onnx.TypeProto.toObject(message.elemType, options);
 return object;
 };
 Sequence.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 Sequence.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.TypeProto.Sequence";
 };
 return Sequence;
 }();
 TypeProto.Map = function() {
 function Map2(properties) {
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 Map2.prototype.keyType = 0;
 Map2.prototype.valueType = null;
 Map2.create = function create(properties) {
 return new Map2(properties);
 };
 Map2.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.keyType != null && Object.hasOwnProperty.call(message, "keyType"))
 writer.uint32(
 /* id 1, wireType 0 =*/
 8
 ).int32(message.keyType);
 if (message.valueType != null && Object.hasOwnProperty.call(message, "valueType"))
 $root.onnx.TypeProto.encode(message.valueType, writer.uint32(
 /* id 2, wireType 2 =*/
 18
 ).fork()).ldelim();
 return writer;
 };
 Map2.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 Map2.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.TypeProto.Map();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 message.keyType = reader.int32();
 break;
 }
 case 2: {
 message.valueType = $root.onnx.TypeProto.decode(reader, reader.uint32());
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 Map2.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 Map2.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.keyType != null && message.hasOwnProperty("keyType")) {
 if (!$util.isInteger(message.keyType))
 return "keyType: integer expected";
 }
 if (message.valueType != null && message.hasOwnProperty("valueType")) {
 var error = $root.onnx.TypeProto.verify(message.valueType);
 if (error)
 return "valueType." + error;
 }
 return null;
 };
 Map2.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.TypeProto.Map)
 return object;
 var message = new $root.onnx.TypeProto.Map();
 if (object.keyType != null)
 message.keyType = object.keyType | 0;
 if (object.valueType != null) {
 if (typeof object.valueType !== "object")
 throw TypeError(".onnx.TypeProto.Map.valueType: object expected");
 message.valueType = $root.onnx.TypeProto.fromObject(object.valueType);
 }
 return message;
 };
 Map2.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.defaults) {
 object.keyType = 0;
 object.valueType = null;
 }
 if (message.keyType != null && message.hasOwnProperty("keyType"))
 object.keyType = message.keyType;
 if (message.valueType != null && message.hasOwnProperty("valueType"))
 object.valueType = $root.onnx.TypeProto.toObject(message.valueType, options);
 return object;
 };
 Map2.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 Map2.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.TypeProto.Map";
 };
 return Map2;
 }();
 TypeProto.Optional = function() {
 function Optional(properties) {
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 Optional.prototype.elemType = null;
 Optional.create = function create(properties) {
 return new Optional(properties);
 };
 Optional.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.elemType != null && Object.hasOwnProperty.call(message, "elemType"))
 $root.onnx.TypeProto.encode(message.elemType, writer.uint32(
 /* id 1, wireType 2 =*/
 10
 ).fork()).ldelim();
 return writer;
 };
 Optional.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 Optional.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.TypeProto.Optional();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 message.elemType = $root.onnx.TypeProto.decode(reader, reader.uint32());
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 Optional.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 Optional.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.elemType != null && message.hasOwnProperty("elemType")) {
 var error = $root.onnx.TypeProto.verify(message.elemType);
 if (error)
 return "elemType." + error;
 }
 return null;
 };
 Optional.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.TypeProto.Optional)
 return object;
 var message = new $root.onnx.TypeProto.Optional();
 if (object.elemType != null) {
 if (typeof object.elemType !== "object")
 throw TypeError(".onnx.TypeProto.Optional.elemType: object expected");
 message.elemType = $root.onnx.TypeProto.fromObject(object.elemType);
 }
 return message;
 };
 Optional.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.defaults)
 object.elemType = null;
 if (message.elemType != null && message.hasOwnProperty("elemType"))
 object.elemType = $root.onnx.TypeProto.toObject(message.elemType, options);
 return object;
 };
 Optional.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 Optional.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.TypeProto.Optional";
 };
 return Optional;
 }();
 TypeProto.SparseTensor = function() {
 function SparseTensor(properties) {
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 SparseTensor.prototype.elemType = 0;
 SparseTensor.prototype.shape = null;
 SparseTensor.create = function create(properties) {
 return new SparseTensor(properties);
 };
 SparseTensor.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.elemType != null && Object.hasOwnProperty.call(message, "elemType"))
 writer.uint32(
 /* id 1, wireType 0 =*/
 8
 ).int32(message.elemType);
 if (message.shape != null && Object.hasOwnProperty.call(message, "shape"))
 $root.onnx.TensorShapeProto.encode(message.shape, writer.uint32(
 /* id 2, wireType 2 =*/
 18
 ).fork()).ldelim();
 return writer;
 };
 SparseTensor.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 SparseTensor.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.TypeProto.SparseTensor();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 message.elemType = reader.int32();
 break;
 }
 case 2: {
 message.shape = $root.onnx.TensorShapeProto.decode(reader, reader.uint32());
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 SparseTensor.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 SparseTensor.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.elemType != null && message.hasOwnProperty("elemType")) {
 if (!$util.isInteger(message.elemType))
 return "elemType: integer expected";
 }
 if (message.shape != null && message.hasOwnProperty("shape")) {
 var error = $root.onnx.TensorShapeProto.verify(message.shape);
 if (error)
 return "shape." + error;
 }
 return null;
 };
 SparseTensor.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.TypeProto.SparseTensor)
 return object;
 var message = new $root.onnx.TypeProto.SparseTensor();
 if (object.elemType != null)
 message.elemType = object.elemType | 0;
 if (object.shape != null) {
 if (typeof object.shape !== "object")
 throw TypeError(".onnx.TypeProto.SparseTensor.shape: object expected");
 message.shape = $root.onnx.TensorShapeProto.fromObject(object.shape);
 }
 return message;
 };
 SparseTensor.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.defaults) {
 object.elemType = 0;
 object.shape = null;
 }
 if (message.elemType != null && message.hasOwnProperty("elemType"))
 object.elemType = message.elemType;
 if (message.shape != null && message.hasOwnProperty("shape"))
 object.shape = $root.onnx.TensorShapeProto.toObject(message.shape, options);
 return object;
 };
 SparseTensor.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 SparseTensor.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.TypeProto.SparseTensor";
 };
 return SparseTensor;
 }();
 return TypeProto;
 }();
 onnx6.OperatorSetIdProto = function() {
 function OperatorSetIdProto(properties) {
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 OperatorSetIdProto.prototype.domain = "";
 OperatorSetIdProto.prototype.version = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
 OperatorSetIdProto.create = function create(properties) {
 return new OperatorSetIdProto(properties);
 };
 OperatorSetIdProto.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.domain != null && Object.hasOwnProperty.call(message, "domain"))
 writer.uint32(
 /* id 1, wireType 2 =*/
 10
 ).string(message.domain);
 if (message.version != null && Object.hasOwnProperty.call(message, "version"))
 writer.uint32(
 /* id 2, wireType 0 =*/
 16
 ).int64(message.version);
 return writer;
 };
 OperatorSetIdProto.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 OperatorSetIdProto.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.OperatorSetIdProto();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 message.domain = reader.string();
 break;
 }
 case 2: {
 message.version = reader.int64();
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 OperatorSetIdProto.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 OperatorSetIdProto.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.domain != null && message.hasOwnProperty("domain")) {
 if (!$util.isString(message.domain))
 return "domain: string expected";
 }
 if (message.version != null && message.hasOwnProperty("version")) {
 if (!$util.isInteger(message.version) && !(message.version && $util.isInteger(message.version.low) && $util.isInteger(message.version.high)))
 return "version: integer|Long expected";
 }
 return null;
 };
 OperatorSetIdProto.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.OperatorSetIdProto)
 return object;
 var message = new $root.onnx.OperatorSetIdProto();
 if (object.domain != null)
 message.domain = String(object.domain);
 if (object.version != null) {
 if ($util.Long)
 (message.version = $util.Long.fromValue(object.version)).unsigned = false;
 else if (typeof object.version === "string")
 message.version = parseInt(object.version, 10);
 else if (typeof object.version === "number")
 message.version = object.version;
 else if (typeof object.version === "object")
 message.version = new $util.LongBits(object.version.low >>> 0, object.version.high >>> 0).toNumber();
 }
 return message;
 };
 OperatorSetIdProto.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.defaults) {
 object.domain = "";
 if ($util.Long) {
 var long = new $util.Long(0, 0, false);
 object.version = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
 } else
 object.version = options.longs === String ? "0" : 0;
 }
 if (message.domain != null && message.hasOwnProperty("domain"))
 object.domain = message.domain;
 if (message.version != null && message.hasOwnProperty("version"))
 if (typeof message.version === "number")
 object.version = options.longs === String ? String(message.version) : message.version;
 else
 object.version = options.longs === String ? $util.Long.prototype.toString.call(message.version) : options.longs === Number ? new $util.LongBits(message.version.low >>> 0, message.version.high >>> 0).toNumber() : message.version;
 return object;
 };
 OperatorSetIdProto.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 OperatorSetIdProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.OperatorSetIdProto";
 };
 return OperatorSetIdProto;
 }();
 onnx6.OperatorStatus = function() {
 var valuesById = {}, values = Object.create(valuesById);
 values[valuesById[0] = "EXPERIMENTAL"] = 0;
 values[valuesById[1] = "STABLE"] = 1;
 return values;
 }();
 onnx6.FunctionProto = function() {
 function FunctionProto(properties) {
 this.input = [];
 this.output = [];
 this.attribute = [];
 this.attributeProto = [];
 this.node = [];
 this.opsetImport = [];
 if (properties) {
 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
 if (properties[keys[i]] != null)
 this[keys[i]] = properties[keys[i]];
 }
 }
 FunctionProto.prototype.name = "";
 FunctionProto.prototype.input = $util.emptyArray;
 FunctionProto.prototype.output = $util.emptyArray;
 FunctionProto.prototype.attribute = $util.emptyArray;
 FunctionProto.prototype.attributeProto = $util.emptyArray;
 FunctionProto.prototype.node = $util.emptyArray;
 FunctionProto.prototype.docString = "";
 FunctionProto.prototype.opsetImport = $util.emptyArray;
 FunctionProto.prototype.domain = "";
 FunctionProto.create = function create(properties) {
 return new FunctionProto(properties);
 };
 FunctionProto.encode = function encode(message, writer) {
 if (!writer)
 writer = $Writer.create();
 if (message.name != null && Object.hasOwnProperty.call(message, "name"))
 writer.uint32(
 /* id 1, wireType 2 =*/
 10
 ).string(message.name);
 if (message.input != null && message.input.length)
 for (var i = 0; i < message.input.length; ++i)
 writer.uint32(
 /* id 4, wireType 2 =*/
 34
 ).string(message.input[i]);
 if (message.output != null && message.output.length)
 for (var i = 0; i < message.output.length; ++i)
 writer.uint32(
 /* id 5, wireType 2 =*/
 42
 ).string(message.output[i]);
 if (message.attribute != null && message.attribute.length)
 for (var i = 0; i < message.attribute.length; ++i)
 writer.uint32(
 /* id 6, wireType 2 =*/
 50
 ).string(message.attribute[i]);
 if (message.node != null && message.node.length)
 for (var i = 0; i < message.node.length; ++i)
 $root.onnx.NodeProto.encode(message.node[i], writer.uint32(
 /* id 7, wireType 2 =*/
 58
 ).fork()).ldelim();
 if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
 writer.uint32(
 /* id 8, wireType 2 =*/
 66
 ).string(message.docString);
 if (message.opsetImport != null && message.opsetImport.length)
 for (var i = 0; i < message.opsetImport.length; ++i)
 $root.onnx.OperatorSetIdProto.encode(
 message.opsetImport[i],
 writer.uint32(
 /* id 9, wireType 2 =*/
 74
 ).fork()
 ).ldelim();
 if (message.domain != null && Object.hasOwnProperty.call(message, "domain"))
 writer.uint32(
 /* id 10, wireType 2 =*/
 82
 ).string(message.domain);
 if (message.attributeProto != null && message.attributeProto.length)
 for (var i = 0; i < message.attributeProto.length; ++i)
 $root.onnx.AttributeProto.encode(
 message.attributeProto[i],
 writer.uint32(
 /* id 11, wireType 2 =*/
 90
 ).fork()
 ).ldelim();
 return writer;
 };
 FunctionProto.encodeDelimited = function encodeDelimited(message, writer) {
 return this.encode(message, writer).ldelim();
 };
 FunctionProto.decode = function decode(reader, length) {
 if (!(reader instanceof $Reader))
 reader = $Reader.create(reader);
 var end = length === void 0 ? reader.len : reader.pos + length, message = new $root.onnx.FunctionProto();
 while (reader.pos < end) {
 var tag = reader.uint32();
 switch (tag >>> 3) {
 case 1: {
 message.name = reader.string();
 break;
 }
 case 4: {
 if (!(message.input && message.input.length))
 message.input = [];
 message.input.push(reader.string());
 break;
 }
 case 5: {
 if (!(message.output && message.output.length))
 message.output = [];
 message.output.push(reader.string());
 break;
 }
 case 6: {
 if (!(message.attribute && message.attribute.length))
 message.attribute = [];
 message.attribute.push(reader.string());
 break;
 }
 case 11: {
 if (!(message.attributeProto && message.attributeProto.length))
 message.attributeProto = [];
 message.attributeProto.push($root.onnx.AttributeProto.decode(reader, reader.uint32()));
 break;
 }
 case 7: {
 if (!(message.node && message.node.length))
 message.node = [];
 message.node.push($root.onnx.NodeProto.decode(reader, reader.uint32()));
 break;
 }
 case 8: {
 message.docString = reader.string();
 break;
 }
 case 9: {
 if (!(message.opsetImport && message.opsetImport.length))
 message.opsetImport = [];
 message.opsetImport.push($root.onnx.OperatorSetIdProto.decode(reader, reader.uint32()));
 break;
 }
 case 10: {
 message.domain = reader.string();
 break;
 }
 default:
 reader.skipType(tag & 7);
 break;
 }
 }
 return message;
 };
 FunctionProto.decodeDelimited = function decodeDelimited(reader) {
 if (!(reader instanceof $Reader))
 reader = new $Reader(reader);
 return this.decode(reader, reader.uint32());
 };
 FunctionProto.verify = function verify(message) {
 if (typeof message !== "object" || message === null)
 return "object expected";
 if (message.name != null && message.hasOwnProperty("name")) {
 if (!$util.isString(message.name))
 return "name: string expected";
 }
 if (message.input != null && message.hasOwnProperty("input")) {
 if (!Array.isArray(message.input))
 return "input: array expected";
 for (var i = 0; i < message.input.length; ++i)
 if (!$util.isString(message.input[i]))
 return "input: string[] expected";
 }
 if (message.output != null && message.hasOwnProperty("output")) {
 if (!Array.isArray(message.output))
 return "output: array expected";
 for (var i = 0; i < message.output.length; ++i)
 if (!$util.isString(message.output[i]))
 return "output: string[] expected";
 }
 if (message.attribute != null && message.hasOwnProperty("attribute")) {
 if (!Array.isArray(message.attribute))
 return "attribute: array expected";
 for (var i = 0; i < message.attribute.length; ++i)
 if (!$util.isString(message.attribute[i]))
 return "attribute: string[] expected";
 }
 if (message.attributeProto != null && message.hasOwnProperty("attributeProto")) {
 if (!Array.isArray(message.attributeProto))
 return "attributeProto: array expected";
 for (var i = 0; i < message.attributeProto.length; ++i) {
 var error = $root.onnx.AttributeProto.verify(message.attributeProto[i]);
 if (error)
 return "attributeProto." + error;
 }
 }
 if (message.node != null && message.hasOwnProperty("node")) {
 if (!Array.isArray(message.node))
 return "node: array expected";
 for (var i = 0; i < message.node.length; ++i) {
 var error = $root.onnx.NodeProto.verify(message.node[i]);
 if (error)
 return "node." + error;
 }
 }
 if (message.docString != null && message.hasOwnProperty("docString")) {
 if (!$util.isString(message.docString))
 return "docString: string expected";
 }
 if (message.opsetImport != null && message.hasOwnProperty("opsetImport")) {
 if (!Array.isArray(message.opsetImport))
 return "opsetImport: array expected";
 for (var i = 0; i < message.opsetImport.length; ++i) {
 var error = $root.onnx.OperatorSetIdProto.verify(message.opsetImport[i]);
 if (error)
 return "opsetImport." + error;
 }
 }
 if (message.domain != null && message.hasOwnProperty("domain")) {
 if (!$util.isString(message.domain))
 return "domain: string expected";
 }
 return null;
 };
 FunctionProto.fromObject = function fromObject(object) {
 if (object instanceof $root.onnx.FunctionProto)
 return object;
 var message = new $root.onnx.FunctionProto();
 if (object.name != null)
 message.name = String(object.name);
 if (object.input) {
 if (!Array.isArray(object.input))
 throw TypeError(".onnx.FunctionProto.input: array expected");
 message.input = [];
 for (var i = 0; i < object.input.length; ++i)
 message.input[i] = String(object.input[i]);
 }
 if (object.output) {
 if (!Array.isArray(object.output))
 throw TypeError(".onnx.FunctionProto.output: array expected");
 message.output = [];
 for (var i = 0; i < object.output.length; ++i)
 message.output[i] = String(object.output[i]);
 }
 if (object.attribute) {
 if (!Array.isArray(object.attribute))
 throw TypeError(".onnx.FunctionProto.attribute: array expected");
 message.attribute = [];
 for (var i = 0; i < object.attribute.length; ++i)
 message.attribute[i] = String(object.attribute[i]);
 }
 if (object.attributeProto) {
 if (!Array.isArray(object.attributeProto))
 throw TypeError(".onnx.FunctionProto.attributeProto: array expected");
 message.attributeProto = [];
 for (var i = 0; i < object.attributeProto.length; ++i) {
 if (typeof object.attributeProto[i] !== "object")
 throw TypeError(".onnx.FunctionProto.attributeProto: object expected");
 message.attributeProto[i] = $root.onnx.AttributeProto.fromObject(object.attributeProto[i]);
 }
 }
 if (object.node) {
 if (!Array.isArray(object.node))
 throw TypeError(".onnx.FunctionProto.node: array expected");
 message.node = [];
 for (var i = 0; i < object.node.length; ++i) {
 if (typeof object.node[i] !== "object")
 throw TypeError(".onnx.FunctionProto.node: object expected");
 message.node[i] = $root.onnx.NodeProto.fromObject(object.node[i]);
 }
 }
 if (object.docString != null)
 message.docString = String(object.docString);
 if (object.opsetImport) {
 if (!Array.isArray(object.opsetImport))
 throw TypeError(".onnx.FunctionProto.opsetImport: array expected");
 message.opsetImport = [];
 for (var i = 0; i < object.opsetImport.length; ++i) {
 if (typeof object.opsetImport[i] !== "object")
 throw TypeError(".onnx.FunctionProto.opsetImport: object expected");
 message.opsetImport[i] = $root.onnx.OperatorSetIdProto.fromObject(object.opsetImport[i]);
 }
 }
 if (object.domain != null)
 message.domain = String(object.domain);
 return message;
 };
 FunctionProto.toObject = function toObject(message, options) {
 if (!options)
 options = {};
 var object = {};
 if (options.arrays || options.defaults) {
 object.input = [];
 object.output = [];
 object.attribute = [];
 object.node = [];
 object.opsetImport = [];
 object.attributeProto = [];
 }
 if (options.defaults) {
 object.name = "";
 object.docString = "";
 object.domain = "";
 }
 if (message.name != null && message.hasOwnProperty("name"))
 object.name = message.name;
 if (message.input && message.input.length) {
 object.input = [];
 for (var j = 0; j < message.input.length; ++j)
 object.input[j] = message.input[j];
 }
 if (message.output && message.output.length) {
 object.output = [];
 for (var j = 0; j < message.output.length; ++j)
 object.output[j] = message.output[j];
 }
 if (message.attribute && message.attribute.length) {
 object.attribute = [];
 for (var j = 0; j < message.attribute.length; ++j)
 object.attribute[j] = message.attribute[j];
 }
 if (message.node && message.node.length) {
 object.node = [];
 for (var j = 0; j < message.node.length; ++j)
 object.node[j] = $root.onnx.NodeProto.toObject(message.node[j], options);
 }
 if (message.docString != null && message.hasOwnProperty("docString"))
 object.docString = message.docString;
 if (message.opsetImport && message.opsetImport.length) {
 object.opsetImport = [];
 for (var j = 0; j < message.opsetImport.length; ++j)
 object.opsetImport[j] = $root.onnx.OperatorSetIdProto.toObject(message.opsetImport[j], options);
 }
 if (message.domain != null && message.hasOwnProperty("domain"))
 object.domain = message.domain;
 if (message.attributeProto && message.attributeProto.length) {
 object.attributeProto = [];
 for (var j = 0; j < message.attributeProto.length; ++j)
 object.attributeProto[j] = $root.onnx.AttributeProto.toObject(message.attributeProto[j], options);
 }
 return object;
 };
 FunctionProto.prototype.toJSON = function toJSON() {
 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
 };
 FunctionProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
 if (typeUrlPrefix === void 0) {
 typeUrlPrefix = "type.googleapis.com";
 }
 return typeUrlPrefix + "/onnx.FunctionProto";
 };
 return FunctionProto;
 }();
 return onnx6;
 }();
 module2.exports = $root;
 }
});

// web/lib/onnxjs/util.ts
function assert(expr, msg) {
 if (!expr) {
 throw new Error(typeof msg === "string" ? msg : msg());
 }
}
function decodeUtf8String(buffer) {
 return new TextDecoder().decode(buffer);
}
var import_onnx, ArrayUtil, MatMulUtil, BroadcastUtil, GemmUtil, ProtoUtil, LongUtil, ShapeUtil, SplitUtil, PoolConvUtil, MIN_CLIP, MAX_CLIP;
var init_util = __esm({
 "web/lib/onnxjs/util.ts"() {
 "use strict";
 init_flatbuffers();
 init_long();
 import_onnx = __toESM(require_onnx());
 init_tensor2();
 ArrayUtil = class {
 /**
 * Verifies if 2 input arrays contain the same elements.
 * @param n1 Array 1
 * @param n2 Array 2
 * @returns Whether these 2 are equal
 */
 static arraysEqual(n1, n2) {
 if (n1.length !== n2.length) {
 return false;
 }
 for (let i = 0; i < n1.length; i++) {
 if (n1[i] !== n2[i]) {
 return false;
 }
 }
 return true;
 }
 };
 MatMulUtil = class {
 /**
 * Fix the input shapes for MatMul operation if they need fixing
 * @param dimsA The shape of tensor A. Should be an array of positive integers
 * @param dimsB The shape of tensor B. Should be an array of positive integers
 * @returns A tuple containing the preprocessed input shapes as required by ONNX specifications
 */
 static preprocessInputShapes(dimsA, dimsB) {
 const a = dimsA.length === 1 ? [1, dimsA[0]] : dimsA;
 const b = dimsB.length === 1 ? [dimsB[0], 1] : dimsB;
 return [a, b];
 }
 /**
 * Fix the output shape computed for MatMul operation if it needs fixing
 * @param outputShape The computed outputShape. Should be an array (atleast of length 2) of positive integers.
 * This will be mutated.
 * @param aRank The rank of tensor A.
 * @param bRank The rank of tensor B.
 */
 static postprocessOutputShape(outputShape, aRank, bRank) {
 if (aRank === 1) {
 outputShape.splice(outputShape.length - 2, 1);
 }
 if (bRank === 1) {
 outputShape.pop();
 }
 }
 /**
 * 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 _BroadcastUtil {
 /**
 * 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;
 }
 cdims[crank - i] = Math.max(aLen, bLen);
 }
 return cdims;
 }
 /**
 * Given the indices of a broadcasted tensor, calculate the original indices
 * @param broadcastedIndices The given indices of the broadcasted tensor.
 * @param originalShape The original shape of the tensor before broadcas
 * @returns The calculated indices that maps to the original tensor.
 */
 static index(broadcastedIndices, originalShape) {
 const originalIndices = new Array(originalShape.length);
 _BroadcastUtil.fillIndex(broadcastedIndices, originalShape, originalIndices);
 return originalIndices;
 }
 /**
 * Given the indices of a broadcasted tensor, calculate the original indices
 * @param broadcastedIndices The given indices of the broadcasted tensor.
 * @param originalShape The original shape of the tensor before broadcast
 * @param originalIndices The mapping of broadcastedIndices to the originalIndices (output parameter - will be
 * mutated).
 */
 static fillIndex(broadcastedIndices, originalShape, originalIndices) {
 const dimOffset = broadcastedIndices.length - originalShape.length;
 for (let i = 0; i < originalShape.length; i++) {
 originalIndices[i] = broadcastedIndices[dimOffset + i] % originalShape[i];
 }
 }
 /**
 * Perform the broadcasting operation on the specific operator
 * @param a The input tensor A
 * @param b The input tensor B
 * @param op The operator lambda function
 * @param inplace Whether to write the result back to A.
 * @returns The result tensor, or undefined if input not broadcastable.
 */
 static calc(a, b, op, inplace, resultType) {
 const outputShape = _BroadcastUtil.calcShape(a.dims, b.dims);
 if (outputShape) {
 if (inplace && !ShapeUtil.areEqual(outputShape, a.dims)) {
 return void 0;
 }
 const size = ShapeUtil.size(outputShape);
 const c = inplace ? a : new Tensor3(outputShape, resultType || a.type);
 if (outputShape.length === 0) {
 c.set([], op(a.get([]), b.get([])));
 } else {
 const outputIndices = new Array(outputShape.length);
 const originalIndicesA = new Array(a.dims.length);
 const originalIndicesB = new Array(b.dims.length);
 let valA = 0;
 let valB = 0;
 let isAScalar = false;
 let isBScalar = false;
 if (a.dims.length === 0) {
 valA = a.get([]);
 isAScalar = true;
 }
 if (b.dims.length === 0) {
 valB = b.get([]);
 isBScalar = true;
 }
 let rest;
 for (let i = 0; i < size; i++) {
 rest = i;
 for (let j = outputShape.length - 1; j >= 0; j--) {
 outputIndices[j] = rest % outputShape[j];
 rest = Math.floor(rest / outputShape[j]);
 }
 if (!isAScalar) {
 _BroadcastUtil.fillIndex(outputIndices, a.dims, originalIndicesA);
 valA = a.get(originalIndicesA);
 }
 if (!isBScalar) {
 _BroadcastUtil.fillIndex(outputIndices, b.dims, originalIndicesB);
 valB = b.get(originalIndicesB);
 }
 c.set(outputIndices, op(valA, valB));
 }
 }
 return c;
 }
 return void 0;
 }
 /**
 * Determine if a shape is unidirectional broadcastable to another shape
 * @param shape The input shape
 * @param finalShape The desired shape after broadcasting
 */
 static isValidBroadcast(shape2, finalShape) {
 const inputRank = shape2.length;
 const finalRank = finalShape.length;
 if (inputRank > finalRank) {
 return false;
 }
 for (let i = 1; i <= inputRank; i++) {
 if (shape2[inputRank - i] !== 1 && shape2[inputRank - i] !== finalShape[finalRank - i]) {
 return false;
 }
 }
 return true;
 }
 /**
--> --------------------

--> maximum size reached

--> --------------------

Quelle ort-dev.mjs Sprache: unbekannt

[Dauer der Verarbeitung: 0.913 Sekunden, vorverarbeitet 2026-06-06]