text: /* jshint esversion: 6 */
  
  // Experimental
  
  var pytorch = pytorch || {};
  var python = python || require('./python');
  var base = base || require('./base');
  
  pytorch.ModelFactory = class {
  
      match(context) {
          if (pytorch.Container.open(context)) {
              return true;
          }
          return false;
      }
  
      open(context) {
          const identifier = context.identifier;
          return pytorch.Metadata.open(context).then((metadata) => {
              let container = null;
              try {
                  container = pytorch.Container.open(context, metadata, (error, fatal) => {
                      const message = error && error.message ? error.message : error.toString();
                      context.exception(new pytorch.Error(message.replace(/\.$/, '') + " in '" + identifier + "'."), fatal);
                  });
              }
              catch (error) {
                  const message = error && error.message ? error.message : error.toString();
                  throw new pytorch.Error('File format is not PyTorch (' + message.replace(/\.$/, '') + ').');
              }
              return new pytorch.Model(metadata, container);
          });
      }
  };
  
  pytorch.Model = class {
  
      constructor(metadata, container) {
          this._format = container.format;
          this._producer = container.producer || '';
          this._graphs = [];
          const type = container.type;
          switch (type) {
              case 'script':
                  this._graphs.push(new pytorch.Graph(metadata, type, container.data, container));
                  break;
              case 'module':
              case 'weights':
                  for (const data of container.data) {
                      this._graphs.push(new pytorch.Graph(metadata, type, data, container));
                  }
                  break;
          }
      }
  
      get format() {
          return this._format;
      }
  
      get graphs() {
          return this._graphs;
      }
  };
  
  pytorch.Graph = class {
  
      constructor(metadata, type, data, container) {
          this._nodes = [];
          this._inputs = [];
          this._outputs = [];
          this._groups = true;
          this._littleEndian = container.littleEndian;
  
          switch (type) {
              case 'script': {
                  this._name = container.name;
                  const traced = container.trace();
                  const initializers = new Map();
                  if (container.constants) {
                      for (const constant of container.constants) {
                          if (pytorch.Utility.isTensor(constant)) {
                              constant.initializer = new pytorch.Tensor(constant.__variable__, constant, this._littleEndian);
                              initializers.set(constant.__variable__, constant);
                          }
                          else if (constant && constant.__class__ && constant.__class__.__module__ === '__torch__.torch.classes.xnnpack') {
                              switch (constant.__class__.__name__) {
                                  case 'LinearOpContext':
                                  case 'Conv2dOpContext':
                                      for (const key of Object.keys(constant)) {
                                          const value = constant[key];
                                          if (pytorch.Utility.isTensor(value)) {
                                              value.initializer = new pytorch.Tensor(value.__variable__, value, this._littleEndian);
                                              initializers.set(value.__variable__, value);
                                          }
                                      }
                                      break;
                                  default:
                                      throw new pytorch.Error("Unsupported constant context '" + constant.__class__.__name__ + "'.");
                              }
                          }
                          else {
                              throw new pytorch.Error('Unsupported constant.');
                          }
                      }
                  }
                  if (data) {
                      const queue = [ data ];
                      while (queue.length > 0) {
                          const module = queue.shift();
                          if (module.__class__ && module.__class__.__module__ === '__torch__.torch.classes._nnapi' && module.__class__.__name__ === 'Compilation') {
                              continue;
                          }
                          for (const key of Object.keys(module)) {
                              if (key !== '__module__' && key !== '__name__' && key !== '__class__' && key !== '__parent__') {
                                  const obj = module[key];
                                  if (!Array.isArray(obj) && obj === Object(obj)) {
                                      if (pytorch.Utility.isTensor(obj)) {
                                          const parameter = obj;
                                          parameter.__parent__ = module;
                                          if (!parameter.initializer && parameter.storage()) {
                                              parameter.initializer = new pytorch.Tensor(parameter.name, parameter, this._littleEndian);
                                          }
                                          if (parameter.__variable__ && parameter.__count__ === 1) {
                                              initializers.set(parameter.__variable__, parameter);
                                          }
                                      }
                                      else if (obj && obj.__class__) {
                                          obj.__parent__ = module;
                                          if (!obj.__id__) {
                                              obj.__id__ = key;
                                          }
                                          queue.push(obj);
                                      }
                                  }
                              }
                          }
                      }
                  }
                  if (traced) {
                      if (container.inputs) {
                          for (const input of container.inputs) {
                              this._inputs.push(new pytorch.Parameter(input, true, [
                                  new pytorch.Argument(input, null, null)
                              ]));
                          }
                      }
                      if (container.outputs) {
                          for (const output of container.outputs) {
                              this._outputs.push(new pytorch.Parameter(output, true, [
                                  new pytorch.Argument(output, null, null)
                              ]));
                          }
                      }
                      if (container.nodes) {
                          for (const node of container.nodes) {
                              const item = {
                                  type: node.type,
                                  node: node
                              };
                              this._nodes.push(new pytorch.Node(metadata, '', item, initializers));
                          }
                      }
                  }
                  if (data) {
                      this._loadScriptModule(metadata, container, data, initializers);
                  }
                  break;
              }
              case 'module': {
                  this._name = data.name || '';
                  this._type = (data.obj.__module__ && data.obj.__name__) ? (data.obj.__module__ + '.' + data.obj.__name__) : '';
                  this._loadModule(metadata, data.obj, [], []);
                  break;
              }
              case 'weights': {
                  this._name = data.name || '';
                  for (const state_group of data.layers) {
                      const attributes = state_group.attributes || [];
                      const inputs = state_group.states.map((parameter) => {
                          return new pytorch.Parameter(parameter.name, true,
                              parameter.arguments.map((state) => {
                                  const tensor = new pytorch.Tensor(state.id, pytorch.Utility.toTensor(state.value), this._littleEndian);
                                  return new pytorch.Argument(state.id, null, tensor);
                              }));
                      });
                      const obj = {
                          name: state_group.name,
                          type: state_group.type || 'torch.nn.Module',
                          attributes: attributes,
                          inputs: inputs,
                          outputs: []
                      };
                      this._nodes.push(new pytorch.Node(metadata, '', obj, null));
                  }
              }
          }
      }
  
      _loadModule(metadata, current, groups, inputs) {
  
          if (current.__class__ && current.__class__.__module__ !== 'torch.nn.modules.container' && (!current._modules || current._modules.size == 0)) {
              this._createNode(metadata, groups, '', current, inputs, false);
              return [];
          }
  
          if (!current._modules) {
              throw new pytorch.Error('Module does not contain modules.');
          }
  
          const sequential = current.__class__ && current.__class__.__module__ === 'torch.nn.modules.container' && current.__class__.__name__ === 'Sequential';
  
          for (const pair of current._modules) {
              const key = pair[0];
              const value = pair[1];
              if (value) {
                  const type = value.__class__.__module__ + '.' + value.__class__.__name__;
                  switch (type) {
                      case 'torch.nn.modules.container.Sequential':
                          groups.push(key);
                          inputs = this._loadModule(metadata, value, groups, sequential ? inputs : []);
                          groups.pop(key);
                          break;
                      default: {
                          inputs = this._createNode(metadata, groups, key, value, sequential ? inputs : [], sequential);
                          break;
                      }
                  }
              }
          }
          return inputs;
      }
  
      _createNode(metadata, groups, key, obj, args, output) {
  
          const type = obj.__class__.__module__ + '.' + obj.__class__.__name__;
          const schema = metadata.type(type);
  
          let inputSchema = [ { name: 'input'} ];
          if (schema && schema.inputs && schema.inputs.length > 0) {
              inputSchema = schema.inputs.slice();
          }
  
          const inputName = inputSchema.shift().name;
          const inputs = [];
          if (args.length > 0) {
              inputs.push(new pytorch.Parameter(inputName, true, args.map((argument) => {
                  return new pytorch.Argument(argument, null, null);
              })));
          }
  
          const parameters = obj._parameters || obj._buffers || [];
          for (const parameter of parameters) {
              const key = parameter[0];
              const value = pytorch.Utility.toTensor(parameter[1]);
              let visible = true;
              let inputName = '';
              if (inputSchema.length > 0) {
                  const input = inputSchema.shift();
                  inputName = input.name;
                  visible = input.visible === false ? false : true;
              }
              if (value) {
                  const initializer = new pytorch.Tensor('', value, this._littleEndian);
                  inputs.push(new pytorch.Parameter(inputName || key, visible, [ new pytorch.Argument('', null, initializer) ]));
              }
          }
  
          const group = groups.join('/');
          const name = group ? (group + '/' + key) : key;
  
          const outputs = output ? [ new pytorch.Parameter('output', true, [ new pytorch.Argument(name, null, null) ]) ] : [];
  
          const attributes = [];
          for (const name of Object.keys(obj)) {
              if (name.startsWith('_')) {
                  continue;
              }
              attributes.push({ name: name, value: obj[name] });
          }
          const item = {
              name: name,
              type: type,
              attributes: attributes,
              children: obj._modules && obj._modules.size > 0 ? true : false,
              inputs: inputs,
              outputs: outputs
          };
          const node = new pytorch.Node(metadata, group, item, {});
          this._nodes.push(node);
          return [ node.name ];
      }
  
      _loadScriptModule(metadata, container, module, initializers) {
          if (module) {
              if (pytorch.Graph._getParameters(module).length > 0 && !module.__hide__) {
                  const item = { module: module };
                  this._nodes.push(new pytorch.Node(metadata, '', item, initializers));
              }
              const submodules = pytorch.Graph._getSubmodules(module);
              for (const submodule of submodules) {
                  this._loadScriptModule(metadata, container, submodule, initializers);
              }
          }
      }
  
      static _getParameters(module) {
          const parameters = [];
          if (module && module.__class__.__module__ && module.__class__.__name__) {
              for (const key of Object.keys(module)) {
                  if (pytorch.Utility.isTensor(module[key])) {
                      const parameter = module[key];
                      parameter.__id__ = key;
                      parameters.push(parameter);
                  }
              }
          }
          return parameters;
      }
  
      static _getSubmodules(module) {
          const submodules = [];
          if (module && module.__class__ && module.__class__.__module__ && module.__class__.__name__) {
              for (const key of Object.keys(module)) {
                  if (!key.startsWith('__')) {
                      const value = module[key];
                      if (value && value.__class__ && value.__module__ && value.__name__ && !pytorch.Utility.isTensor(value)) {
                          submodules.push(value);
                      }
                  }
              }
          }
          return submodules;
      }
  
      get type() {
          return this._type;
      }
  
      get name() {
          return this._name;
      }
  
      get groups() {
          return this._groups;
      }
  
      get inputs() {
          return this._inputs;
      }
  
      get outputs() {
          return this._outputs;
      }
  
      get nodes() {
          return this._nodes;
      }
  };
  
  pytorch.Parameter = class {
  
      constructor(name, visible, args) {
          this._name = name;
          this._visible = visible;
          this._arguments = args;
      }
  
      get name() {
          return this._name;
      }
  
      get visible() {
          return this._visible;
      }
  
      get arguments() {
          return this._arguments;
      }
  };
  
  pytorch.Argument = class {
  
      constructor(name, type, initializer) {
          if (typeof name !== 'string') {
              throw new pytorch.Error("Invalid argument identifier '" + JSON.stringify(name) + "'.");
          }
          this._name = name;
          this._type = type;
          this._initializer = initializer;
      }
  
      get name() {
          return this._name;
      }
  
      get type() {
          if (this._initializer) {
              return this._initializer.type;
          }
          return this._type;
      }
  
      get initializer() {
          return this._initializer;
      }
  };
  
  pytorch.Node = class {
  
      constructor(metadata, group, item, initializers) {
          this._group = group || '';
          this._name = item.name || '';
          const type = (metadata, name) => {
              this._type = Object.assign({}, metadata.type(name) || { name: name });
              const identifier = this._type.name;
              this._type.identifier = identifier;
              const index = identifier.indexOf(':');
              this._type.name = index === -1 ? identifier : identifier.substring(0, index);
          };
          if (!item.module && !item.node) {
              type(metadata, item.type);
              this._function = item.children;
              this._inputs = item.inputs;
              this._outputs = item.outputs;
              this._attributes = item.attributes.map((attribute) => {
                  const schema = metadata.attribute(this._type.identifier, attribute.name);
                  return new pytorch.Attribute(schema, attribute.name, attribute.value);
              });
          }
          else {
              this._attributes = [];
              this._inputs = [];
              this._outputs = [];
  
              let module = item.module;
              if (module) {
                  this._type = { name: 'torch.nn.modules.module.Module' };
                  for (const parameter of pytorch.Graph._getParameters(module)) {
                      this._inputs.push(new pytorch.Parameter(parameter.__id__, true, [
                          new pytorch.Argument('', null, parameter.initializer || null)
                      ]));
                      if (parameter.__variable__) {
                          this._outputs.push(new pytorch.Parameter(parameter.__id__, true, [
                              new pytorch.Argument(parameter.__variable__, null, null)
                          ]));
                      }
                  }
              }
  
              if (item.node) {
                  type(metadata, item.type);
                  module = null;
                  let match = true;
                  let count = 0;
                  for (const input of item.node.inputs) {
                      for (const argument of input) {
                          const parameter = initializers.get(argument.id);
                          if (parameter) {
                              if (parameter.__parent__ && (module == null || module == parameter.__parent__)) {
                                  module = parameter.__parent__;
                                  count++;
                              }
                              else if (parameter.__variable__.startsWith('CONSTANTS.c')) {
                                  argument.initializer = parameter.initializer;
                                  count++;
                              }
                              else {
                                  match = false;
                                  break;
                              }
                          }
                      }
                      if (!match) {
                          break;
                      }
                  }
                  if (module) {
                      const params = pytorch.Graph._getParameters(module).filter((p) => p.__id__ !== 'num_batches_tracked');
                      if (params.length == count && match) {
                          module.__hide__ = true;
                          for (const input of item.node.inputs) {
                              for (const argument of input) {
                                  const parameter = initializers.get(argument.id);
                                  if (parameter && parameter.initializer) {
                                      argument.initializer = parameter.initializer;
                                  }
                              }
                          }
                      }
                      else {
                          module = null;
                      }
                  }
  
                  for (let inputIndex = 0; inputIndex < item.node.inputs.length; inputIndex++) {
                      let inputName = inputIndex.toString();
                      if (this._type && this._type.inputs && this._type.inputs.length > inputIndex) {
                          inputName = this._type.inputs[inputIndex].name;
                      }
                      this._inputs.push(new pytorch.Parameter(inputName, true,
                          item.node.inputs[inputIndex].map((input) => new pytorch.Argument(input.id, null, input.initializer || null))
                      ));
                  }
  
                  for (let outputIndex = 0; outputIndex < item.node.outputs.length; outputIndex++) {
                      let outputName = outputIndex.toString();
                      if (this._type && this._type.outputs && this._type.outputs.length > outputIndex) {
                          outputName = this._type.outputs[outputIndex].name;
                      }
                      this._outputs.push(new pytorch.Parameter(outputName, true,
                          item.node.outputs[outputIndex].map((output) => new pytorch.Argument(output.id, null, null))
                      ));
                  }
  
                  for (const attribute of item.node.attributes) {
                      const name = attribute.name;
                      const value = attribute.value;
                      const schema = metadata.attribute(this._type.identifier, name);
                      this._attributes.push(new pytorch.Attribute(schema, name, value));
                  }
              }
              if (module) {
                  if (module.__id__) {
                      let current = module;
                      this._name = current.__id__;
                      while (current.__parent__ != null) {
                          current = current.__parent__;
                          if (!current.__parent__ && !current.__id__) {
                              break;
                          }
                          this._name = [ current.__id__, this._name ].join('.');
                      }
                  }
              }
          }
      }
  
      get name() {
          return this._name;
      }
  
      get group() {
          return this._group;
      }
  
      get type() {
          return this._type;
      }
  
      get function() {
          return this._function;
      }
  
      get attributes() {
          return this._attributes;
      }
  
      get inputs() {
          return this._inputs;
      }
  
      get outputs() {
          return this._outputs;
      }
  };
  
  pytorch.Attribute = class {
  
      constructor(schema, name, value) {
          this._name = name;
          this._value = value;
  
          if (this._name === 'training') {
              this._visible = false;
              this._type = 'boolean';
              return;
          }
          if (schema) {
              if (Object.prototype.hasOwnProperty.call(schema, 'type')) {
                  this._type = schema.type;
              }
              if (schema.visible === false) {
                  this._visible = false;
              }
              else if (Object.prototype.hasOwnProperty.call(schema, 'default')) {
                  if (JSON.stringify(schema.default) == JSON.stringify(this._value)) {
                      this._visible = false;
                  }
                  else if (Array.isArray(this._value) && !Array.isArray(schema.default) && this.value.every((item) => item == schema.default)) {
                      this._visible = false;
                  }
              }
          }
          if (Array.isArray(value) && value.length > 0 && value.every((obj) => obj && obj.__class__ && obj.__class__.__module__ && obj.__class__.__module__.startsWith('torch.nn'))) {
              this._value = '?';
          }
      }
  
      get type() {
          return this._type;
      }
  
      get name() {
          return this._name;
      }
  
      get value() {
          return this._value;
      }
  
      get visible() {
          return this._visible == false ? false : true;
      }
  };
  
  pytorch.Tensor = class {
  
      constructor(name, tensor, littleEndian) {
          const storage = tensor.storage();
          const size = tensor.size();
          this._name = name || '';
          this._type = new pytorch.TensorType(storage.dtype, new pytorch.TensorShape(size));
          this._data = storage.data;
          this._littleEndian = littleEndian;
      }
  
      get kind() {
          return 'Tensor';
      }
  
      get name() {
          return this._name;
      }
  
      get type() {
          return this._type;
      }
  
      get state() {
          return this._context().state;
      }
  
      get value() {
          const context = this._context();
          if (context.state) {
              return null;
          }
          context.limit = Number.MAX_SAFE_INTEGER;
          return this._decode(context, 0);
      }
  
      toString() {
          const context = this._context();
          if (context.state) {
              return '';
          }
          context.limit = 10000;
          const value = this._decode(context, 0);
          return pytorch.Tensor._stringify(value, '', '    ');
      }
  
      _context() {
          const context = {};
          context.state = null;
          context.index = 0;
          context.count = 0;
  
          if (!this._type.dataType) {
              context.state = 'Tensor has no data type.';
              return context;
          }
          switch (this._type.dataType) {
              case 'boolean':
              case 'uint8':
              case 'qint8':
              case 'int8':
              case 'int16':
              case 'int32':
              case 'int64':
              case 'float16':
              case 'float32':
              case 'float64':
                  break;
              default:
                  context.state = "Tensor data type '" + this._type.dataType + "' is not supported.";
                  return context;
          }
          if (!this._type.shape) {
              context.state = 'Tensor has no dimensions.';
              return context;
          }
          if (!this._data) {
              context.state = 'Tensor data is empty.';
              return context;
          }
  
          try {
              context.data = this._data instanceof Uint8Array ? this._data : this._data.peek();
          }
          catch (err) {
              context.state = err.message;
              return context;
          }
  
          context.dataType = this._type.dataType;
          context.dimensions = this._type.shape.dimensions;
          context.dataView = new DataView(context.data.buffer, context.data.byteOffset, context.data.byteLength);
          return context;
      }
  
      _decode(context, dimension) {
          const results = [];
          const dimensions = (context.dimensions.length == 0) ? [ 1 ] : context.dimensions;
          const size = dimensions[dimension];
          if (dimension == dimensions.length - 1) {
              for (let i = 0; i < size; i++) {
                  if (context.count > context.limit) {
                      results.push('...');
                      return results;
                  }
                  switch (context.dataType) {
                      case 'boolean':
                          results.push(context.dataView.getUint8(context.index) === 0 ?  false : true);
                          context.index++;
                          context.count++;
                          break;
                      case 'uint8':
                          results.push(context.dataView.getUint8(context.index));
                          context.index++;
                          context.count++;
                          break;
                      case 'qint8':
                      case 'int8':
                          results.push(context.dataView.getInt8(context.index));
                          context.index++;
                          context.count++;
                          break;
                      case 'int16':
                          results.push(context.dataView.getInt16(context.index, this._littleEndian));
                          context.index += 2;
                          context.count++;
                          break;
                      case 'int32':
                          results.push(context.dataView.getInt32(context.index, this._littleEndian));
                          context.index += 4;
                          context.count++;
                          break;
                      case 'int64':
                          results.push(context.dataView.getInt64(context.index, this._littleEndian));
                          context.index += 8;
                          context.count++;
                          break;
                      case 'float16':
                          results.push(context.dataView.getFloat16(context.index, this._littleEndian));
                          context.index += 2;
                          context.count++;
                          break;
                      case 'float32':
                          results.push(context.dataView.getFloat32(context.index, this._littleEndian));
                          context.index += 4;
                          context.count++;
                          break;
                      case 'float64':
                          results.push(context.dataView.getFloat64(context.index, this._littleEndian));
                          context.index += 8;
                          context.count++;
                          break;
                  }
              }
          }
          else {
              for (let j = 0; j < size; j++) {
                  if (context.count > context.limit) {
                      results.push('...');
                      return results;
                  }
                  results.push(this._decode(context, dimension + 1));
              }
          }
          if (context.dimensions.length == 0) {
              return results[0];
          }
          return results;
      }
  
      static _stringify(value, indentation, indent) {
          if (Array.isArray(value)) {
              const result = [];
              result.push(indentation + '[');
              const items = value.map((item) => pytorch.Tensor._stringify(item, indentation + indent, indent));
              if (items.length > 0) {
                  result.push(items.join(',\n'));
              }
              result.push(indentation + ']');
              return result.join('\n');
          }
          if (value && (value instanceof base.Int64 || value instanceof base.Uint64)) {
              return indentation + value.toString();
          }
          if (typeof value == 'string') {
              return indentation + value;
          }
          if (value == Infinity) {
              return indentation + 'Infinity';
          }
          if (value == -Infinity) {
              return indentation + '-Infinity';
          }
          if (isNaN(value)) {
              return indentation + 'NaN';
          }
          return indentation + value.toString();
      }
  };
  
  pytorch.TensorType = class {
  
      constructor(dtype, shape) {
          this._dataType = dtype.__reduce__();
          this._shape = shape;
      }
  
      get dataType() {
          return this._dataType;
      }
  
      get shape() {
          return this._shape;
      }
  
      toString() {
          return this._dataType + this._shape.toString();
      }
  };
  
  pytorch.TensorShape = class {
  
      constructor(dimensions) {
          this._dimensions = dimensions || [];
      }
  
      get dimensions() {
          return this._dimensions;
      }
  
      toString() {
          if (this._dimensions && this._dimensions.length > 0) {
              return '[' + this._dimensions.map((dimension) => dimension.toString()).join(',') + ']';
          }
          return '';
      }
  };
  
  pytorch.Execution = class extends python.Execution {
  
      constructor(sources, exceptionCallback) {
          super(sources, exceptionCallback);
          this.registerModule('ops');
          this.registerModule('ops.torchvision');
          this.registerModule('torch');
          this.registerModule('torchvision');
          this.context.scope.ops._caffe2 = { __name__: 'torch', __class__: this.context.scope.builtins.module };
          const self = this;
          const torch = this.context.scope.torch;
          this.registerType('builtins.number', class {});
          this.registerType('__torch__.torch.classes._nnapi.Compilation', class {
              constructor() {
                  this.__hide__ = true;
              }
              __init__() {
              }
              init(serialized_model_tensor, parameter_buffers) {
                  this.serialized_model_tensor = serialized_model_tensor;
                  this.parameter_buffers = parameter_buffers;
                  const storage = serialized_model_tensor.storage();
                  new pytorch.nnapi.SerializedModel(storage.data, parameter_buffers);
              }
              run(inputs, outputs) {
                  this.serialized_model_tensor.__variable__ = this.serialized_model_tensor.__variable__ || self.variable();
                  this.serialized_model_tensor.__count__ = (this.serialized_model_tensor.__count__ || 0) + 1;
                  self.push({
                      type: 'torch.classes._nnapi.Compilation',
                      attributes: [],
                      inputs: [
                          [ { id: this.serialized_model_tensor.__variable__ } ],
                          inputs.map((input) => { return { id: input.__variable__ }; }),
                          this.parameter_buffers.map((buffer) => { return { id: buffer.__variable__ }; })
                      ],
                      outputs: [
                          outputs.map((output) => { return { id: output.__variable__ }; })
                      ],
                  });
              }
          });
          this.registerType('torch.autograd.variable.Variable', class {});
          this.registerType('torch.backends.cudnn.rnn.Unserializable', class {});
          this.registerType('torch.distributions.constraints._LowerCholesky', class {});
          this.registerType('torch.distributions.constraints._Real', class {});
          this.registerType('torch.distributions.multivariate_normal.MultivariateNormal', class {});
          this.registerType('torch.distributions.transforms.LowerCholeskyTransform', class {});
          this.registerType('torch.nn.backends.thnn._get_thnn_function_backend', class {});
          this.registerType('torch.nn.intrinsic.modules.fused.ConvReLU2d', class {});
          this.registerType('torch.nn.intrinsic.qat.modules.conv_fused.ConvReLU2d', class {});
          this.registerType('torch.nn.intrinsic.quantized.modules.conv_relu.ConvReLU2d', class {});
          this.registerType('torch.nn.intrinsic.quantized.modules.linear_relu.LinearReLU', class {});
          this.registerType('torch.nn.modules.activation.CELU', class {});
          this.registerType('torch.nn.modules.activation.ELU', class {});
          this.registerType('torch.nn.modules.activation.GELU', class {});
          this.registerType('torch.nn.modules.activation.GLU', class {});
          this.registerType('torch.nn.modules.activation.Hardtanh', class {});
          this.registerType('torch.nn.modules.activation.Hardswish', class {});
          this.registerType('torch.nn.modules.activation.Hardsigmoid', class {});
          this.registerType('torch.nn.modules.activation.LeakyReLU', class {});
          this.registerType('torch.nn.modules.activation.LogSigmoid', class {});
          this.registerType('torch.nn.modules.activation.LogSoftmax', class {});
          this.registerType('torch.nn.modules.activation.MultiheadAttention', class {});
          this.registerType('torch.nn.modules.activation.ReLU', class {});
          this.registerType('torch.nn.modules.activation.ReLU6', class {});
          this.registerType('torch.nn.modules.activation.PReLU', class {});
          this.registerType('torch.nn.modules.activation.RReLU', class {});
          this.registerType('torch.nn.modules.activation.SELU', class {});
          this.registerType('torch.nn.modules.activation.Sigmoid', class {});
          this.registerType('torch.nn.modules.activation.SiLU', class {});
          this.registerType('torch.nn.modules.activation.Softmax', class {});
          this.registerType('torch.nn.modules.activation.Softmax2d', class {});
          this.registerType('torch.nn.modules.activation.Softplus', class {});
          this.registerType('torch.nn.modules.activation.Tanh', class {});
          this.registerType('torch.nn.modules.activation.Threshold', class {});
          this.registerType('torch.nn.modules.batchnorm.BatchNorm1d', class {});
          this.registerType('torch.nn.modules.batchnorm.BatchNorm2d', class {});
          this.registerType('torch.nn.modules.batchnorm.BatchNorm3d', class {});
          this.registerType('torch.nn.modules.batchnorm.SyncBatchNorm', class {});
          this.registerType('torch.nn.modules.container.ModuleDict', class {});
          this.registerType('torch.nn.modules.container.ModuleList', class {});
          this.registerType('torch.nn.modules.container.ParameterList', class {});
          this.registerType('torch.nn.modules.container.Sequential', class {});
          this.registerType('torch.nn.modules.conv.Conv1d', class {});
          this.registerType('torch.nn.modules.conv.Conv2d', class {});
          this.registerType('torch.nn.modules.conv.Conv3d', class {});
          this.registerType('torch.nn.modules.conv.ConvTranspose1d', class {});
          this.registerType('torch.nn.modules.conv.ConvTranspose2d', class {});
          this.registerType('torch.nn.modules.conv.ConvTranspose3d', class {});
          this.registerType('torch.nn.modules.distance.CosineSimilarity', class {});
          this.registerType('torch.nn.modules.dropout.AlphaDropout', class {});
          this.registerType('torch.nn.modules.dropout.Dropout', class {});
          this.registerType('torch.nn.modules.dropout.Dropout2d', class {});
          this.registerType('torch.nn.modules.dropout.Dropout3d', class {});
          this.registerType('torch.nn.modules.fold.Fold', class {});
          this.registerType('torch.nn.modules.fold.Unfold', class {});
          this.registerType('torch.nn.modules.flatten.Flatten', class {});
          this.registerType('torch.nn.modules.flatten.Unflatten', class {});
          this.registerType('torch.nn.modules.instancenorm.InstanceNorm1d', class {});
          this.registerType('torch.nn.modules.instancenorm.InstanceNorm2d', class {});
          this.registerType('torch.nn.modules.instancenorm.InstanceNorm3d', class {});
          this.registerType('torch.nn.modules.linear._LinearWithBias', class {});
          this.registerType('torch.nn.modules.linear.Bilinear', class {});
          this.registerType('torch.nn.modules.linear.LazyLinear', class {});
          this.registerType('torch.nn.modules.linear.Linear', class {});
          this.registerType('torch.nn.modules.linear.Identity', class {});
          this.registerType('torch.nn.modules.loss.BCELoss', class {});
          this.registerType('torch.nn.modules.loss.BCEWithLogitsLoss', class {});
          this.registerType('torch.nn.modules.loss.CrossEntropyLoss', class {});
          this.registerType('torch.nn.modules.loss.CTCLoss', class {});
          this.registerType('torch.nn.modules.loss.KLDivLoss', class {});
          this.registerType('torch.nn.modules.loss.L1Loss', class {});
          this.registerType('torch.nn.modules.loss.MarginRankingLoss', class {});
          this.registerType('torch.nn.modules.loss.MSELoss', class {});
          this.registerType('torch.nn.modules.loss.NLLLoss', class {});
          this.registerType('torch.nn.modules.loss.NLLLoss2d', class {});
          this.registerType('torch.nn.modules.loss.SmoothL1Loss', class {});
          this.registerType('torch.nn.modules.module._IncompatibleKeys', class {});
          this.registerType('torch.nn.modules.module.Module', class {});
          this.registerType('torch.nn.modules.normalization.CrossMapLRN2d', class {});
          this.registerType('torch.nn.modules.normalization.GroupNorm', class {});
          this.registerType('torch.nn.modules.normalization.LayerNorm', class {});
          this.registerType('torch.nn.modules.normalization.LocalResponseNorm', class {});
          this.registerType('torch.nn.modules.padding.ReflectionPad1d', class {});
          this.registerType('torch.nn.modules.padding.ReflectionPad2d', class {});
          this.registerType('torch.nn.modules.padding.ReplicationPad1d', class {});
          this.registerType('torch.nn.modules.padding.ReplicationPad2d', class {});
          this.registerType('torch.nn.modules.padding.ReplicationPad3d', class {});
          this.registerType('torch.nn.modules.padding.ZeroPad2d', class {});
          this.registerType('torch.nn.modules.padding.ConstantPad1d', class {});
          this.registerType('torch.nn.modules.padding.ConstantPad2d', class {});
          this.registerType('torch.nn.modules.padding.ConstantPad3d', class {});
          this.registerType('torch.nn.modules.pixelshuffle.PixelShuffle', class {});
          this.registerType('torch.nn.modules.pooling.AdaptiveAvgPool1d', class {});
          this.registerType('torch.nn.modules.pooling.AdaptiveAvgPool2d', class {});
          this.registerType('torch.nn.modules.pooling.AdaptiveAvgPool3d', class {});
          this.registerType('torch.nn.modules.pooling.AdaptiveMaxPool1d', class {});
          this.registerType('torch.nn.modules.pooling.AdaptiveMaxPool2d', class {});
          this.registerType('torch.nn.modules.pooling.AdaptiveMaxPool3d', class {});
          this.registerType('torch.nn.modules.pooling.AvgPool1d', class {});
          this.registerType('torch.nn.modules.pooling.AvgPool2d', class {});
          this.registerType('torch.nn.modules.pooling.AvgPool3d', class {});
          this.registerType('torch.nn.modules.pooling.FractionalMaxPool2d', class {});
          this.registerType('torch.nn.modules.pooling.LPPool2d', class {});
          this.registerType('torch.nn.modules.pooling.MaxPool1d', class {});
          this.registerType('torch.nn.modules.pooling.MaxPool2d', class {});
          this.registerType('torch.nn.modules.pooling.MaxPool3d', class {});
          this.registerType('torch.nn.modules.pooling.MaxUnpool1d', class {});
          this.registerType('torch.nn.modules.pooling.MaxUnpool2d', class {});
          this.registerType('torch.nn.modules.pooling.MaxUnpool3d', class {});
          this.registerType('torch.nn.modules.rnn.GRU', class {});
          this.registerType('torch.nn.modules.rnn.GRUCell', class {});
          this.registerType('torch.nn.modules.rnn.LSTM', class {});
          this.registerType('torch.nn.modules.rnn.LSTMCell', class {});
          this.registerType('torch.nn.modules.rnn.RNN', class {});
          this.registerType('torch.nn.modules.sparse.Embedding', class {});
          this.registerType('torch.nn.modules.sparse.EmbeddingBag', class {});
          this.registerType('torch.nn.modules.transformer.Transformer', class {});
          this.registerType('torch.nn.modules.transformer.TransformerDecoder', class {});
          this.registerType('torch.nn.modules.transformer.TransformerDecoderLayer', class {});
          this.registerType('torch.nn.modules.transformer.TransformerEncoder', class {});
          this.registerType('torch.nn.modules.transformer.TransformerEncoderLayer', class {});
          this.registerType('torch.nn.modules.upsampling.Upsample', class {});
          this.registerType('torch.nn.modules.upsampling.UpsamplingBilinear2d', class {});
          this.registerType('torch.nn.modules.upsampling.UpsamplingNearest2d', class {});
          this.registerType('torch.nn.parallel.data_parallel.DataParallel', class {});
          this.registerType('torch.nn.parallel.distributed.DistributedDataParallel', class {});
          this.registerType('torch.nn.qat.modules.conv.Conv2d', class {});
          this.registerType('torch.nn.quantized.modules.activation.ReLU', class {});
          this.registerType('torch.nn.quantized.modules.activation.ReLU6', class {});
          this.registerType('torch.nn.quantized.modules.batchnorm.BatchNorm2d', class {});
          this.registerType('torch.nn.quantized.modules.conv.Conv2d', class {});
          this.registerType('torch.nn.quantized.modules.conv.ConvTranspose2d', class {});
          this.registerType('torch.nn.quantized.modules.DeQuantize', class {});
          this.registerType('torch.nn.quantized.modules.functional_modules.FloatFunctional', class {});
          this.registerType('torch.nn.quantized.modules.functional_modules.QFunctional', class {});
          this.registerType('torch.nn.quantized.modules.linear.Linear', class {});
          this.registerType('torch.nn.quantized.modules.linear.LinearPackedParams', class {});
          this.registerType('torch.nn.quantized.modules.normalization.InstanceNorm2d', class {});
          this.registerType('torch.nn.quantized.modules.Quantize', class {});
          this.registerType('torch.nn.utils.prune.L1Unstructured', class {});
          this.registerType('torch.nn.utils.spectral_norm.SpectralNorm', class {});
          this.registerType('torch.nn.utils.spectral_norm.SpectralNormStateDictHook', class {});
          this.registerType('torch.nn.utils.spectral_norm.SpectralNormLoadStateDictPreHook', class {});
          this.registerType('torch.nn.utils.weight_norm.WeightNorm', class {});
          this.registerType('torch.optim.adam.Adam', class {});
          this.registerType('torch.optim.adamw.AdamW', class {});
          this.registerType('torch.optim.adagrad.Adagrad', class {});
          this.registerType('torch.optim.adadelta.Adadelta', class {});
          this.registerType('torch.optim.lr_scheduler.CosineAnnealingLR', class {});
          this.registerType('torch.optim.lr_scheduler.CyclicLR', class {});
          this.registerType('torch.optim.lr_scheduler.ExponentialLR', class {});
          this.registerType('torch.optim.lr_scheduler.LambdaLR', class {});
          this.registerType('torch.optim.lr_scheduler.MultiStepLR', class {});
          this.registerType('torch.optim.lr_scheduler.OneCycleLR', class {});
          this.registerType('torch.optim.lr_scheduler.ReduceLROnPlateau', class {});
          this.registerType('torch.optim.lr_scheduler.StepLR', class {});
          this.registerType('torch.optim.optimizer._RequiredParameter', class {});
          this.registerType('torch.optim.rmsprop.RMSprop', class {});
          this.registerType('torch.optim.sgd.SGD', class {});
          this.registerType('torch.quantization.fake_quantize.FakeQuantize', class {});
          this.registerType('torch.quantization.observer._PartialWrapper', class {});
          this.registerType('torch.quantization.observer.MinMaxObserver', class {});
          this.registerType('torch.quantization.QConfig.QConfig', class {});
          this.registerType('torch.quantization.stubs.DeQuantStub', class {});
          this.registerType('torch.quantization.stubs.QuantStub', class {});
          this.registerType('torch.utils.data.dataloader.DataLoader', class {});
          this.registerType('torch.utils.data.dataset.Subset', class {});
          this.registerType('torch.utils.data.dataset.ConcatDataset', class {});
          this.registerType('torch.utils.data.sampler.BatchSampler', class {});
          this.registerType('torch.utils.data.sampler.RandomSampler', class {});
          this.registerType('torch.utils.data.sampler.SequentialSampler', class {});
          this.registerType('torchvision.datasets.folder.ImageFolder', class {});
          this.registerType('torchvision.datasets.mnist.MNIST', class {});
          this.registerType('torchvision.datasets.vision.StandardTransform', class {});
          this.registerType('torchvision.models.alexnet.AlexNet', class {});
          this.registerType('torchvision.models.densenet.DenseNet', class {});
          this.registerType('torchvision.models.densenet._DenseBlock', class {});
          this.registerType('torchvision.models.densenet._DenseLayer', class {});
          this.registerType('torchvision.models.densenet._Transition', class {});
          this.registerType('torchvision.models.detection._utils.BalancedPositiveNegativeSampler', class {});
          this.registerType('torchvision.models.detection._utils.BoxCoder', class {});
          this.registerType('torchvision.models.detection._utils.Matcher', class {});
          this.registerType('torchvision.models.detection._utils.SSDMatcher', class {});
          this.registerType('torchvision.models.detection.anchor_utils.AnchorGenerator', class {});
          this.registerType('torchvision.models.detection.anchor_utils.DefaultBoxGenerator', class {});
          this.registerType('torchvision.models.detection.backbone_utils.BackboneWithFPN', class {});
          this.registerType('torchvision.models.detection.faster_rcnn.FasterRCNN', class {});
          this.registerType('torchvision.models.detection.faster_rcnn.FastRCNNPredictor', class {});
          this.registerType('torchvision.models.detection.faster_rcnn.TwoMLPHead', class {});
          this.registerType('torchvision.models.detection.keypoint_rcnn.KeypointRCNN', class {});
          this.registerType('torchvision.models.detection.keypoint_rcnn.KeypointRCNNHeads', class {});
          this.registerType('torchvision.models.detection.keypoint_rcnn.KeypointRCNNPredictor', class {});
          this.registerType('torchvision.models.detection.mask_rcnn.MaskRCNN', class {});
          this.registerType('torchvision.models.detection.mask_rcnn.MaskRCNNHeads', class {});
          this.registerType('torchvision.models.detection.mask_rcnn.MaskRCNNPredictor', class {});
          this.registerType('torchvision.models.detection.retinanet.RetinaNetClassificationHead', class {});
          this.registerType('torchvision.models.detection.retinanet.RetinaNetHead', class {});
          this.registerType('torchvision.models.detection.retinanet.RetinaNetRegressionHead', class {});
          this.registerType('torchvision.models.detection.roi_heads.RoIHeads', class {});
          this.registerType('torchvision.models.detection.rpn.AnchorGenerator', class {});
          this.registerType('torchvision.models.detection.rpn.RegionProposalNetwork', class {});
          this.registerType('torchvision.models.detection.rpn.RPNHead', class {});
          this.registerType('torchvision.models.detection.ssd.SSD', class {});
          this.registerType('torchvision.models.detection.ssdlite.SSDLiteClassificationHead', class {});
          this.registerType('torchvision.models.detection.ssdlite.SSDLiteFeatureExtractorMobileNet', class {});
          this.registerType('torchvision.models.detection.ssdlite.SSDLiteHead', class {});
          this.registerType('torchvision.models.detection.ssdlite.SSDLiteRegressionHead', class {});        this.registerType('torchvision.models.detection.transform.GeneralizedRCNNTransform', class {});
          this.registerType('torchvision.models.googlenet.BasicConv2d', class {});
          this.registerType('torchvision.models.googlenet.GoogLeNet', class {});
          this.registerType('torchvision.models.googlenet.Inception', class {});
          this.registerType('torchvision.models.googlenet.InceptionAux', class {});
          this.registerType('torchvision.models.inception.BasicConv2d', class {});
          this.registerType('torchvision.models.inception.Inception3', class {});
          this.registerType('torchvision.models.inception.InceptionAux', class {});
          this.registerType('torchvision.models.inception.InceptionA', class {});
          this.registerType('torchvision.models.inception.InceptionB', class {});
          this.registerType('torchvision.models.inception.InceptionC', class {});
          this.registerType('torchvision.models.inception.InceptionD', class {});
          this.registerType('torchvision.models.inception.InceptionE', class {});
          this.registerType('torchvision.models.mnasnet._InvertedResidual', class {});
          this.registerType('torchvision.models.mnasnet.MNASNet', class {});
          this.registerType('torchvision.models.mobilenet.ConvBNReLU', class {});
          this.registerType('torchvision.models.mobilenet.MobileNetV2', class {});
          this.registerType('torchvision.models.mobilenet.InvertedResidual', class {});
          this.registerType('torchvision.models.mobilenetv2.ConvBNActivation', class {});
          this.registerType('torchvision.models.mobilenetv2.InvertedResidual', class {});
          this.registerType('torchvision.models.mobilenetv2.MobileNetV2', class {});
          this.registerType('torchvision.models.mobilenetv3.InvertedResidual', class {});
          this.registerType('torchvision.models.mobilenetv3.MobileNetV3', class {});
          this.registerType('torchvision.models.mobilenetv3.SqueezeExcitation', class {});
          this.registerType('torchvision.models.resnet.Bottleneck', class {});
          this.registerType('torchvision.models.resnet.BasicBlock', class {});
          this.registerType('torchvision.models.quantization.mobilenet.QuantizableInvertedResidual', class {});
          this.registerType('torchvision.models.quantization.mobilenet.QuantizableMobileNetV2', class {});
          this.registerType('torchvision.models.quantization.resnet.QuantizableBasicBlock', class {});
          this.registerType('torchvision.models.quantization.resnet.QuantizableBottleneck', class {});
          this.registerType('torchvision.models.quantization.resnet.QuantizableResNet', class {});
          this.registerType('torchvision.models.segmentation.deeplabv3.ASPP', class {});
          this.registerType('torchvision.models.segmentation.deeplabv3.ASPPConv', class {});
          this.registerType('torchvision.models.segmentation.deeplabv3.ASPPPooling', class {});
          this.registerType('torchvision.models.segmentation.deeplabv3.DeepLabHead', class {});
          this.registerType('torchvision.models.segmentation.deeplabv3.DeepLabV3', class {});
          this.registerType('torchvision.models.segmentation.fcn.FCN', class {});
          this.registerType('torchvision.models.segmentation.fcn.FCNHead', class {});
          this.registerType('torchvision.models.shufflenetv2.ShuffleNetV2', class {});
          this.registerType('torchvision.models.shufflenetv2.InvertedResidual', class {});
          this.registerType('torchvision.models.squeezenet.Fire', class {});
          this.registerType('torchvision.models.squeezenet.SqueezeNet', class {});
          this.registerType('torchvision.models.resnet.ResNet', class {});
          this.registerType('torchvision.models.vgg.VGG', class {});
          this.registerType('torchvision.models.video.resnet.BasicBlock', class {});
          this.registerType('torchvision.models.video.resnet.BasicStem', class {});
          this.registerType('torchvision.models.video.resnet.Conv2Plus1D', class {});
          this.registerType('torchvision.models.video.resnet.Conv3DNoTemporal', class {});
          this.registerType('torchvision.models.video.resnet.Conv3DSimple', class {});
          this.registerType('torchvision.models.video.resnet.R2Plus1dStem', class {});
          this.registerType('torchvision.models.video.resnet.VideoResNet', class {});
          this.registerType('torchvision.models._utils.IntermediateLayerGetter', class {});
          this.registerType('torchvision.ops.deform_conv.DeformConv2d', class {});
          this.registerType('torchvision.ops.feature_pyramid_network.FeaturePyramidNetwork', class {});
          this.registerType('torchvision.ops.feature_pyramid_network.LastLevelMaxPool', class {});
          this.registerType('torchvision.ops.feature_pyramid_network.LastLevelP6P7', class {});
          this.registerType('torchvision.ops.misc.ConvTranspose2d', class {});
          this.registerType('torchvision.ops.misc.FrozenBatchNorm2d', class {});
          this.registerType('torchvision.ops.poolers.LevelMapper', class {});
          this.registerType('torchvision.ops.poolers.MultiScaleRoIAlign', class {});
          this.registerType('torchvision.transforms.functional.InterpolationMode', class {});
          this.registerType('torchvision.transforms.transforms.Compose', class {});
          this.registerType('torchvision.transforms.transforms.Grayscale', class {});
          this.registerType('torchvision.transforms.transforms.Normalize', class {});
          this.registerType('torchvision.transforms.transforms.RandomAffine', class {});
          this.registerType('torchvision.transforms.transforms.Resize', class {});
          this.registerType('torchvision.transforms.transforms.ToPILImage', class {});
          this.registerType('torchvision.transforms.transforms.ToTensor', class {});
          this.registerFunction('annotate', function(type, value) {
              if (type === self.context.scope.builtins.int) {
                  return Number.isInteger(value) ? value : NaN;
              }
              if (type === self.context.scope.builtins.float) {
                  return typeof value === 'number' ? value : NaN;
              }
              if (type === self.context.scope.builtins.number) {
                  if (pytorch.Utility.isTensor(value)) {
                      value.resize_([]);
                  }
              }
              return value;
          });
          this.registerFunction('int', function(value) {
              if (pytorch.Utility.isTensor(value)) {
                  const storage = value.storage();
                  if (storage && storage.dtype.__reduce__() === 'int64' && storage.data.length === 8) {
                      const buffer = storage.data;
                      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
                      return view.getInt64(0, true);
                  }
              }
              if (Number.isInteger(value)) {
                  return value;
              }
              return NaN;
          });
          this.registerFunction('float', function(value) {
              if (pytorch.Utility.isTensor(value)) {
                  const storage = value.storage();
                  if (storage && storage.dtype.__reduce__() === 'float32') {
                      if (storage.size() !== undefined && storage.data.length === 4) {
                          const buffer = storage.data;
                          const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
                          return view.getFloat32(0, true);
                      }
                      return NaN;
                  }
              }
              if (Number(value) === value) {
                  return value;
              }
              return NaN;
          });
          this.registerFunction('str', function(value) {
              return JSON.stringify(value);
          });
          this.registerFunction('unchecked_cast', function(type, value) {
              return value;
          });
          this.registerFunction('ops.prim.data', function(tensor) {
              return tensor;
          });
          this.registerFunction('ops.prim.device', function(tensor) {
              return tensor.device;
          });
          this.registerFunction('ops.prim.dtype', function(tensor) {
              return tensor.dtype.scalar_type();
          });
          this.registerFunction('ops.prim.unchecked_unwrap_optional', function(value) {
              return value;
          });
          this.registerFunction('ops.prim.NumToTensor', function(value) {
              const tensor = self.invoke('torch.Tensor', []);
              tensor.value = value; // TODO
              return tensor;
          });
          this.registerFunction('ops.prim.min', function(value) {
              if (Array.isArray(value)) {
                  return Math.min.apply(null, value);
              }
              return Math.min.apply(null, arguments);
          });
          this.registerFunction('ops.prim.shape', function(tensor) {
              return tensor && tensor.size ? tensor.size() : undefined;
          });
          this.registerFunction('ops.quantized.conv_prepack', function(weight, bias, stride, padding, dilation, groups) {
              return {
                  __class__: {
                      __module__: '__torch__.torch.classes.quantized',
                      __name__: 'Conv2dPackedParamsBase'
                  },
                  weight: weight,
                  bias: bias,
                  stride: stride,
                  padding: padding,
                  dilation: dilation,
                  groups: groups
              };
          });
          this.registerFunction('ops.quantized.conv1d_prepack', function(weight, bias, stride, padding, dilation, groups) {
              return {
                  __class__: {
                      __module__: '__torch__.torch.classes.quantized',
                      __name__: 'Conv2dPackedParamsBase'
                  },
                  weight: weight,
                  bias: bias,
                  stride: stride,
                  padding: padding,
                  dilation: dilation,
                  groups: groups
              };
          });
          this.registerFunction('ops.quantized.conv2d_prepack', function(weight, bias, stride, padding, dilation, groups) {
              return {
                  __class__: {
                      __module__: '__torch__.torch.classes.quantized',
                      __name__: 'Conv2dPackedParamsBase'
                  },
                  weight: weight,
                  bias: bias,
                  stride: stride,
                  padding: padding,
                  dilation: dilation,
                  groups: groups
              };
          });
          this.registerFunction('ops.quantized.conv3d_prepack', function(weight, bias, stride, padding, dilation, groups) {
              return {
                  __class__: {
                      __module__: '__torch__.torch.classes.quantized',
                      __name__: 'Conv3dPackedParamsBase'
                  },
                  weight: weight,
                  bias: bias,
                  stride: stride,
                  padding: padding,
                  dilation: dilation,
                  groups: groups
              };
          });
          this.registerFunction('ops.quantized.conv_transpose2d_prepack', function(weight, bias, stride, padding, dilation, groups) {
              return {
                  __class__: {
                      __module__: '__torch__.torch.classes.quantized',
                      __name__: 'Conv2dPackedParamsBase'
                  },
                  weight: weight,
                  bias: bias,
                  stride: stride,
                  padding: padding,
                  dilation: dilation,
                  groups: groups
              };
          });
          this.registerFunction('ops.quantized.linear_prepack', function(weight, bias) {
              return {
                  __class__: {
                      __module__: '__torch__.torch.classes.quantized',
                      __name__: 'LinearPackedParamsBase'
                  },
                  weight: weight,
                  bias: bias
              };
          });
          this.registerFunction('ops.prim.RaiseException', function(message) {
              throw new pytorch.Error(message);
          });
          this.registerFunction('range', function(start, stop, step) {
              if (start !== undefined && Number.isInteger(start) && stop === undefined && step === undefined) {
                  return Array(start).keys();
              }
              throw new pytorch.Error('Unsupported function range(' + JSON.stringify(start) + ', ' + JSON.stringify(stop) + ', ' + JSON.stringify(step) + ')');
          });
          this.registerFunction('torch._utils._rebuild_tensor', function (storage, storage_offset, size, stride) {
              const name = storage.__class__.__module__ + '.' + storage.__class__.__name__.replace('Storage', 'Tensor');
              const tensor = self.invoke(name, []);
              tensor.__setstate__([ storage, storage_offset, size, stride ]);
              return tensor;
          });
          this.registerFunction('torch._utils._rebuild_tensor_v2', function (storage, storage_offset, size, stride, requires_grad, backward_hooks) {
              const name = storage.__class__.__module__ + '.' + storage.__class__.__name__.replace('Storage', 'Tensor');
              const tensor = self.invoke(name, []);
              tensor.__setstate__([ storage, storage_offset, size, stride ]);
              tensor.requires_grad = requires_grad;
              tensor.backward_hooks = backward_hooks;
              return tensor;
          });
          this.registerFunction('torch._utils._rebuild_parameter', function(data, requires_grad, backward_hooks) {
              const obj = self.invoke('torch.nn.parameter.Parameter', [ data, requires_grad ]);
              obj.backward_hooks = backward_hooks;
              return obj;
          });
          this.registerFunction('torch._utils._rebuild_qtensor', function(storage, storage_offset, size, stride, quantizer_params, requires_grad, backward_hooks) {
              const name = storage.__class__.__module__ + '.' + storage.__class__.__name__.replace('Storage', 'Tensor');
              const tensor = self.invoke(name, []);
              tensor.__setstate__([ storage, storage_offset, size, stride ]);
              tensor.quantizer_params = quantizer_params;
              tensor.requires_grad = requires_grad;
              tensor.backward_hooks = backward_hooks;
              return tensor;
          });
          this.registerFunction('torch._set_item', function(dict, key, value) {
              dict[key] = value;
          });
          this.registerFunction('torch.__and__', function(left, right) {
              return left && right;
          });
          this.registerFunction('torch.__contains__', function(dict, key) {
              return dict[key] !== undefined;
          });
          this.registerFunction('torch.__derive_index', function(index, start, step) {
              return start + index * step;
          });
          this.registerFunction('torch.__is__', function(left, right) {
              if (left === null && right === null) {
                  return true;
              }
              if ((left !== null && right === null) || (left === null && right !== null)) {
                  return false;
              }
              throw new pytorch.Error("Unknown 'torch.__is__' expression type.");
          });
          this.registerFunction('torch.__isnot__', function(left, right) {
              if (left === null && right === null) {
                  return false;
              }
              if ((left !== null && right === null) || (left === null && right !== null)) {
                  return true;
              }
              throw new pytorch.Error("Unknown 'torch.__isnot__' expression type.");
          });
          this.registerFunction('torch.__not__', function(value) {
              if (typeof value === 'boolean') {
                  return !value;
              }
              throw new pytorch.Error("Unknown 'torch.__not__' expression type.");
          });
          this.registerFunction('torch.__range_length', function(lo, hi, step) {
              if (step === 0) {
                  throw new pytorch.Error('range() arg 3 must not be zero');
              }
              if (step > 0 && lo < hi) {
                  return 1 + (hi - 1 - lo) / step;
              }
              else if (step < 0 && lo > hi) {
                  return 1 + (lo - 1 - hi) / (0 - step);
              }
              return 0;
          });
          this.registerFunction('torch._unwrap_optional', function(value) {
              return value; // TODO
          });
          this.registerFunction('torch.add', function(left, right) {
              if (typeof left === 'number' && typeof right === 'number') {
                  return left * right;
              }
              if (Array.isArray(left) && Array.isArray(right)) {
                  return left.concat(right);
              }
              if (typeof left === 'string' && typeof right === 'string') {
                  return left + right;
              }
              throw new pytorch.Error('Unknown torch.add expression type.');
          });
          this.registerFunction('torch.append', function(list, value) {
              list.push(value);
              return value;
          });
          this.registerFunction('torch.extend', function(list, value) {
              list.push(...value);
          });
          this.registerFunction('torch.insert', function(list, index, value) {
              list.splice(index, 0, value);
              return value;
          });
          this.registerFunction('torch.clear', function(value) {
              if (Object(value) === value) {
                  for (const key of Object.keys(value)) {
                      delete value[key];
                  }
              }
          });
          this.registerFunction('torch.dict', function(args) {
              const obj = {};
              if (args) {
                  if (Array.isArray(args)) {
                      for (const pair of args) {
                          const key = pair[0];
                          const value = pair[1];
                          obj[key] = value;
                      }
                  }
                  else {
                      throw new pytorch.Error("'torch.dict' arguments not supported.");
                  }
              }
              return obj;
          });
          this.registerFunction('torch.dim', function(tensor) {
              if (tensor && tensor.size) {
                  const size = tensor.size();
                  if (size) {
                      return size.length;
                  }
              }
              return undefined; // TODO
          });
          this.registerFunction('torch.numel', function(tensor) {
              if (tensor && tensor.size) {
                  const size = tensor.size();
                  if (size) {
                      return size.reduce((a, b) => a * b, 1);
                  }
              }
              return NaN;
          });
          this.registerFunction('torch.eq', function(left, right) {
              if (typeof left === 'string' && typeof right === 'string') {
                  return left === right;
              }
              if (typeof left === 'number' && typeof right === 'number') {
                  return left === right;
              }
              if (left === undefined || right === undefined) {
                  return true;
              }
              throw new pytorch.Error("Unknown 'torch.eq' expression type.");
          });
          this.registerFunction('torch.floor', function(value) {
              return Math.floor(value);
          });
          this.registerFunction('torch.ceil', function(value) {
              return Math.ceil(value);
          });
          this.registerFunction('torch.floordiv', function(left, right) {
              return Math.floor(left / right);
          });
          this.registerFunction('torch.format', function() {
              const args = Array.from(arguments);
              const list = args.shift().split(/({}D?)/);
              return list.map((text) => {
                  if (text === '{}' || text === '{}D') {
                      const arg = args.shift();
                      return Array.isArray(arg) ? '[' + arg.map((item) => item.toString()).join(', ') + ']' : arg ? arg.toString() : '?';
                  }
                  return text;
              }).join('');
          });
          this.registerFunction('torch.gt', function(left, right) {
              if (typeof left === 'number' && typeof right === 'number') {
                  if (!isNaN(left) && !isNaN(right)) {
                      return left > right;
                  }
              }
              if (isNaN(left) && !isNaN(right)) {
                  return true;
              }
              throw new pytorch.Error("Unknown 'torch.gt' expression type.");
          });
          this.registerFunction('torch.ge', function(left, right) {
              if (typeof left === 'number' && typeof right === 'number') {
                  if (!isNaN(left) && !isNaN(right)) {
                      return left > right;
                  }
              }
              if (isNaN(left) && !isNaN(right)) {
                  return true;
              }
              throw new pytorch.Error("Unknown 'torch.ge' expression type.");
          });
          this.registerFunction('torch.jit._pickle.build_boollist', function(data) {
              return data;
          });
          this.registerFunction('torch.jit._pickle.build_doublelist', function(data) {
              return data;
          });
          this.registerFunction('torch.jit._pickle.build_intlist', function(data) {
              return data;
          });
          this.registerFunction('torch.jit._pickle.build_tensorlist', function(data) {
              return data;
          });
          this.registerFunction('torch.jit._pickle.build_tensor_from_id', function(data) {
              const constants = self.context.getx('CONSTANTS');
              return constants['c' + data.toString()];
          });
          this.registerFunction('torch.jit._pickle.restore_type_tag', function(value /*, type_str */) {
              return value;
          });
          this.registerFunction('torch.keys', function(dict) {
              return Object.keys(dict);
          });
          this.registerFunction('torch.len', function(value) {
              if (Array.isArray(value)) {
                  return value.length;
              }
              if (value && value.__len__) {
                  return value.__len__();
              }
              return NaN;
          });
          this.registerFunction('torch.le', function(left, right) {
              if (typeof left === 'number' && typeof right === 'number') {
                  if (isNaN(left) || isNaN(right)) {
                      return false;
                  }
                  return left <= right;
              }
              if (left === undefined || right === undefined) {
                  return true;
              }
              throw new pytorch.Error("Unknown 'torch.le' expression type.");
          });
          this.registerFunction('torch.list', function(args) {
              return args;
          });
          this.registerFunction('torch.list_with_default', function(size /*, defaults */) {
              return size;
          });
          this.registerFunction('torch.lt', function(left, right) {
              if (typeof left === 'number' && typeof right === 'number') {
                  return left < right;
              }
              throw new pytorch.Error("Unknown 'torch.lt' expression type.");
          });
          this.registerFunction('torch.mul', function(left, right) {
              if (typeof left === 'number' && typeof right === 'number') {
                  return left * right;
              }
              if (isNaN(left) || isNaN(right)) {
                  return NaN;
              }
              if (Array.isArray(left) && left.every((value) => typeof value === 'number') && typeof right === 'number') {
                  return left.map((value) => value * right);
              }
              throw new pytorch.Error("Unknown 'torch.mul' expression type.");
          });
          this.registerFunction('torch.div', function(left, right) {
              if (typeof left === 'number' && typeof right === 'number') {
                  return left / right;
              }
              if (isNaN(left) || isNaN(right)) {
                  return NaN;
              }
              throw new pytorch.Error("Unknown 'torch.div' expression type.");
          });
          this.registerFunction('torch.remainder', function(left, right) {
              if (typeof left === 'number' && typeof right === 'number') {
                  return left % right;
              }
              if (isNaN(left) || isNaN(right)) {
                  return NaN;
              }
              throw new pytorch.Error("Unknown 'torch.remainder' expression type.");
          });
          this.registerFunction('torch.ne', function(left, right) {
              if (typeof left === 'number' && typeof right === 'number') {
                  if (isNaN(left) || isNaN(right)) {
                      return false;
                  }
                  return left !== right;
              }
              if (Array.isArray(left) && Array.isArray(right) && left.length === right.length) {
                  return false;
              }
              if (typeof left === 'string' && typeof right === 'string') {
                  return left !== right;
              }
              if (left === undefined || right === undefined) {
                  return true;
              }
              throw new pytorch.Error("Unknown 'torch.ne' expression type.");
          });
          this.registerFunction('torch.neg', function(value) {
              if (typeof value === 'number') {
                  return -value;
              }
              throw new pytorch.Error("Unknown 'torch.neg' expression type.");
          });
          this.registerFunction('torch.q_scale', function(/* tensor */) {
              return -1; // TODO
          });
          this.registerFunction('torch.t', function(tensor) {
              return tensor;
          });
          this.registerFunction('torch.size', function(tensor, dim) {
              if (tensor && tensor.size) {
                  const size = tensor.size();
                  if (Array.isArray(size)) {
                      if (dim === undefined) {
                          return size;
                      }
                      if (Number.isInteger(dim)) {
                          if (dim >= 0 && dim < size.length) {
                              return size[dim];
                          }
                          if (dim < 0 && -dim < size.length) {
                              return size[size.length + dim];
                          }
                      }
                      throw new pytorch.Error('Dimension out of range (expected to be in range of ' + JSON.stringify(size) + ', but got ' + JSON.stringify(dim) + ').');
                  }
              }
              return NaN;
          });
          this.registerFunction('torch.slice', function(l, start, end, step) {
              if (step !== 1) {
                  throw new pytorch.Error('Slicing only supports step=1');
              }
              start = Math.max(0, start >= 0 ? start : l.length + start);
              end = Math.min(l.length, end);
              return l.slice(start, end);
          });
          this.registerFunction('torch.sub', function(left, right) {
              if (typeof left === 'number' && typeof right === 'number') {
                  return left - right;
              }
              throw new pytorch.Error("Unknown 'torch.sub' expression type.");
          });
          this.registerFunction('torch.values', function(dict) {
              return Object.keys(dict).map((key) => dict[key]);
          });
          this.registerFunction('torch.warn', function() {
          });
          this.registerFunction('uninitialized', function(/* type */) {
              return undefined;
          });
          this.registerType('torch.device', class {
              constructor(type, index) {
                  this.type = type;
                  if (index) {
                      this.index = index;
                  }
              }
          });
          this.registerType('torch.dtype', class {
              constructor(type) {
                  this._type = type;
                  this._data = pytorch.Utility.getScalarType(type);
              }
              scalar_type() {
                  return this._type;
              }
              itemsize() {
                  return this._data.itemsize;
              }
              __reduce__() {
                  return this._data.name;
              }
              __str__() {
                  return 'torch.' + this._data.name;
              }
          });
          this.registerType('torch.utils.hooks.RemovableHandle', class {
              __setstate__(state) {
                  this.hooks_dict_ref = state[0] || new Map();
                  this.id = state[1];
              }
          });
          this.registerType('torch.storage._StorageBase', class {
              constructor(size, dtype) {
                  this._size = size;
                  this._dtype = dtype;
              }
              get dtype() {
                  return this._dtype;
              }
              get data() {
                  return this._cdata;
              }
              element_size() {
                  return this._dtype.element_size;
              }
              size() {
                  return this._size;
              }
              _set_cdata(data) {
                  const length = this.size() * this.dtype.itemsize();
                  if (length !== data.length) {
                      throw new pytorch.Error('Storage data size mismatch.');
                  }
                  this._cdata = data;
              }
              _set_from_file(unpickler) {
                  const size = unpickler.int64();
                  if (size !== this.size()) {
                      throw new pytorch.Error('Storage size mismatch.');
                  }
                  const itemsize = this.dtype.itemsize();
                  const data = unpickler.stream(itemsize * size);
                  this._set_cdata(data);
              }
              static _new_with_file(unpickler) {
                  const size = unpickler.int64();
                  const storage = new this(size);
                  const itemsize = storage.dtype.itemsize();
                  const data = unpickler.stream(itemsize * size);
                  storage._set_cdata(data);
                  return storage;
              }
          });
          this.registerType('torch.BoolStorage', class extends torch.storage._StorageBase {
              constructor(size) {
                  super(size, torch.bool);
              }
          });
          this.registerType('torch.ByteStorage', class extends torch.storage._StorageBase {
              constructor(size) {
                  super(size, torch.uint8);
              }
          });
          this.registerType('torch.CharStorage', class extends torch.storage._StorageBase {
              constructor(size) {
                  super(size, torch.int8);
              }
          });
          this.registerType('torch.ShortStorage', class extends torch.storage._StorageBase {
              constructor(size) {
                  super(size, torch.int16);
              }
          });
          this.registerType('torch.IntStorage', class extends torch.storage._StorageBase {
              constructor(size) {
                  super(size, torch.int32);
              }
          });
          this.registerType('torch.LongStorage', class extends torch.storage._StorageBase {
              constructor(size) {
                  super(size, torch.int64);
              }
          });
          this.registerType('torch.HalfStorage', class extends torch.storage._StorageBase {
              constructor(size) {
                  super(size, torch.float16);
              }
          });
          this.registerType('torch.FloatStorage', class extends torch.storage._StorageBase {
              constructor(size) {
                  super(size, torch.float32);
              }
          });
          this.registerType('torch.DoubleStorage', class extends torch.storage._StorageBase {
              constructor(size) {
                  super(size, torch.float64);
              }
          });
          this.registerType('torch.QInt8Storage', class extends torch.storage._StorageBase {
              constructor(size) {
                  super(size, torch.qint8);
              }
          });
          this.registerType('torch.QUInt8Storage', class extends torch.storage._StorageBase {
              constructor(size) {
                  super(size, torch.quint8);
              }
          });
          this.registerType('torch.Tensor', class {
              constructor() {
              }
              get dtype() {
                  return this.storage().dtype;
              }
              get shape() {
                  return this._shape;
              }
              size() {
                  return this._shape;
              }
              storage() {
                  if (!this._storage) {
                      const name = this.__class__.__name__ == 'Tensor' ? 'FloatStorage' : this.__storage__.__name__.replace('Tensor', 'Storage');
                      this._storage = self.invoke(this.__class__.__module__ + '.' + name, []);
                  }
                  return this._storage;
              }
              storage_offset() {
                  return this._storage_offset;
              }
              stride() {
                  return this._stride;
              }
              resize_(shape) {
                  this._shape = shape;
              }
              __len__() {
                  return this._shape[0];
              }
              __setstate__(state) {
                  this._storage = state[0];
                  this._storage_offset = state[1];
                  this._shape = state[2];
                  this._stride = state[3];
              }
              tolist() {
  
              }
          });
          this.registerType('torch.nn.parameter.Parameter', class extends torch.Tensor {
              constructor(data, requires_grad) {
                  super();
                  if (!data) {
                      data = self.invoke('torch.Tensor', [[]]);
                  }
                  this.data = data;
                  this.requires_grad = requires_grad !== undefined ? requires_grad : true;
              }
              __setstate__(state) {
                  switch (state.length) {
                      case 4:
                          this.data = state[0];
                          break;
                      case 5:
                          this.data = state[0];
                          break;
                  }
              }
          });
          this.registerType('torch.nn.parameter.UninitializedParameter', class extends torch.nn.parameter.Parameter {
              constructor(requires_grad /*, device, dtype */) {
                  super(undefined, requires_grad);
              }
          });
          this.registerType('torch.BoolTensor', class extends torch.Tensor {});
          this.registerType('torch.ByteTensor', class extends torch.Tensor {});
          this.registerType('torch.CharTensor', class extends torch.Tensor {});
          this.registerType('torch.ShortTensor', class extends torch.Tensor {});
          this.registerType('torch.IntTensor', class extends torch.Tensor {});
          this.registerType('torch.LongTensor', class extends torch.Tensor {});
          this.registerType('torch.HalfTensor', class extends torch.Tensor {});
          this.registerType('torch.FloatTensor', class extends torch.Tensor {});
          this.registerType('torch.DoubleTensor', class extends torch.Tensor {});
          this.registerType('torch.QInt8Tensor', class extends torch.Tensor {});
          this.registerType('torch.QUInt8Tensor', class extends torch.Tensor {});
          this.registerType('torch.cuda.FloatTensor', class extends torch.Tensor {});
          this.registerType('torch.cuda.DoubleTensor', class extends torch.Tensor {});
          torch.uint8 = new torch.dtype(pytorch.ScalarType.uint8);
          torch.int8 = new torch.dtype(pytorch.ScalarType.int8);
          torch.int16 = new torch.dtype(pytorch.ScalarType.int16);
          torch.int32 = new torch.dtype(pytorch.ScalarType.int32);
          torch.int64 = new torch.dtype(pytorch.ScalarType.int64);
          torch.float16 = new torch.dtype(pytorch.ScalarType.float16);
          torch.float32 = new torch.dtype(pytorch.ScalarType.float32);
          torch.float64 = new torch.dtype(pytorch.ScalarType.float64);
          torch.complex32 = new torch.dtype(pytorch.ScalarType.complex32);
          torch.complex64 = new torch.dtype(pytorch.ScalarType.complex64);
          torch.complex128 = new torch.dtype(pytorch.ScalarType.complex128);
          torch.bool = new torch.dtype(pytorch.ScalarType.boolean);
          torch.qint8 = new torch.dtype(pytorch.ScalarType.qint8);
          torch.quint8 = new torch.dtype(pytorch.ScalarType.quint8);
          torch.qint32 = new torch.dtype(pytorch.ScalarType.qint32);
          torch.bfloat16 = new torch.dtype(pytorch.ScalarType.bfloat16);
      }
  
      debug(file) {
          const buffer = this.source(file + '.debug_pkl');
          if (buffer) {
              return null;
              // const unpickler = python.Unpickler.open(buffer);
              // return unpickler.load((name, args) => this.invoke(name, args), null);
          }
          return null;
      }
  };
  
  pytorch.Container = class {
  
      static open(context, metadata, exception) {
          const zip = pytorch.Container.Zip.open(context.entries('zip'), metadata, exception);
          if (zip) {
              return zip;
          }
          const stream = context.stream;
          const signature = [ 0x80, undefined, 0x8a, 0x0a, 0x6c, 0xfc, 0x9c, 0x46, 0xf9, 0x20, 0x6a, 0xa8, 0x50, 0x19 ];
          if (signature.length <= stream.length && stream.peek(signature.length).every((value, index) => signature[index] === undefined || signature[index] === value)) {
              return new pytorch.Container.Pickle(stream, exception);
          }
          const entries = context.entries('tar');
          if (entries.has('pickle')) {
              return new pytorch.Container.Tar(entries, exception);
          }
          return null;
      }
  };
  
  pytorch.Container.Tar = class {
  
      constructor(entries, exceptionCallback) {
          this._entries = entries;
          this._exceptionCallack = exceptionCallback;
      }
  
      get format() {
          return 'PyTorch v0.1.1';
      }
  
      get type() {
          this._unpickle();
          return this._type;
      }
  
      get data() {
          this._unpickle();
          return this._data;
      }
  
      get littleEndian() {
          this._unpickle();
          return this._littleEndian;
      }
  
      _unpickle() {
          if (!this._entries) {
              return;
          }
          this._type = '';
          this._data = null;
          this._littleEndian = true;
  
          const execution = new pytorch.Execution(null, this._exceptionCallback);
  
          const entries = {};
          for (const entry of this._entries) {
              switch (entry.name) {
                  case 'sys_info': entries.sys_info = entry.stream.peek(); break;
                  case 'pickle': entries.pickle = entry.stream.peek(); break;
                  case 'storages': entries.storages = entry.stream.peek(); break;
                  case 'tensors': entries.tensors = entry.stream.peek(); break;
              }
          }
  
          this._exceptionCallback = null;
          this._entries = null;
  
          if (entries.sys_info) {
              const unpickler = python.Unpickler.open(entries.sys_info);
              const sys_info = unpickler.load((name, args) => execution.invoke(name, args));
              if (sys_info.protocol_version != 1000) {
                  throw new pytorch.Error("Unsupported protocol version '" + sys_info.protocol_version + "'.");
              }
              if (sys_info.type_sizes &&
                  ((sys_info.type_sizes.int && sys_info.type_sizes.int != 4) ||
                  (sys_info.type_sizes.long && sys_info.type_sizes.long != 4) ||
                  (sys_info.type_sizes.short && sys_info.type_sizes.short != 2))) {
                  throw new pytorch.Error('Unsupported type sizes.');
              }
              this._littleEndian = sys_info.little_endian;
          }
  
          const deserialized_objects = {};
          if (entries.storages) {
              const unpickler = python.Unpickler.open(entries.storages);
              const num_storages = unpickler.load((name, args) => execution.invoke(name, args));
              for (let i = 0; i < num_storages; i++) {
                  const args = unpickler.load();
                  const key = args[0];
                  const storage_type = execution.type(args[2]);
                  const obj = storage_type._new_with_file(unpickler);
                  deserialized_objects[key] = obj;
              }
              /*
              let storage_views = unpickler.load();
              for target_cdata, root_cdata, offset, size in storage_views:
                  root = deserialized_objects[root_cdata]
                  deserialized_objects[target_cdata] = root[offset:offset + size]
              */
          }
  
          if (entries.tensors) {
              const unpickler = python.Unpickler.open(entries.tensors);
              const num_tensors = unpickler.load((name, args) => execution.invoke(name, args));
              for (let i = 0; i < num_tensors; i++) {
                  const args = unpickler.load();
                  const key = args[0];
                  const storage_id = args[1];
                  const storage = deserialized_objects[storage_id];
                  const ndim = unpickler.int32();
                  unpickler.read(4);
                  const shape = new Array(ndim);
                  for (let j = 0; j < ndim; j++) {
                      shape[j] = unpickler.int64();
                  }
                  const stride = new Array(ndim);
                  for (let j = 0; j < ndim; j++) {
                      stride[j] = unpickler.int64();
                  }
                  const storage_offset = unpickler.int64();
                  const tensor = execution.invoke('torch._utils._rebuild_tensor', [ storage, storage_offset, shape, stride ]);
                  deserialized_objects[key] = tensor;
              }
          }
  
          if (entries.pickle) {
              const unpickler = python.Unpickler.open(entries.pickle);
              const persistent_load = (saved_id) => {
                  return deserialized_objects[saved_id];
              };
              const obj = unpickler.load((name, args) => execution.invoke(name, args), persistent_load);
              const weights = pytorch.Utility.findWeights(obj);
              if (weights) {
                  this._type = 'weights';
                  this._data = weights;
              }
              else {
                  throw new pytorch.Error('File does not contain root module or state dictionary.');
              }
          }
      }
  };
  
  pytorch.Container.Pickle = class {
  
      constructor(stream, exception) {
          this._stream = stream;
          this._exceptionCallback = exception;
      }
  
      get format() {
          return 'PyTorch v0.1.10';
      }
  
      get type() {
          this._unpickle();
          return this._type;
      }
  
      get data() {
          this._unpickle();
          return this._data;
      }
  
      get littleEndian() {
          this._unpickle();
          return this._littleEndian;
      }
  
      _unpickle() {
          if (!this._stream) {
              return;
          }
  
          const execution = new pytorch.Execution(null, this._exceptionCallback);
          const unpickler = python.Unpickler.open(this._stream.length < 0x7ffff000 ? this._stream.peek() : this._stream);
  
          this._stream = null;
          this._exceptionCallback = null;
  
          unpickler.load(); // magic_number
          const protocol_version = unpickler.load();
          if (protocol_version != 1001) {
              throw new pytorch.Error("Unsupported protocol version '" + protocol_version + "'.");
          }
          const sys_info = unpickler.load();
          if (sys_info.protocol_version != 1001) {
              throw new pytorch.Error("Unsupported protocol version '" + sys_info.protocol_version + "'.");
          }
          this._littleEndian = sys_info.little_endian;
  
          const module_source_map = new Map();
          const deserialized_objects = new Map();
          const persistent_load = (saved_id) => {
              const typename = saved_id.shift();
              const data = saved_id;
              switch (typename) {
                  case 'module': {
                      const module = data[0];
                      const source = data[2];
                      module_source_map.set(module, source);
                      return data[0];
                  }
                  case 'storage': {
                      const data_type = execution.type(data.shift());
                      const root_key = data.shift();
                      data.shift(); // location
                      const size = data.shift();
                      const view_metadata = data.shift();
                      if (!deserialized_objects.has(root_key)) {
                          const obj = new data_type(size);
                          deserialized_objects.set(root_key, obj);
                      }
                      if (view_metadata) {
                          const view_key = view_metadata.shift();
                          view_metadata.shift(); // view_offset
                          view_metadata.shift(); // view_size
                          if (!deserialized_objects.has(view_key)) {
                              const view = null; // storage.slice(view_offset, view_offset + view_size);
                              deserialized_objects.set(view_key, view);
                          }
                          return deserialized_objects.get(view_key);
                      }
                      return deserialized_objects.get(root_key);
                  }
              }
              throw new pytorch.Error("Unknown persistent load type '" + typename + "'.");
          };
  
          const obj = unpickler.load((name, args) => execution.invoke(name, args), persistent_load);
          if (!obj) {
              throw new pytorch.Error('File format is not PyTorch.');
          }
          if (obj === 'None') {
              throw new pytorch.Error("File contains 'None' root object.");
          }
  
          const deserialized_storage_keys = unpickler.load();
          for (const deserialized_storage_key of deserialized_storage_keys) {
              const storage = deserialized_objects.get(deserialized_storage_key);
              storage._set_from_file(unpickler);
          }
  
          const root = pytorch.Utility.findModule(obj);
          if (root) {
              this._type = 'module';
              this._data = root;
          }
          else {
              const weights = pytorch.Utility.findWeights(obj);
              if (weights) {
                  this._type = 'weights';
                  this._data = weights;
              }
              else {
                  throw new pytorch.Error('File does not contain root module or state dictionary.');
              }
          }
      }
  };
  
  pytorch.Container.Zip = class {
  
      static open(entries, metadata, exception) {
          const name = Array.from(entries.keys()).find((name) => name == 'model.json' || name == 'data.pkl' || name.endsWith('/model.json') || name.endsWith('/data.pkl'));
          if (!name) {
              return null;
          }
          let model = null;
          if (name.endsWith('.json')) {
              try {
                  const stream = entries.get(name);
                  const buffer = stream.peek();
                  const decoder = new TextDecoder('utf-8');
                  const text = decoder.decode(buffer);
                  model = JSON.parse(text);
                  if (!model.mainModule) {
                      return null;
                  }
              }
              catch (error) {
                  return null;
              }
          }
          return new pytorch.Container.Zip(entries, name, model, metadata, exception);
      }
  
      constructor(entries, name, model, metadata, exception) {
          this._entries = entries;
          this._metadata = metadata;
          this._exceptionCallback = exception;
          // https://github.com/pytorch/pytorch/blob/master/torch/csrc/jit/docs/serialization.md
          this._model = model;
          const lastIndex = name.lastIndexOf('/');
          this._prefix = lastIndex === -1 ? '' : name.substring(0, lastIndex + 1);
      }
  
      get format() {
          if (this._format === undefined) {
              if (this._entry('model.json')) {
                  this._format = this._entry('attributes.pkl') ? 'TorchScript v1.1' : 'TorchScript v1.0';
              }
              else if (this._entry('data.pkl')) {
                  // https://github.com/pytorch/pytorch/blob/master/caffe2/serialize/inline_container.h
                  // kProducedFileFormatVersion
                  const versions = new Map([
                      [ '1', 'v1.3'  ],
                      [ '2', 'v1.5'  ], // 7a2889b014ce36fcc333b2c6de6f29f976652f84 (#28122)
                      [ '3', 'v1.6'  ], // 2ec6a30722b0ef85632a2f3e7ce6f80da403008a (#36085)
                      [ '4', 'v1.6'  ], // 95489b590f00801bdee7f41783f30874883cf6bb (#38620)
                      [ '5', 'v1.7'  ], // cb26661fe4faf26386703180a9045e6ac6d157df (#40364)
                      [ '6', 'v1.9+' ]  // 3ee7637ffa50df0d9b231c7b40778ac1c390bf4a (#59714)
                  ]);
                  const value = this.version;
                  if (!versions.has(value)) {
                      this._exceptionCallback(new pytorch.Error("Unsupported PyTorch Zip version '" + value + "'."));
                  }
                  const version = versions.get(value);
                  const constants = this._entry('constants.pkl');
                  this._format = (constants ? 'TorchScript' : 'PyTorch') + ' ' + (version || 'v-' + value.toString() );
              }
          }
          return this._format;
      }
  
      get version() {
          const stream = this._entry('version');
          if (stream) {
              const decoder = new TextDecoder('utf-8');
              const buffer = stream.peek();
              const value = decoder.decode(buffer);
              return value.split('\n').shift();
          }
          return '';
      }
  
      get producer() {
          return this.data ? this._producer : '';
      }
  
      get name() {
          return this._name;
      }
  
      get littleEndian() {
          return true;
      }
  
      get type() {
          this._load();
          return this._type;
      }
  
      get data() {
          this._load();
          return this._data;
      }
  
      get constants() {
          if (this._constants === undefined) {
              this._constants = [];
              const stream = this._entry('constants.pkl');
              if (stream) {
                  const buffer = stream.peek();
                  this._constants = this._unpickle(buffer, this._storage('constants'));
                  for (let i = 0; i < this._constants.length; i++) {
                      const constant = this._constants[i];
                      const variable = 'CONSTANTS.c' + i.toString();
                      if (pytorch.Utility.isTensor(constant)) {
                          constant.__variable__ = variable;
                      }
                      else if (constant && constant.__class__ && constant.__class__.__module__ === '__torch__.torch.classes.xnnpack') {
                          switch (constant.__class__.__name__) {
                              case 'LinearOpContext':
                              case 'Conv2dOpContext':
                                  if (pytorch.Utility.isTensor(constant[0])) {
                                      constant[0].__variable__ = variable + '.weight';
                                  }
                                  if (pytorch.Utility.isTensor(constant[1])) {
                                      constant[1].__variable__ = variable + '.bias';
                                  }
                                  break;
                              default:
                                  throw new pytorch.Error("Unsupported constant context '" + constant.__class__.__name__ + "'.");
                          }
                      }
                      else {
                          throw new pytorch.Error('Unsupported constant.');
                      }
                  }
              }
          }
          return this._constants;
      }
  
      get execution() {
          if (this._execution === undefined) {
              const sources = new Map();
              for (const entry of this._entries) {
                  const name = entry[0];
                  if (name.startsWith(this._prefix + 'code')) {
                      const file = name.substring(this._prefix.length);
                      if (sources.has(file)) {
                          throw new pytorch.Error("Duplicate source file '" + file + "'.");
                      }
                      const stream = entry[1];
                      const buffer = stream.peek();
                      sources.set(file, buffer);
                  }
              }
              this._execution = new pytorch.Container.Zip.Execution(sources, this._exceptionCallback, this._metadata);
              const constants = {};
              for (let i = 0; i < this.constants.length; i++) {
                  constants['c' + i.toString()] = this.constants[i];
              }
              this._execution.context.set('CONSTANTS', constants);
          }
          return this._execution;
      }
  
      _entry(name) {
          return this._entries.get(this._prefix + name);
      }
  
      _load() {
          if (this._data === undefined) {
              this._data = null;
              const stream = this._entry('data.pkl');
              if (stream) {
                  const buffer = stream.peek();
                  this._data = this._unpickle(buffer, this._storage('data'));
              }
              else {
                  if (this._model) {
                      this._producer = this._model.producerName + (this._model.producerVersion ? ' v' + this._model.producerVersion : '');
                      this._data = this._model.mainModule || {};
                      this._name = this._data.name || '';
                      if (this._data.torchscriptArena) {
                          this._torchscriptArena = this._data.torchscriptArena.key;
                      }
                      const queue = [ this._data ];
                      const entries = new Map();
                      for (const entry of this._entries) {
                          const name = entry[0];
                          const stream = entry[1];
                          const buffer = stream.peek();
                          entries.set(name, buffer);
                      }
                      const tensorTypeMap = new Map([
                          [ 'FLOAT', 'Float' ],
                          [ 'FLOAT16', 'Half' ],
                          [ 'DOUBLE', 'Double' ],
                          [ 'INT8', 'Char' ],
                          [ 'INT32', 'Int' ],
                          [ 'INT64', 'Long' ]
                      ]);
                      const constants = this._model.tensors || [];
                      this._constants = constants.map((constant) => {
                          const key = this._prefix + constant.data.key;
                          if (!tensorTypeMap.has(constant.dataType)) {
                              throw new pytorch.Error("Unknown tensor data type '" + constant.dataType + "'.");
                          }
                          const type = tensorTypeMap.get(constant.dataType);
                          const shape = constant.dims ? constant.dims.map((dim) => parseInt(dim, 10)) : null;
                          const storage_type = this.execution.type('torch.' + type + 'Storage');
                          const size = (shape || []).reduce((a, b) => a * b, 1);
                          const offset = parseInt(constant.offset, 10) || 0;
                          const storage = new storage_type([ size ]);
                          const itemsize = storage.dtype.itemsize();
                          const buffer = entries.get(key);
                          const length = size * itemsize;
                          const data = buffer.slice(offset, offset + length);
                          storage._set_cdata(data);
                          const tensor = this.execution.invoke('torch._utils._rebuild_tensor', [ storage, 0, shape, 0 ]);
                          tensor.name = constant.data.key;
                          return tensor;
                      });
                      this._attributes = [];
                      const stream = this._entry('attributes.pkl');
                      if (stream) {
                          const buffer = stream.peek();
                          const unpickler = python.Unpickler.open(buffer);
                          this._attributes.push(...unpickler.load((name, args) => this.execution.invoke(name, args)));
                      }
                      while (queue.length > 0) {
                          const module = queue.shift();
                          if (!module.__class__) {
                              module.__class__ = {
                                  __module__: 'torch.nn.modules.module',
                                  __name__: 'Module'
                              };
                          }
                          if (module.name) {
                              module.__id__ = module.name;
                          }
                          if (module.submodules) {
                              for (const submodule of module.submodules) {
                                  module[submodule.name] = submodule;
                                  submodule.__parent__ = module;
                                  queue.push(submodule);
                              }
                              delete module.submodules;
                          }
                          const attributes = [];
                          if (module.attributes) {
                              attributes.push(...module.attributes);
                              delete module.attributes;
                          }
                          const parameters = [];
                          if (module.parameters) {
                              parameters.push(...module.parameters);
                              delete module.parameters;
                          }
                          if (module.arguments) {
                              parameters.push(...module.arguments);
                              delete module.arguments;
                          }
                          for (const parameter of parameters) {
                              const tensor = this._constants[parameter.tensorId];
                              module[parameter.name] = tensor;
                              if (!parameter.__class__) {
                                  parameter.__class__ = {
                                      __module__: 'torch',
                                      __name__: 'Tensor'
                                  };
                              }
                          }
                          for (const attribute of attributes) {
                              module[attribute.name] = this._attributes[attribute.id];
                          }
                      }
                      delete this._model;
                  }
              }
              if (this.format.startsWith('TorchScript ')) {
                  this._type = 'script';
              }
              else {
                  const obj = this._data;
                  const root = pytorch.Utility.findModule(obj);
                  if (root) {
                      this._type = 'module';
                      this._data = root;
                  }
                  else {
                      const weights = pytorch.Utility.findWeights(obj);
                      if (weights) {
                          this._type = 'weights';
                          this._data = weights;
                      }
                      else {
                          throw new pytorch.Error('File does not contain root module or state dictionary.');
                      }
                  }
              }
          }
      }
  
      _unpickle(data, storage_map) {
          const loaded_storages = new Map();
          const persistent_load = (saved_id) => {
              const typename = saved_id.shift();
              if (typename !== 'storage') {
                  throw new pytorch.Error("Unknown persistent load type '" + typename + "'.");
              }
              const data_type = this.execution.type(saved_id.shift());
              const root_key = saved_id.shift();
              /* const location = */ saved_id.shift();
              const size = saved_id.shift();
              if (!loaded_storages.has(root_key)) {
                  const storage = new data_type(size);
                  storage._set_cdata(storage_map.get(root_key));
                  loaded_storages.set(root_key, storage);
              }
              const storage = loaded_storages.get(root_key);
              const view_metadata = saved_id.shift();
              if (view_metadata) {
                  const view_key = view_metadata.shift();
                  view_metadata.shift(); // view_offset
                  view_metadata.shift(); // view_size
                  let view = null;
                  if (loaded_storages.has(view_key)) {
                      view = loaded_storages.get(root_key);
                  }
                  else {
                      view = null; // storage.slice(view_offset, view_offset + view_size);
                      loaded_storages.set(view_key, view);
                  }
                  return view;
              }
              return storage;
          };
          const unpickler = python.Unpickler.open(data);
          return unpickler.load((name, args) => this.execution.invoke(name, args), persistent_load);
      }
  
      _storage(dirname) {
          const map = new Map();
          const prefix = this._prefix + dirname + '/';
          for (const entry of this._entries) {
              if (entry[0].startsWith(prefix)) {
                  const key = entry[0].substring(prefix.length);
                  const buffer = entry[1].peek();
                  map.set(key, buffer);
              }
          }
          return map;
      }
  
      trace() {
          this._inputs = [];
          this._outputs = [];
          this.execution.reset();
          if (this._torchscriptArena) {
              const program = this.execution.parse(this._torchscriptArena);
              for (const statement of program.body) {
                  if (statement.type == 'def') {
                      const self = this;
                      const globals = this.execution.context;
                      const func = {
                          __class__: this.execution.context.scope.builtins.function,
                          __name__: statement.name,
                          __code__: statement,
                          __call__: function(args) {
                              return self.execution.apply(this.__code__, args, globals);
                          }
                      };
                      this.data[statement.name] = func;
                  }
              }
          }
          if (this.data.forward) {
              const args = [ this.data ]; // self
              if (this.data.forward.__code__ && this.data.forward.__code__.parameters) {
                  for (const parameter of this.data.forward.__code__.parameters) {
                      const defaultValue = (type, name) => {
                          if (type.type === 'type' && type.name.type) {
                              switch (type.name.value) {
                                  case 'Tensor': {
                                      const tensor = this.execution.invoke('torch.Tensor', []);
                                      tensor.__variable__ = name;
                                      tensor.__origin__ = 'graph-input';
                                      return tensor;
                                  }
                                  case 'Tuple':
                                      return type.arguments.map((type, index) => defaultValue(type, name + '[' + index.toString() + ']'));
                                  case 'List':
                                      return type.arguments.map((type, index) => defaultValue(type, name + '[' + index.toString() + ']' ));
                                  case 'Dict':
                                      return {};
                                  case 'int':
                                      return 0;
                                  case 'float':
                                      return 0.0;
                                  case 'bool':
                                      return false;
                                  case 'Optional':
                                      return undefined;
                              }
                          }
                          throw new pytorch.Error("Unknown function parameter type '" + JSON.stringify(type) + "'.");
                      };
                      if (parameter.name !== 'self') {
                          const type = parameter.parameterType;
                          const value = defaultValue(type, parameter.name);
                          if (pytorch.Utility.isTensor(value)) {
                              value.__variable__ = parameter.name;
                              value.__origin__ = 'graph-input';
                              this._inputs.push(parameter.name);
                          }
                          args.push(value);
                      }
                  }
              }
              const result = this.data.forward.__call__(args);
              if (Array.isArray(result)) {
                  for (const output of result) {
                      if (pytorch.Utility.isTensor(output)) {
                          this._outputs.push(output.__variable__);
                      }
                  }
              }
              else if (pytorch.Utility.isTensor(result)) {
                  this._outputs.push(result.__variable__);
              }
              else if (Object(result) === result) {
                  for (const key of Object.keys(result)) {
                      const value = result[key];
                      if (Array.isArray(value)) {
                          for (const output of value) {
                              if (pytorch.Utility.isTensor(output)) {
                                  this._outputs.push(output.__variable__);
                              }
                          }
                      }
                      else if (pytorch.Utility.isTensor(value)) {
                          this._outputs.push(value.__variable__);
                      }
                  }
              }
              this._nodes = this.execution.nodes;
              return true;
          }
          throw new pytorch.Error("Module 'forward' not implemented.");
      }
  
      get inputs() {
          return this._inputs;
      }
  
      get outputs() {
          return this._outputs;
      }
  
      get nodes() {
          return this._nodes;
      }
  };
  
  pytorch.Container.Zip.Execution = class extends pytorch.Execution {
  
      constructor(sources, exceptionCallback, metadata) {
          super(sources, exceptionCallback);
          this._metadata = metadata;
          this.reset();
      }
  
      reset() {
          this._nodes = [];
          this._variableIndex = 0;
      }
  
      get nodes() {
          return this._nodes;
      }
  
      call(target, name, args, context) {
          let resolvedTarget = pytorch.Utility.target(target);
          let outputTypes = null;
          if (resolvedTarget && resolvedTarget + '.' + name === 'ops.prim.NumToTensor' &&
              args.length === 1 && args[0].type === 'call' && args[0].target.member.type == 'id') {
              const innerCall = args[0];
              resolvedTarget = pytorch.Utility.target(innerCall.target.target);
              name = innerCall.target.member.value;
              args = innerCall.arguments;
              outputTypes = [ 'int64' ];
          }
          if (resolvedTarget) {
              const type = resolvedTarget + '.' + name;
              // https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/native_functions.yaml
              let schemas = this._metadata.type(type);
              if (schemas) {
                  schemas = !Array.isArray(schemas) ? [ schemas ] : schemas;
                  const evalArgs = args.map((argument) => argument.type === '=' && argument.target && argument.target.type === 'id' ? this.expression(argument.expression, context) : this.expression(argument, context));
                  for (const schema of schemas) {
                      const copyArgs = Array.prototype.slice.call(args);
                      const copyEvalArgs = Array.prototype.slice.call(evalArgs);
                      const node = {
                          type: schema.name,
                          inputs: [],
                          attributes: [],
                          outputs: []
                      };
                      const referencedParameters = [];
                      let next = false;
                      const parameters = Array.prototype.slice.call(schema.inputs || []).concat(Array.prototype.slice.call(schema.attributes || []));
                      while (copyEvalArgs.length > 0) {
  
                          if (parameters.length <= 0) {
                              next = true;
                              break;
                          }
  
                          const paramsBase = copyEvalArgs[0];
                          if (paramsBase && paramsBase.__class__ && paramsBase.__class__.__module__ === '__torch__.torch.classes.quantized') {
                              switch (paramsBase.__class__.__name__) {
                                  case 'Conv2dPackedParamsBase':
                                  case 'Conv3dPackedParamsBase': {
                                      copyArgs.shift();
                                      copyEvalArgs.shift();
                                      copyArgs.unshift({ type: null });
                                      copyEvalArgs.unshift(paramsBase.bias);
                                      copyArgs.unshift({ type: null });
                                      copyEvalArgs.unshift(paramsBase.weight);
                                      break;
                                  }
                                  case 'LinearPackedParamsBase': {
                                      copyArgs.shift();
                                      copyEvalArgs.shift();
                                      copyArgs.unshift({ type: null });
                                      copyEvalArgs.unshift(paramsBase.bias);
                                      copyArgs.unshift({ type: null });
                                      copyEvalArgs.unshift(paramsBase.weight);
                                      break;
                                  }
                                  default:
                                      throw new pytorch.Error("Unsupported type '" + paramsBase.__name__ + "'.");
                              }
                          }
                          const op_context = copyEvalArgs[0];
                          if (op_context && op_context.__class__ && op_context.__class__.__module__ === '__torch__.torch.classes.xnnpack') {
                              switch (op_context.__class__.__name__) {
                                  case 'LinearOpContext':
                                  case 'Conv2dOpContext':
                                      copyArgs.shift();
                                      copyEvalArgs.shift();
                                      for (const key of Object.keys(op_context).filter((key) => Number.isInteger(parseInt(key, 10)))) {
                                          copyArgs.push({ type: null });
                                          copyEvalArgs.push(op_context[key]);
                                      }
                                      break;
                                  default:
                                      throw new pytorch.Error("Unsupported type '" + paramsBase.__name__ + "'.");
                              }
                          }
  
                          if (copyArgs.every((arg) => arg.type === '=' && arg.target && arg.target.type === 'id') &&
                              parameters.every((parameter) => parameter.type !== 'Tensor' && parameter.type !== 'Tensor[]')) {
                              const map = new Map();
                              for (const parameter of parameters) {
                                  map.set(parameter.name, parameter);
                              }
                              while (copyArgs.length > 0) {
                                  const argument = copyArgs.shift();
                                  const value = copyEvalArgs.shift();
                                  const parameter = map.get(argument.target.value);
                                  if (!parameter) {
                                      next = true;
                                      break;
                                  }
                                  if (!pytorch.Utility.isType(value, parameter.type)) {
                                      if (parameter.optional) {
                                          continue;
                                      }
                                      next = true;
                                      break;
                                  }
                                  node.attributes.push({ name: parameter.name, value: value });
                              }
                              continue;
                          }
                          if (next) {
                              break;
                          }
  
                          const parameter = parameters.shift();
                          const argument = copyEvalArgs[0];
  
                          switch (parameter.type) {
                              case 'Tensor': {
                                  if (Array.isArray(argument) || (!pytorch.Utility.isTensor(argument) && argument !== null && argument !== undefined)) {
                                      if (parameter.optional) {
                                          if (argument === undefined) {
                                              copyArgs.shift();
                                              copyEvalArgs.shift();
                                          }
                                          continue;
                                      }
                                      next = true;
                                      break;
                                  }
                                  copyArgs.shift();
                                  copyEvalArgs.shift();
                                  const item = (argument === null || argument === undefined) ? {} : argument;
                                  item.__variable__ = item.__variable__ || this.variable();
                                  const inputs = [];
                                  inputs.push({ id: item.__variable__ });
                                  referencedParameters.push(item);
                                  node.inputs.push(inputs);
                                  break;
                              }
                              case 'Tensor[]': {
                                  const argument = copyEvalArgs[0];
                                  if (!Array.isArray(argument) || !argument.every((item) => pytorch.Utility.isTensor(item) || item === null)) {
                                      if (parameter.optional) {
                                          continue;
                                      }
                                      next = true;
                                      break;
                                  }
                                  copyArgs.shift();
                                  copyEvalArgs.shift();
                                  const inputs = [];
                                  for (let item of argument) {
                                      if (item === null) {
                                          item = {};
                                      }
                                      item.__variable__ = item.__variable__ || this.variable();
                                      inputs.push({ id: item.__variable__ });
                                      referencedParameters.push(item);
                                  }
                                  node.inputs.push(inputs);
                                  break;
                              }
                              default: {
                                  const arg = copyArgs[0];
                                  if (!pytorch.Utility.isType(argument, parameter.type) && argument !== null) {
                                      if (parameter.optional) {
                                          continue;
                                      }
                                      next = true;
                                      break;
                                  }
                                  if (arg.type !== '=') {
                                      copyArgs.shift();
                                      copyEvalArgs.shift();
                                      node.attributes.push({ name: parameter.name, value: argument });
                                  }
                                  else {
                                      throw new pytorch.Error('Expected named argument.');
                                  }
                                  break;
                              }
                          }
                          if (next) {
                              break;
                          }
                      }
                      if (next) {
                          continue;
                      }
                      const result = [];
                      for (let i = 0; i < schema.outputs.length; i++) {
                          const parameter = schema.outputs[i];
                          switch (parameter.type) {
                              case 'Tensor': {
                                  const parameter = this.invoke('torch.Tensor', []);
                                  parameter.__origin__ = type;
                                  if (i === 0) {
                                      switch (type) {
                                          case 'torch.cat':
                                          case 'torch.conv2d':
                                          case 'torch.dropout':
                                          case 'torch.flatten':
                                          case 'torch.max_pool2d':
                                          case 'torch.adaptive_avg_pool2d':
                                          case 'torch.avg_pool2d':
                                          case 'torch.quantize_per_tensor':
                                          case 'torch.relu_':
                                          case 'torch.hardtanh_':
                                          case 'torch.unsqueeze':
                                          case 'torch.slice': {
                                              parameter.resize_([ NaN, NaN, NaN, NaN ]);
                                              break;
                                          }
                                          case 'torch.conv3d': {
                                              parameter.resize_([ NaN, NaN, NaN, NaN, NaN ]);
                                              break;
                                          }
                                          case 'torch.embedding': {
                                              parameter.resize_([ NaN, NaN, NaN ]);
                                              break;
                                          }
                                          case 'torch.mean':
                                          case 'torch.mul':
                                          case 'torch.add':
                                          case 'torch.batch_norm':
                                          case 'torch.relu': {
                                              const input = this.expression(args[0], context);
                                              if (pytorch.Utility.isTensor(input) && Array.isArray(input.size())) {
                                                  parameter.resize_(input.size());
                                              }
                                              break;
                                          }
                                          case 'torch.ones':
                                          case 'torch.zeros':
                                          case 'torch.zeros_like': {
                                              parameter.resize_(this.expression(args[0], context));
                                              break;
                                          }
                                          case 'torch.new_full': {
                                              parameter.resize_(this.expression(args[1], context));
                                              break;
                                          }
                                          case 'ops.quantized.cat':
                                          case 'ops.quantized.cat_relu':
                                          case 'ops.quantized.linear':
                                          case 'ops.quantized.conv2d':
                                          case 'ops.quantized.conv2d_relu':
                                          case 'ops.quantized.add_relu':
                                              parameter.resize_([ NaN, NaN, NaN, NaN ]);
                                              break;
                                          case 'torch.view':
                                              parameter.resize_(this.expression(args[1], context));
                                              break;
                                      }
                                  }
                                  parameter.__variable__ = this.variable();
                                  result.push(parameter);
                                  node.outputs.push([ { id: parameter.__variable__ } ]);
                                  break;
                              }
                              case 'Tensor[]': {
                                  let count = 1;
                                  switch (type) {
                                      case 'torch.chunk':
                                          count = node.attributes.filter((attribute) => attribute.name == 'chunks')[0].value;
                                          break;
                                      case 'torch.meshgrid':
                                          count = node.inputs[0].length;
                                          break;
                                      case 'torch.unbind':
                                          count = args[0].__tuple__ || count;
                                          break;
                                  }
                                  const tensors = [];
                                  const outputs = [];
                                  for (let i = 0; i < count; i ++) {
                                      const tensor = this.invoke('torch.Tensor', []);
                                      tensor.__origin__ = type;
                                      tensor.__variable__ = this.variable();
                                      tensors.push(tensor);
                                      outputs.push({ id: tensor.__variable__ });
                                  }
                                  result.push(tensors);
                                  node.outputs.push(outputs);
                                  break;
                              }
                              default: {
                                  if (!outputTypes || schema.outputs.length !== 1 || schema.outputs[0].type !== outputTypes[0]) {
                                      next = true;
                                      break;
                                  }
                                  const tensor = this.invoke('torch.Tensor', []);
                                  tensor.resize_([]);
                                  tensor.__origin__ = type;
                                  tensor.__variable__ = this.variable();
                                  result.push(tensor);
                                  node.outputs.push([ { id: tensor.__variable__ } ]);
                                  break;
                              }
                          }
                      }
                      if (next) {
                          continue;
                      }
                      for (const parameter of referencedParameters) {
                          parameter.__count__ = (parameter.__count__ || 0) + 1;
                      }
                      this.push(node);
                      if (result.length > 1) {
                          return result;
                      }
                      return result[0];
                  }
              }
          }
          return super.call(target, name, args, context);
      }
  
      block(statements, context) {
          statements = Array.prototype.slice.call(statements);
          while (statements.length > 0) {
              if (statements.length > 1) {
                  const assign = statements[0];
                  const condition = statements[1];
                  // _x = torch.ne(torch.len(torch.size(input)), 5)
                  // if _x:
                  //   ops.prim.RaiseException(...)
                  if (assign.type === '=' &&
                      condition.type === 'if' &&
                      pytorch.Utility.isEqual(assign.target, condition.condition) &&
                      pytorch.Utility.isCall(assign.expression, 'torch.ne', 2) &&
                      pytorch.Utility.isCall(assign.expression.arguments[0], 'torch.len', 1) &&
                      pytorch.Utility.isCall(assign.expression.arguments[0].arguments[0], 'torch.size', 1) &&
                      condition.then.statements.length == 1 &&
                      pytorch.Utility.isCall(condition.then.statements[0], 'ops.prim.RaiseException', 1)) {
                      const tensor = this.expression(assign.expression.arguments[0].arguments[0].arguments[0], context);
                      if (tensor && tensor.size) {
                          const number = this.expression(assign.expression.arguments[1], context);
                          const size = tensor.size();
                          if (size && size.length && size.length !== number &&
                              size.every((item) => isNaN(item)) && number >= 3 && number <= 5) {
                              if (tensor.__origin__ === 'torch.quantize_per_tensor') {
                                  tensor.resize_(Array(number).fill(NaN));
                              }
                          }
                      }
                  }
                  // _0 = torch.eq(torch.len(torch.size(x)), 2)
                  // if _0:
                  //   pass
                  // else:
                  //   ops.prim.RaiseException("AssertionError: ")
                  if (assign.type === '=' &&
                      condition.type === 'if' &&
                      pytorch.Utility.isEqual(assign.target, condition.condition) &&
                      pytorch.Utility.isCall(assign.expression, 'torch.eq', 2) &&
                      pytorch.Utility.isCall(assign.expression.arguments[0], 'torch.len', 1) &&
                      pytorch.Utility.isCall(assign.expression.arguments[0].arguments[0], 'torch.size', 1) &&
                      condition.else.statements.length == 1 &&
                      pytorch.Utility.isCall(condition.else.statements[0], 'ops.prim.RaiseException', 1)) {
                      const tensor = this.expression(assign.expression.arguments[0].arguments[0].arguments[0], context);
                      if (tensor && tensor.shape === undefined) {
                          const number = this.expression(assign.expression.arguments[1], context);
                          tensor.resize_(Array(number).fill(NaN));
                      }
                  }
              }
              const statement = statements.shift();
              // input_shape = torch.slice(torch.size(x), -2, 9223372036854775807, 1)
              if (statement.type === '=' &&
                  pytorch.Utility.isCall(statement.expression, 'torch.slice', 4) &&
                  pytorch.Utility.isCall(statement.expression.arguments[0], 'torch.size', 1)) {
                  const tensor = this.expression(statement.expression.arguments[0].arguments[0], context);
                  if (tensor && tensor.shape === undefined) {
                      tensor.resize_([ 1, 3, 299, 299 ]);
                  }
              }
              // torch.slice(ops.prim.shape(input), 0, 2, 1)
              if (statement.type === '=' &&
                  pytorch.Utility.isCall(statement.expression, 'torch.slice', 4) &&
                  pytorch.Utility.isCall(statement.expression.arguments[0], 'ops.prim.shape', 1)) {
                  const tensor = this.expression(statement.expression.arguments[0].arguments[0], context);
                  if (tensor && tensor.__origin__ === 'graph-input' && tensor.shape === undefined) {
                      tensor.resize_([ NaN, NaN, NaN, NaN ]);
                  }
              }
              // _3 = torch.le(xxxx, torch.dim(f0))
              if (statement.type === '=' &&
                  pytorch.Utility.isCall(statement.expression, 'torch.le', 2) &&
                  pytorch.Utility.isCall(statement.expression.arguments[1], 'torch.dim', 1)) {
                  const tensor = this.expression(statement.expression.arguments[1].arguments[0], context);
                  if (tensor && tensor.__origin__ === 'graph-input' && tensor.shape === undefined) {
                      tensor.resize_([ NaN, NaN, NaN, NaN ]);
                  }
              }
              // if torch.ne(torch.dim(image), 3):
              //   xxxx
              //   ops.prim.RaiseException(_7)
              if (statement.type === 'if' &&
                  pytorch.Utility.isCall(statement.condition, 'torch.ne', 2) &&
                  pytorch.Utility.isCall(statement.condition.arguments[0], 'torch.dim', 1) &&
                  statement.then.statements.length > 0 &&
                  pytorch.Utility.isCall(statement.then.statements.slice(-1).pop(), 'ops.prim.RaiseException', 1)) {
                  const tensor = this.expression(statement.condition.arguments[0].arguments[0], context);
                  const size = this.expression(statement.condition.arguments[1], context);
                  if (tensor && Number.isInteger(size) && size < 10) {
                      tensor.resize_(Array.isArray(tensor.shape) && tensor.shape.length > size ? tensor.shape.slice(-size) : Array(size).fill(NaN));
                  }
              }
              // dim = torch.sub(torch.dim(input), 2)
              if (statement.type === '=' &&
                  statement.target.type === 'id' && statement.target.value === 'dim' &&
                  pytorch.Utility.isCall(statement.expression, 'torch.sub', 2) &&
                  pytorch.Utility.isCall(statement.expression.arguments[0], 'torch.dim', 1)) {
                  const tensor = this.expression(statement.expression.arguments[0].arguments[0], context);
                  if (tensor && tensor.__origin__ === 'graph-input' && tensor.shape === undefined) {
                      tensor.resize_([ NaN, NaN, NaN, NaN ]);
                  }
              }
              // a, b = torch.unbind(size, 0)
              if (statement.type === '=' &&
                  statement.target.type === 'tuple' &&
                  pytorch.Utility.isCall(statement.expression, 'torch.unbind', 2)) {
                  statement.expression.arguments[0].__tuple__ = statement.target.value.length;
              }
              // x = torch.len(input)
              if (statement.type === '=' &&
                  statement.target.type === 'id' &&
                  pytorch.Utility.isCall(statement.expression, 'torch.len', 1)) {
                  const tensor = this.expression(statement.expression.arguments[0], context);
                  if (tensor && tensor.__origin__ === 'graph-input' && tensor.shape === undefined) {
                      tensor.resize_([ NaN, NaN, NaN, NaN ]);
                  }
              }
              const value = this.statement(statement, context);
              if (value !== undefined) {
                  return value;
              }
          }
      }
  
      push(node) {
          this._nodes.push(node);
      }
  
      variable() {
          this._variableIndex++;
          return this._variableIndex.toString();
      }
  };
  
  pytorch.ScalarType = {
      uint8: 0,
      int8: 1,
      int16: 2,
      int32: 3,
      int64: 4,
      float16: 5,
      float32: 6,
      float64: 7,
      complex32: 8,
      complex64: 9,
      complex128: 10,
      boolean: 11,
      qint8: 12,
      quint8: 13,
      qint32: 14,
      bfloat16: 15,
      quint4x2: 16
  };
  
  pytorch.MemoryFormat = {
      Contiguous: 0,
      Preserve: 1,
      ChannelsLast: 2,
      ChannelsLast3d: 3
  };
  
  pytorch.Layout = {
      Strided: 0,
      Sparse: 1,
      Mkldnn: 2
  };
  
  pytorch.Utility = class {
  
      static getScalarType(scalarType) {
          if (!pytorch.Utility._scalarTypes) {
              pytorch.Utility._scalarTypes = [
                  { name: 'uint8', itemsize: 1 },
                  { name: 'int8', itemsize: 1 },
                  { name: 'int16', itemsize: 2 },
                  { name: 'int32', itemsize: 4 },
                  { name: 'int64', itemsize: 8 },
                  { name: 'float16', itemsize: 2 },
                  { name: 'float32', itemsize: 4 },
                  { name: 'float64', itemsize: 8 },
                  { name: 'complex32', itemsize: 4 },
                  { name: 'complex64', itemsize: 8 },
                  { name: 'complex128', itemsize: 16 },
                  { name: 'boolean', itemsize: 1 },
                  { name: 'qint8', itemsize: 1 },
                  { name: 'quint8', itemsize: 1 },
                  { name: 'qint32', itemsize: 4 },
                  { name: 'bfloat16', itemsize: 2 },
                  { name: 'quint4x2' }
              ];
          }
          if (scalarType < pytorch.Utility._scalarTypes.length) {
              return pytorch.Utility._scalarTypes[scalarType];
          }
          throw new pytorch.Error("Unknown scalar type '" + scalarType + "'.");
      }
  
      static target(expression) {
          if (expression.type == 'id') {
              return expression.value;
          }
          if (expression.type == '.') {
              return pytorch.Utility.target(expression.target) + '.' + pytorch.Utility.target(expression.member);
          }
          return null;
      }
  
      static isTensor(obj) {
          if (obj && obj.__class__) {
              switch (obj.__class__.__module__) {
                  case 'torch':
                  case 'torch.cuda':
                      return obj.__class__.__name__.endsWith('Tensor');
                  case 'torch.nn.parameter':
                      return obj.__class__.__name__ === 'Parameter';
              }
          }
          return false;
      }
  
      static toTensor(obj) {
          if (obj && obj.__class__) {
              switch (obj.__class__.__module__) {
                  case 'torch':
                  case 'torch.cuda':
                      return obj.__class__.__name__.endsWith('Tensor') ? obj : null;
                  case 'torch.nn.parameter':
                      return obj.__class__.__name__ === 'Parameter' ? obj.data : null;
              }
          }
          return null;
      }
  
      static isType(obj, type) {
          switch (type) {
              case 'Tensor':
                  return !Array.isArray(obj) && (pytorch.Utility.isTensor(obj) || obj === null);
              case 'Tensor[]':
                  return Array.isArray(obj) && obj.length > 0 && obj.every((tensor) => pytorch.Utility.isTensor(tensor) || tensor === null);
              case 'Scalar':
                  return (obj !== null && obj !== Object(obj)) || (pytorch.Utility.isTensor(obj) && Array.isArray(obj.size()) && obj.size().length === 0);
              case 'boolean':
                  return obj === true || obj === false;
              case 'int64':
                  return Number.isInteger(obj) || obj instanceof base.Int64 || (typeof obj === 'number' && isNaN(obj));
              case 'int64[]':
                  return Array.isArray(obj) && obj.every((item) => Number.isInteger(item) || (typeof item === 'number' && isNaN(item)) || item === undefined);
              case 'int64[1]':
                  return pytorch.Utility.isType(obj, 'int64') || pytorch.Utility.isType(obj, 'int64[]');
              case 'float32':
              case 'float64':
                  return obj !== null && obj !== Object(obj);
              case 'Layout':
              case 'ScalarType':
              case 'MemoryFormat':
                  return Number.isInteger(obj) || obj === null;
              case 'Device':
                  return obj === null || obj === Object(obj);
          }
          return true;
      }
  
      static isCall(expression, name, size) {
          if (expression.type === 'call' &&
              expression.arguments.length === size &&
              pytorch.Utility.target(expression.target) === name) {
              return true;
          }
          return false;
      }
  
      static isEqual(a, b) {
          return (a.type === 'id' && b.type === 'id' && a.value === b.value);
      }
  
      static findModule(root) {
          if (root) {
              const keys = [ '', 'model', 'net' ];
              for (const key of keys) {
                  const obj = key === '' ? root : root[key];
                  if (obj) {
                      if (obj._modules) {
                          return [ { name: '', obj: obj } ];
                      }
                      const objKeys = Object.keys(obj).filter((key) => obj[key] && obj[key]._modules);
                      if (objKeys.length > 1) {
                          return objKeys.map((key) => { return { name: key, obj: obj[key] }; });
                      }
                  }
              }
          }
          return null;
      }
  
      static findWeights(root) {
          if (!root) {
              return null;
          }
          if (root instanceof Map) {
              const obj = {};
              for (const pair of root) {
                  const key = pair[0];
                  const value = pair[1];
                  obj[key] = value;
              }
              root = obj;
          }
          const keys = root && !Array.isArray(root) ? Object.keys(root) : [];
          if (keys.length > 1) {
              keys.splice(0, keys.length);
          }
          keys.push(...[
              'state_dict', 'state', 'model_state', 'model', 'model_state_dict', 'model_dict', 'net_dict', 'params', 'generator',
              'discriminator', 'g_state', 'network', 'net', 'netG', 'net_states', 'state_dict_stylepredictor', 'state_dict_ghiasi', 'runner', ''
          ]);
          for (const key of keys) {
              const obj = key === '' ? root : root[key];
              let graphs = null;
              graphs = graphs || pytorch.Utility._convertTensor(obj);
              graphs = graphs || pytorch.Utility._convertObjectList(obj);
              graphs = graphs || pytorch.Utility._convertStateDict(obj);
              if (graphs) {
                  return graphs;
              }
          }
          return null;
      }
  
      static _convertTensor(obj) {
          if (obj && pytorch.Utility.isTensor(obj)) {
              const layers = [];
              const argument = { id: '', value: obj };
              const parameter = { name: 'value', arguments: [ argument ] };
              layers.push({ states: [ parameter ] });
              return [ { layers: layers } ];
          }
          return null;
      }
  
      static _convertObjectList(list) {
          if (list && Array.isArray(list) && list.every((obj) => obj && Object.keys(obj).filter((key) => pytorch.Utility.isTensor(obj[key]).length > 0))) {
              const layers = [];
              for (const obj of list) {
                  const type = obj.__class__ ? obj.__class__.__module__ + '.' + obj.__class__.__name__ : '?';
                  const layer = { type: type, states: [], attributes: [] };
                  for (const key of Object.keys(obj)) {
                      const value = obj[key];
                      if (pytorch.Utility.isTensor(value)) {
                          layer.states.push({ name: key, arguments: [ { id: '', value: value } ] });
                      }
                      else {
                          layer.attributes.push({ name: key, value: value });
                      }
                  }
                  layers.push(layer);
              }
              return [ { layers: layers } ];
          }
          return null;
      }
  
      static _convertStateDict(obj) {
          const clean = (obj) => {
              if (obj && Array.isArray(obj)) {
                  return obj;
              }
              if (obj && obj instanceof Map) {
                  return obj;
              }
              if (obj && Object(obj) === obj) {
                  const integer = new Set([ 'epoch', 'i_batch', 'num_vid', 'seen' ]);
                  const target = {};
                  for (const key of Object.keys(obj)) {
                      const value = obj[key];
                      if (key.indexOf('optim') !== -1 || key.indexOf('opt') !== -1) {
                          if (value === null || (value.state && value.param_groups)) {
                              continue;
                          }
                      }
                      if (key.indexOf('loss') !== -1 && Array.isArray(value)) {
                          continue;
                      }
                      if (integer.has(key) && Number.isInteger(value)) {
                          continue;
                      }
                      target[key] = value;
                  }
                  return target;
              }
              return obj;
          };
          const validate = (map) => {
              let tensor = false;
              if (map && map instanceof Map) {
                  for (const pair of map) {
                      const key = pair[0];
                      const value = pair[1];
                      if (key.split('.').pop() === '_metadata') {
                          continue;
                      }
                      if (pytorch.Utility.isTensor(value)) {
                          tensor = true;
                          continue;
                      }
                      else if (value && Array.isArray(value) && value.every((item) => pytorch.Utility.isTensor(item))) {
                          tensor = true;
                          continue;
                      }
                      else if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
                          continue;
                      }
                      return false;
                  }
              }
              return tensor;
          };
          const flatten = (obj) => {
              if (!obj || Array.isArray(obj)) {
                  return null;
              }
              if (obj instanceof Map) {
                  if (validate(obj)) {
                      return obj;
                  }
                  return null;
              }
              if (Object(obj) !== obj) {
                  return null;
              }
              const map = new Map(Object.keys(obj).map((key) => [ key, obj[key] ]));
              if (validate(map)) {
                  return map;
              }
              map.clear();
              for (const key of Object.keys(obj)) {
                  const value = flatten(obj[key]);
                  if (value && value instanceof Map) {
                      for (const pair of value) {
                          map.set(key + '.' + pair[0], pair[1]);
                      }
                      continue;
                  }
                  return null;
              }
              return map;
          };
          if (!obj) {
              return null;
          }
          obj = clean(obj);
          const map = new Map();
          if (Array.isArray(obj) && obj.every((item) => validate(item))) {
              for (let i = 0; i < obj.length; i++) {
                  map.set(i.toString(), flatten(obj[i]));
              }
          }
          else if (obj instanceof Map && validate(obj)) {
              map.set('', flatten(obj));
          }
          else if (Object(obj) === obj && Object.keys(obj).every((key) => validate(obj[key]))) {
              for (const key of Object.keys(obj)) {
                  map.set(key, obj[key]);
              }
          }
          else if (Object(obj) === obj && Object.keys(obj).every((key) => pytorch.Utility.isTensor(obj[key]))) {
              map.set('', new Map(Object.keys(obj).map((key) => [ key, obj[key] ])));
          }
          else {
              const value = flatten(obj);
              if (value) {
                  map.set('', value);
              }
          }
          if (map.size > 0) {
              const graphs = [];
              for (const pair of map) {
                  const graph_key = pair[0];
                  const layer_map = pair[1];
                  const layers = new Map();
                  for (const item of layer_map) {
                      const key = item[0];
                      const value = item[1];
                      let layerName = '';
                      let parameter = '';
                      const keys = key.split('.');
                      if (keys[keys.length - 1] === '_metadata') {
                          continue;
                      }
                      if (keys.length >= 2 && keys[keys.length - 2] === '_packed_params') {
                          parameter = keys.slice(-2).join('.');
                          keys.pop();
                          keys.pop();
                      }
                      else {
                          parameter = keys.pop();
                          if (keys.length < 0) {
                              keys.push('');
                          }
                      }
                      layerName = keys.join('.');
                      if (!layers.has(layerName)) {
                          layers.set(layerName, { name: layerName, states: [], attributes: [] });
                      }
                      const layer = layers.get(layerName);
                      if (pytorch.Utility.isTensor(value)) {
                          layer.states.push({ name: parameter, arguments: [ { id: key, value: value } ] });
                          if (layer.name == '' && layer.states.length > 12) {
                              return null;
                          }
                      }
                      else if (value && Array.isArray(value) && value.every((item) => pytorch.Utility.isTensor(item))) {
                          layer.states.push({ name: parameter, arguments: value.map((item) => { return { id: '', value: item }; }) });
                      }
                      else if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
                          layer.attributes.push({ name: parameter, value: value });
                      }
                  }
                  graphs.push({
                      name: graph_key,
                      layers: layers.values()
                  });
              }
              return graphs;
          }
          return null;
      }
  };
  
  pytorch.nnapi = {};
  
  pytorch.nnapi.SerializedModel = class {
  
      constructor(serialized_model /*, buffer_ptrs */) {
          const reader = new pytorch.nnapi.SerializedModel.BinaryReader(serialized_model);
          this.version = reader.int32();
          if (this.version !== 1) {
              throw new pytorch.Error('Invalid NNAPI serialized model version.');
          }
          const operands = new Array(reader.int32());
          const values = new Array(reader.int32());
          this.operations = new Array(reader.int32());
          this.inputs = new Array(reader.int32());
          this.outputs = new Array(reader.int32());
          const types = new Map([
              [ 0, 'float32' ],
              [ 1, 'int32' ],
              [ 2, 'uint32' ],
              [ 3, 'float32' ],
              [ 4, 'int32*' ],
              [ 5, 'quant8_asymm*' ],
              [ 6, 'boolean' ],
              [ 7, 'quant16_symm*' ],
              [ 8, 'float16*' ],
              [ 9, 'boolean*' ],
              [ 10, 'float16' ],
              [ 11, 'quant8_symm_per_channel*' ],
              [ 12, 'quant16_asymm*' ],
              [ 13, 'quant8_symm*' ],
              [ 14, 'quant8_asymm_signed*' ],
              [ 16, 'model' ]
          ]);
          const operations = new Map([
              [ 0, 'ADD' ],
              [ 1, 'AVERAGE_POOL_2D' ],
              [ 2, 'CONCATENATION' ],
              [ 3, 'CONV_2D' ],
              [ 4, 'DEPTHWISE_CONV_2D' ],
              [ 5, 'DEPTH_TO_SPACE' ],
              [ 6, 'DEQUANTIZE' ],
              [ 7, 'EMBEDDING_LOOKUP' ],
              [ 8, 'FLOOR' ],
              [ 9, 'FULLY_CONNECTED' ],
              [ 10, 'HASHTABLE_LOOKUP' ],
              [ 11, 'L2_NORMALIZATION' ],
              [ 12, 'L2_POOL_2D' ],
              [ 13, 'LOCAL_RESPONSE_NORMALIZATION' ],
              [ 14, 'LOGISTIC' ],
              [ 15, 'LSH_PROJECTION' ],
              [ 16, 'LSTM' ],
              [ 17, 'MAX_POOL_2D' ],
              [ 18, 'MUL' ],
              [ 19, 'RELU' ],
              [ 20, 'RELU1' ],
              [ 21, 'RELU6' ],
              [ 22, 'RESHAPE' ],
              [ 23, 'RESIZE_BILINEAR' ],
              [ 24, 'RNN' ],
              [ 25, 'SOFTMAX' ],
              [ 26, 'SPACE_TO_DEPTH' ],
              [ 27, 'SVDF' ],
              [ 28, 'TANH' ],
              [ 29, 'BATCH_TO_SPACE_ND' ],
              [ 30, 'DIV' ],
              [ 31, 'MEAN' ],
              [ 32, 'PAD' ],
              [ 33, 'SPACE_TO_BATCH_ND' ],
              [ 34, 'SQUEEZE' ],
              [ 35, 'STRIDED_SLICE' ],
              [ 36, 'SUB' ],
              [ 37, 'TRANSPOSE' ],
              [ 38, 'ABS' ],
              [ 39, 'ARGMAX' ],
              [ 40, 'ARGMIN' ],
              [ 41, 'AXIS_ALIGNED_BBOX_TRANSFORM' ],
              [ 42, 'BIDIRECTIONAL_SEQUENCE_LSTM' ],
              [ 43, 'BIDIRECTIONAL_SEQUENCE_RNN' ],
              [ 44, 'BOX_WITH_NMS_LIMIT' ],
              [ 45, 'CAST' ],
              [ 46, 'CHANNEL_SHUFFLE' ],
              [ 47, 'DETECTION_POSTPROCESSING' ],
              [ 48, 'EQUAL' ],
              [ 49, 'EXP' ],
              [ 50, 'EXPAND_DIMS' ],
              [ 51, 'GATHER' ],
              [ 52, 'GENERATE_PROPOSALS' ],
              [ 53, 'GREATER' ],
              [ 54, 'GREATER_EQUAL' ],
              [ 55, 'GROUPED_CONV_2D' ],
              [ 56, 'HEATMAP_MAX_KEYPOINT' ],
              [ 57, 'INSTANCE_NORMALIZATION' ],
              [ 58, 'LESS' ],
              [ 59, 'LESS_EQUAL' ],
              [ 60, 'LOG' ],
              [ 61, 'LOGICAL_AND' ],
              [ 62, 'LOGICAL_NOT' ],
              [ 63, 'LOGICAL_OR' ],
              [ 64, 'LOG_SOFTMAX' ],
              [ 65, 'MAXIMUM' ],
              [ 66, 'MINIMUM' ],
              [ 67, 'NEG' ],
              [ 68, 'NOT_EQUAL' ],
              [ 69, 'PAD_V2' ],
              [ 70, 'POW' ],
              [ 71, 'PRELU' ],
              [ 72, 'QUANTIZE' ],
              [ 73, 'QUANTIZED_16BIT_LSTM' ],
              [ 74, 'RANDOM_MULTINOMIAL' ],
              [ 75, 'REDUCE_ALL' ],
              [ 76, 'REDUCE_ANY' ],
              [ 77, 'REDUCE_MAX' ],
              [ 78, 'REDUCE_MIN' ],
              [ 79, 'REDUCE_PROD' ],
              [ 80, 'REDUCE_SUM' ],
              [ 81, 'ROI_ALIGN' ],
              [ 82, 'ROI_POOLING' ],
              [ 83, 'RSQRT' ],
              [ 84, 'SELECT' ],
              [ 85, 'SIN' ],
              [ 86, 'SLICE' ],
              [ 87, 'SPLIT' ],
              [ 88, 'SQRT' ],
              [ 89, 'TILE' ],
              [ 90, 'TOPK_V2' ],
              [ 91, 'TRANSPOSE_CONV_2D' ],
              [ 92, 'UNIDIRECTIONAL_SEQUENCE_LSTM' ],
              [ 93, 'UNIDIRECTIONAL_SEQUENCE_RNN' ],
              [ 94, 'RESIZE_NEAREST_NEIGHBOR' ],
              [ 95, 'QUANTIZED_LSTM' ],
              [ 96, 'IF' ],
              [ 97, 'WHILE' ],
              [ 98, 'ELU' ],
              [ 99, 'HARD_SWISH' ],
              [ 100, 'FILL' ],
              [ 101, 'RANK' ],
          ]);
          for (let i = 0; i < operands.length; i++) {
              const type = reader.int32();
              operands[i] = {
                  type: types.has(type) ? types.get(type) : type,
                  dimensions: new Array(reader.uint32()),
                  scale: reader.float32(),
                  zero_point: reader.int32()
              };
          }
          for (let i = 0; i < values.length; i++) {
              values[i] = {
                  index: reader.int32(),
                  source_type: reader.int32(),
                  source_length: reader.uint32()
              };
          }
          for (let i = 0; i < this.operations.length; i++) {
              const operation_type = reader.int32();
              this.operations[i] = {
                  operation_type: operations.has(operation_type) ? operations.get(operation_type) : operation_type,
                  inputs: new Array(reader.uint32()),
                  outputs: new Array(reader.uint32())
              };
          }
          for (const operand of operands) {
              for (let i = 0; i< operand.dimensions.length; i++) {
                  operand.dimensions[i] = reader.uint32();
              }
          }
          for (const value of values) {
              const operand = operands[value.index];
              switch (value.source_type) {
                  case 0: { // immediate
                      switch (operand.type) {
                          case 'boolean':
                              operand.value = reader.byte() ? true : false;
                              reader.skip(3);
                              break;
                          case 'int32':
                              operand.value = reader.int32();
                              break;
                          case 'float32':
                              operand.value = reader.float32();
                              break;
                          case 'int32*':
                              operand.value = reader.read(value.source_length);
                              break;
                          default:
                              throw new pytorch.Error("Unsupported NNAPI operand type '" + operand.type.toString() + "'.");
                      }
                      break;
                  }
                  case 2: { // numbered buffer
                      if (value.source_length !== 12) {
                          throw new pytorch.Error('Invalid NNAPI numbered buffer source length.');
                      }
                      const number = reader.uint32();
                      const offset = reader.uint32();
                      const operand_length = reader.uint32();
                      operand.value = [ number, offset, operand_length ];
                      break;
                  }
                  case 3: { // numbered memory
                      throw new pytorch.Error('NNAPI numbered memory buffer not implemented.');
                  }
                  default: {
                      throw new pytorch.Error('Unsupported NNAPI value source type.');
                  }
              }
          }
          for (const operation of this.operations) {
              for (let i = 0; i< operation.inputs.length; i++) {
                  operation.inputs[i] = operands[reader.uint32()];
              }
              for (let i = 0; i< operation.outputs.length; i++) {
                  operation.outputs[i] = operands[reader.uint32()];
              }
          }
          for (let i = 0; i< this.inputs.length; i++) {
              this.inputs[i] = operands[reader.uint32()];
          }
          for (let i = 0; i< this.outputs.length; i++) {
              this.outputs[i] = operands[reader.uint32()];
          }
          if (!reader.end()) {
              throw new pytorch.Error('Invalid NNAPI serialized model length.');
          }
      }
  };
  
  pytorch.nnapi.SerializedModel.BinaryReader = class {
  
      constructor(buffer) {
          this._buffer = buffer;
          this._dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
          this._position = 0;
      }
  
      end() {
          return this._position >= this._buffer.length;
      }
  
      skip(offset) {
          this._position += offset;
          if (this._position > this._buffer.length) {
              throw new pytorch.Error('Expected ' + (this._position - this._buffer.length) + ' more bytes. The file might be corrupted. Unexpected end of file.');
          }
      }
  
      read(length) {
          const position = this._position;
          this.skip(length);
          return this._buffer.subarray(position, this._position);
      }
  
      byte() {
          const position = this._position;
          this.skip(1);
          return this._dataView.getUint8(position, true);
      }
  
      int32() {
          const position = this._position;
          this.skip(4);
          return this._dataView.getInt32(position, true);
      }
  
      uint32() {
          const position = this._position;
          this.skip(4);
          return this._dataView.getUint32(position, true);
      }
  
      int64() {
          const value = this.int32();
          if (this.int32() !== 0) {
              throw new pytorch.Error('Invalid int64 value.');
          }
          return value;
      }
  
      float32() {
          const position = this._position;
          this.skip(4);
          return this._dataView.getFloat32(position, true);
      }
  };
  
  pytorch.Metadata = class {
  
      static open(context) {
          if (pytorch.Metadata._metadata) {
              return Promise.resolve(pytorch.Metadata._metadata);
          }
          else {
              return context.request('pytorch-metadata.json', 'utf-8', null).then((data) => {
                  pytorch.Metadata._metadata = new pytorch.Metadata(data);
                  return pytorch.Metadata._metadata;
              }).catch(() => {
                  pytorch.Metadata._metadata = new pytorch.Metadata(null);
                  return pytorch.Metadata._metadata;
              });
          }
      }
  
      constructor(data) {
          this._map = new Map();
          this._attributeCache = new Map();
          if (data) {
              const items = JSON.parse(data);
              for (const item of items) {
                  this._map.set(item.name, item);
                  const index = item.name.indexOf(':');
                  if (index !== -1) {
                      const name = item.name.substring(0, index);
                      if (!this._map.has(name)) {
                          this._map.set(name, []);
                      }
                      this._map.get(name).push(item.name);
                  }
              }
          }
      }
  
      type(name) {
          const schema = this._map.get(name);
          if (schema) {
              return Array.isArray(schema) ? schema.map((name) => this._map.get(name)) : schema;
          }
          return null;
      }
  
      attribute(type, name) {
          const attributeName = type + ':' + name;
          if (!this._attributeCache.has(attributeName)) {
              this._attributeCache.set(attributeName, null);
              const schema = this.type(type);
              if (schema) {
                  if (schema.inputs) {
                      for (const input of schema.inputs) {
                          this._attributeCache.set(type + ':' + input.name, input);
                      }
                  }
                  if (schema.attributes) {
                      for (const attribute of schema.attributes) {
                          this._attributeCache.set(type + ':' + attribute.name, attribute);
                      }
                  }
              }
          }
          return this._attributeCache.get(attributeName);
      }
  };
  
  pytorch.Error = class extends Error {
  
      constructor(message) {
          super(message);
          this.name = 'Error loading PyTorch model.';
      }
  };
  
  if (typeof module !== 'undefined' && typeof module.exports === 'object') {
      module.exports.ModelFactory = pytorch.ModelFactory;
  }
  