// automatically generated by the FlatBuffers compiler, do not modify

/**
 * @const
 * @namespace
 */
var MNN = MNN || {};

/**
 * @enum {number}
 */
MNN.NetSource = {
  CAFFE: 0,
  TENSORFLOW: 1,
  TFLITE: 2,
  ONNX: 3
};

/**
 * @enum {string}
 */
MNN.NetSourceName = {
  '0': 'CAFFE',
  '1': 'TENSORFLOW',
  '2': 'TFLITE',
  '3': 'ONNX'
};

/**
 * @enum {number}
 */
MNN.DataType = {
  DT_INVALID: 0,
  DT_FLOAT: 1,
  DT_DOUBLE: 2,
  DT_INT32: 3,
  DT_UINT8: 4,
  DT_INT16: 5,
  DT_INT8: 6,
  DT_STRING: 7,
  DT_COMPLEX64: 8,
  DT_INT64: 9,
  DT_BOOL: 10,
  DT_QINT8: 11,
  DT_QUINT8: 12,
  DT_QINT32: 13,
  DT_BFLOAT16: 14,
  DT_QINT16: 15,
  DT_QUINT16: 16,
  DT_UINT16: 17,
  DT_COMPLEX128: 18,
  DT_HALF: 19,
  DT_RESOURCE: 20,
  DT_VARIANT: 21
};

/**
 * @enum {string}
 */
MNN.DataTypeName = {
  '0': 'DT_INVALID',
  '1': 'DT_FLOAT',
  '2': 'DT_DOUBLE',
  '3': 'DT_INT32',
  '4': 'DT_UINT8',
  '5': 'DT_INT16',
  '6': 'DT_INT8',
  '7': 'DT_STRING',
  '8': 'DT_COMPLEX64',
  '9': 'DT_INT64',
  '10': 'DT_BOOL',
  '11': 'DT_QINT8',
  '12': 'DT_QUINT8',
  '13': 'DT_QINT32',
  '14': 'DT_BFLOAT16',
  '15': 'DT_QINT16',
  '16': 'DT_QUINT16',
  '17': 'DT_UINT16',
  '18': 'DT_COMPLEX128',
  '19': 'DT_HALF',
  '20': 'DT_RESOURCE',
  '21': 'DT_VARIANT'
};

/**
 * @enum {number}
 */
MNN.MNN_DATA_FORMAT = {
  NCHW: 0,
  NHWC: 1,
  NC4HW4: 2,
  NHWC4: 3,
  UNKNOWN: 4
};

/**
 * @enum {string}
 */
MNN.MNN_DATA_FORMATName = {
  '0': 'NCHW',
  '1': 'NHWC',
  '2': 'NC4HW4',
  '3': 'NHWC4',
  '4': 'UNKNOWN'
};

/**
 * @enum {number}
 */
MNN.PadMode = {
  CAFFE: 0,
  VALID: 1,
  SAME: 2
};

/**
 * @enum {string}
 */
MNN.PadModeName = {
  '0': 'CAFFE',
  '1': 'VALID',
  '2': 'SAME'
};

/**
 * @enum {number}
 */
MNN.PoolType = {
  MAXPOOL: 0,
  AVEPOOL: 1
};

/**
 * @enum {string}
 */
MNN.PoolTypeName = {
  '0': 'MAXPOOL',
  '1': 'AVEPOOL'
};

/**
 * @enum {number}
 */
MNN.PoolPadType = {
  CAFFE: 0,
  VALID: 1,
  SAME: 2
};

/**
 * @enum {string}
 */
MNN.PoolPadTypeName = {
  '0': 'CAFFE',
  '1': 'VALID',
  '2': 'SAME'
};

/**
 * @enum {number}
 */
MNN.EltwiseType = {
  PROD: 0,
  SUM: 1,
  MAXIMUM: 2,
  SUB: 3
};

/**
 * @enum {string}
 */
MNN.EltwiseTypeName = {
  '0': 'PROD',
  '1': 'SUM',
  '2': 'MAXIMUM',
  '3': 'SUB'
};

/**
 * @enum {number}
 */
MNN.BinaryOpOperation = {
  ADD: 0,
  SUB: 1,
  MUL: 2,
  DIV: 3,
  MAX_TEMP: 4,
  MIN_TEMP: 5,
  POW: 6,
  REALDIV: 7,
  MINIMUM: 8,
  MAXIMUM: 9,
  GREATER: 10,
  GREATER_EQUAL: 11,
  LESS: 12,
  FLOORDIV: 13,
  SquaredDifference: 14,
  EQUAL: 15,
  LESS_EQUAL: 16,
  FLOORMOD: 17,
  MOD: 19,
  ATAN2: 20,
  LOGICALOR: 21,
  NOTEQUAL: 22
};

/**
 * @enum {string}
 */
MNN.BinaryOpOperationName = {
  '0': 'ADD',
  '1': 'SUB',
  '2': 'MUL',
  '3': 'DIV',
  '4': 'MAX_TEMP',
  '5': 'MIN_TEMP',
  '6': 'POW',
  '7': 'REALDIV',
  '8': 'MINIMUM',
  '9': 'MAXIMUM',
  '10': 'GREATER',
  '11': 'GREATER_EQUAL',
  '12': 'LESS',
  '13': 'FLOORDIV',
  '14': 'SquaredDifference',
  '15': 'EQUAL',
  '16': 'LESS_EQUAL',
  '17': 'FLOORMOD',
  '19': 'MOD',
  '20': 'ATAN2',
  '21': 'LOGICALOR',
  '22': 'NOTEQUAL'
};

/**
 * @enum {number}
 */
MNN.ReductionType = {
  SUM: 0,
  ASUM: 1,
  SUMSQ: 2,
  MEAN: 3,
  MAXIMUM: 4,
  MINIMUM: 5,
  PROD: 6,
  ANY: 7,
  ALL: 8
};

/**
 * @enum {string}
 */
MNN.ReductionTypeName = {
  '0': 'SUM',
  '1': 'ASUM',
  '2': 'SUMSQ',
  '3': 'MEAN',
  '4': 'MAXIMUM',
  '5': 'MINIMUM',
  '6': 'PROD',
  '7': 'ANY',
  '8': 'ALL'
};

/**
 * @enum {number}
 */
MNN.UnaryOpOperation = {
  ABS: 0,
  NEG: 1,
  FLOOR: 2,
  CEIL: 3,
  SQUARE: 4,
  SQRT: 5,
  RSQRT: 6,
  EXP: 7,
  LOG: 8,
  SIN: 9,
  COS: 10,
  TAN: 11,
  ASIN: 12,
  ACOS: 13,
  ATAN: 14,
  RECIPROCAL: 15,
  LOG1P: 16,
  BNLL: 17,
  ACOSH: 18,
  SINH: 19,
  ASINH: 20,
  ATANH: 21,
  SIGN: 22,
  ROUND: 23,
  COSH: 24,
  ERF: 25,
  ERFC: 26,
  ERFINV: 27,
  EXPM1: 28
};

/**
 * @enum {string}
 */
MNN.UnaryOpOperationName = {
  '0': 'ABS',
  '1': 'NEG',
  '2': 'FLOOR',
  '3': 'CEIL',
  '4': 'SQUARE',
  '5': 'SQRT',
  '6': 'RSQRT',
  '7': 'EXP',
  '8': 'LOG',
  '9': 'SIN',
  '10': 'COS',
  '11': 'TAN',
  '12': 'ASIN',
  '13': 'ACOS',
  '14': 'ATAN',
  '15': 'RECIPROCAL',
  '16': 'LOG1P',
  '17': 'BNLL',
  '18': 'ACOSH',
  '19': 'SINH',
  '20': 'ASINH',
  '21': 'ATANH',
  '22': 'SIGN',
  '23': 'ROUND',
  '24': 'COSH',
  '25': 'ERF',
  '26': 'ERFC',
  '27': 'ERFINV',
  '28': 'EXPM1'
};

/**
 * @enum {number}
 */
MNN.CropAndResizeMethod = {
  BILINEAR: 0,
  NEAREST: 1
};

/**
 * @enum {string}
 */
MNN.CropAndResizeMethodName = {
  '0': 'BILINEAR',
  '1': 'NEAREST'
};

/**
 * @enum {number}
 */
MNN.PadValueMode = {
  CONSTANT: 0,
  REFLECT: 1,
  SYMMETRIC: 2
};

/**
 * @enum {string}
 */
MNN.PadValueModeName = {
  '0': 'CONSTANT',
  '1': 'REFLECT',
  '2': 'SYMMETRIC'
};

/**
 * @enum {number}
 */
MNN.FusedActivation = {
  kTfLiteActNone: 0,
  kTfLiteActRelu: 1,
  kTfLiteActRelu1: 2,
  kTfLiteActRelu6: 3,
  kTfLiteActTanh: 4,
  kTfLiteActSignBit: 5,
  kTfLiteActSigmoid: 6
};

/**
 * @enum {string}
 */
MNN.FusedActivationName = {
  '0': 'kTfLiteActNone',
  '1': 'kTfLiteActRelu',
  '2': 'kTfLiteActRelu1',
  '3': 'kTfLiteActRelu6',
  '4': 'kTfLiteActTanh',
  '5': 'kTfLiteActSignBit',
  '6': 'kTfLiteActSigmoid'
};

/**
 * @enum {number}
 */
MNN.ModeFormat = {
  TENSORFLOW: 0,
  TFLITE: 1
};

/**
 * @enum {string}
 */
MNN.ModeFormatName = {
  '0': 'TENSORFLOW',
  '1': 'TFLITE'
};

/**
 * @enum {number}
 */
MNN.QuantizeMode = {
  MIN_COMBINED: 0,
  MIN_FIRST: 1,
  SCALED: 2
};

/**
 * @enum {string}
 */
MNN.QuantizeModeName = {
  '0': 'MIN_COMBINED',
  '1': 'MIN_FIRST',
  '2': 'SCALED'
};

/**
 * @enum {number}
 */
MNN.QuantizeRoundMode = {
  HALF_AWAY_FROM_ZERO: 0,
  HALF_TO_EVEN: 1
};

/**
 * @enum {string}
 */
MNN.QuantizeRoundModeName = {
  '0': 'HALF_AWAY_FROM_ZERO',
  '1': 'HALF_TO_EVEN'
};

/**
 * @enum {number}
 */
MNN.STORAGE_TYPE = {
  BUFFER: 0,
  UNIFORM: 1,
  IMAGE: 2
};

/**
 * @enum {string}
 */
MNN.STORAGE_TYPEName = {
  '0': 'BUFFER',
  '1': 'UNIFORM',
  '2': 'IMAGE'
};

/**
 * @enum {number}
 */
MNN.ACCESS_TYPE = {
  READ_ONLY: 0,
  WRITE_ONLY: 1,
  READ_WRITE: 2
};

/**
 * @enum {string}
 */
MNN.ACCESS_TYPEName = {
  '0': 'READ_ONLY',
  '1': 'WRITE_ONLY',
  '2': 'READ_WRITE'
};

/**
 * @enum {number}
 */
MNN.OpType = {
  AbsVal: 0,
  QuantizedAdd: 1,
  ArgMax: 2,
  AsString: 3,
  InstanceNorm: 4,
  BatchToSpaceND: 5,
  Bias: 6,
  BinaryOp: 7,
  Bnll: 8,
  Cast: 9,
  Concat: 10,
  Const: 11,
  Convolution: 12,
  ConvolutionDepthwise: 13,
  Crop: 14,
  CropAndResize: 15,
  Cubic: 16,
  Deconvolution: 17,
  DeconvolutionDepthwise: 18,
  Dequantize: 19,
  DetectionOutput: 20,
  Dropout: 21,
  Eltwise: 22,
  ELU: 23,
  Embed: 24,
  Exp: 25,
  ExpandDims: 26,
  Fill: 27,
  Flatten: 28,
  FloorMod: 29,
  Gather: 30,
  GatherV2: 31,
  Im2Seq: 32,
  InnerProduct: 33,
  Input: 34,
  Interp: 35,
  Log: 36,
  LRN: 37,
  LSTM: 38,
  MatMul: 39,
  MVN: 40,
  NonMaxSuppression: 41,
  NonMaxSuppressionV2: 42,
  Normalize: 43,
  Pack: 44,
  Padding: 45,
  Permute: 46,
  Pooling: 47,
  Power: 48,
  PReLU: 49,
  PriorBox: 50,
  Proposal: 51,
  QuantizedAvgPool: 52,
  QuantizedBiasAdd: 53,
  QuantizedConcat: 54,
  QuantizedDepthwiseConv2D: 55,
  QuantizedLogistic: 56,
  QuantizedMatMul: 57,
  QuantizedMaxPool: 58,
  QuantizedRelu: 59,
  QuantizedRelu6: 60,
  QuantizedReshape: 61,
  QuantizedSoftmax: 62,
  QuantizeMaxMin: 63,
  QuantizeV2: 64,
  Range: 65,
  Rank: 66,
  ReduceJoin: 67,
  Reduction: 68,
  ReLU: 69,
  ReLU6: 70,
  RequantizationRange: 71,
  Requantize: 72,
  Reshape: 73,
  Resize: 74,
  RNN: 75,
  ROIPooling: 76,
  Scale: 77,
  Selu: 78,
  Seq2Out: 79,
  Shape: 80,
  Sigmoid: 81,
  Size: 82,
  Slice: 83,
  SliceTf: 84,
  Softmax: 85,
  SpaceToBatchND: 86,
  SpatialProduct: 87,
  Split: 88,
  SPP: 89,
  Squeeze: 90,
  StridedSlice: 91,
  StringJoin: 92,
  StringSplit: 93,
  StringToNumber: 94,
  TanH: 95,
  TfQuantizedConv2D: 96,
  Threshold: 97,
  Tile: 98,
  TopKV2: 99,
  Transpose: 100,
  UnaryOp: 101,
  Unpack: 102,
  Where: 103,
  Moments: 104,
  RNNSequenceGRU: 105,
  BatchMatMul: 106,
  Unsqueeze: 107,
  CosineSimilarity: 108,
  DepthToSpace: 109,
  SpaceToDepth: 110,
  ReverseSequence: 111,
  Pooling3D: 112,
  Convolution3D: 113,
  MatrixBandPart: 114,
  GatherND: 115,
  DetectionPostProcess: 116,
  UnravelIndex: 117,
  ScatterNd: 118,
  OneHot: 119,
  BroadcastTo: 120,
  Dilation2D: 121,
  MaxLayerCount: 128,
  ConvertTensor: 129,
  ArgMin: 130,
  LinSpace: 131,
  PLUGIN: 256,
  Select: 257,
  ZerosLike: 258,
  Broastcast: 259,
  SetDiff1D: 260,
  ReluGrad: 261,
  Relu6Grad: 262,
  PoolGrad: 263,
  SoftmaxGrad: 264,
  Conv2DBackPropFilter: 265,
  TrainableParam: 266,
  BatchNorm: 267,
  ZeroGrad: 268,
  Extra: 512,
  ConvInt8: 513,
  Int8ToFloat: 514,
  DepthwiseConvInt8: 515,
  PoolInt8: 516,
  FloatToInt8: 517,
  EltwiseInt8: 518
};

/**
 * @enum {string}
 */
MNN.OpTypeName = {
  '0': 'AbsVal',
  '1': 'QuantizedAdd',
  '2': 'ArgMax',
  '3': 'AsString',
  '4': 'InstanceNorm',
  '5': 'BatchToSpaceND',
  '6': 'Bias',
  '7': 'BinaryOp',
  '8': 'Bnll',
  '9': 'Cast',
  '10': 'Concat',
  '11': 'Const',
  '12': 'Convolution',
  '13': 'ConvolutionDepthwise',
  '14': 'Crop',
  '15': 'CropAndResize',
  '16': 'Cubic',
  '17': 'Deconvolution',
  '18': 'DeconvolutionDepthwise',
  '19': 'Dequantize',
  '20': 'DetectionOutput',
  '21': 'Dropout',
  '22': 'Eltwise',
  '23': 'ELU',
  '24': 'Embed',
  '25': 'Exp',
  '26': 'ExpandDims',
  '27': 'Fill',
  '28': 'Flatten',
  '29': 'FloorMod',
  '30': 'Gather',
  '31': 'GatherV2',
  '32': 'Im2Seq',
  '33': 'InnerProduct',
  '34': 'Input',
  '35': 'Interp',
  '36': 'Log',
  '37': 'LRN',
  '38': 'LSTM',
  '39': 'MatMul',
  '40': 'MVN',
  '41': 'NonMaxSuppression',
  '42': 'NonMaxSuppressionV2',
  '43': 'Normalize',
  '44': 'Pack',
  '45': 'Padding',
  '46': 'Permute',
  '47': 'Pooling',
  '48': 'Power',
  '49': 'PReLU',
  '50': 'PriorBox',
  '51': 'Proposal',
  '52': 'QuantizedAvgPool',
  '53': 'QuantizedBiasAdd',
  '54': 'QuantizedConcat',
  '55': 'QuantizedDepthwiseConv2D',
  '56': 'QuantizedLogistic',
  '57': 'QuantizedMatMul',
  '58': 'QuantizedMaxPool',
  '59': 'QuantizedRelu',
  '60': 'QuantizedRelu6',
  '61': 'QuantizedReshape',
  '62': 'QuantizedSoftmax',
  '63': 'QuantizeMaxMin',
  '64': 'QuantizeV2',
  '65': 'Range',
  '66': 'Rank',
  '67': 'ReduceJoin',
  '68': 'Reduction',
  '69': 'ReLU',
  '70': 'ReLU6',
  '71': 'RequantizationRange',
  '72': 'Requantize',
  '73': 'Reshape',
  '74': 'Resize',
  '75': 'RNN',
  '76': 'ROIPooling',
  '77': 'Scale',
  '78': 'Selu',
  '79': 'Seq2Out',
  '80': 'Shape',
  '81': 'Sigmoid',
  '82': 'Size',
  '83': 'Slice',
  '84': 'SliceTf',
  '85': 'Softmax',
  '86': 'SpaceToBatchND',
  '87': 'SpatialProduct',
  '88': 'Split',
  '89': 'SPP',
  '90': 'Squeeze',
  '91': 'StridedSlice',
  '92': 'StringJoin',
  '93': 'StringSplit',
  '94': 'StringToNumber',
  '95': 'TanH',
  '96': 'TfQuantizedConv2D',
  '97': 'Threshold',
  '98': 'Tile',
  '99': 'TopKV2',
  '100': 'Transpose',
  '101': 'UnaryOp',
  '102': 'Unpack',
  '103': 'Where',
  '104': 'Moments',
  '105': 'RNNSequenceGRU',
  '106': 'BatchMatMul',
  '107': 'Unsqueeze',
  '108': 'CosineSimilarity',
  '109': 'DepthToSpace',
  '110': 'SpaceToDepth',
  '111': 'ReverseSequence',
  '112': 'Pooling3D',
  '113': 'Convolution3D',
  '114': 'MatrixBandPart',
  '115': 'GatherND',
  '116': 'DetectionPostProcess',
  '117': 'UnravelIndex',
  '118': 'ScatterNd',
  '119': 'OneHot',
  '120': 'BroadcastTo',
  '121': 'Dilation2D',
  '128': 'MaxLayerCount',
  '129': 'ConvertTensor',
  '130': 'ArgMin',
  '131': 'LinSpace',
  '256': 'PLUGIN',
  '257': 'Select',
  '258': 'ZerosLike',
  '259': 'Broastcast',
  '260': 'SetDiff1D',
  '261': 'ReluGrad',
  '262': 'Relu6Grad',
  '263': 'PoolGrad',
  '264': 'SoftmaxGrad',
  '265': 'Conv2DBackPropFilter',
  '266': 'TrainableParam',
  '267': 'BatchNorm',
  '268': 'ZeroGrad',
  '512': 'Extra',
  '513': 'ConvInt8',
  '514': 'Int8ToFloat',
  '515': 'DepthwiseConvInt8',
  '516': 'PoolInt8',
  '517': 'FloatToInt8',
  '518': 'EltwiseInt8'
};

/**
 * @enum {number}
 */
MNN.OpParameter = {
  NONE: 0,
  QuantizedAdd: 1,
  ArgMax: 2,
  AsString: 3,
  Axis: 4,
  BatchNorm: 5,
  BinaryOp: 6,
  Blob: 7,
  CastParam: 8,
  Convolution2D: 9,
  Crop: 10,
  CropAndResize: 11,
  Dequantize: 12,
  DetectionOutput: 13,
  Eltwise: 14,
  ExpandDims: 15,
  Fill: 16,
  Flatten: 17,
  Gather: 18,
  GatherV2: 19,
  InnerProduct: 20,
  Input: 21,
  Interp: 22,
  LRN: 23,
  LSTM: 24,
  MatMul: 25,
  NonMaxSuppressionV2: 26,
  Normalize: 27,
  PackParam: 28,
  Permute: 29,
  Plugin: 30,
  Pool: 31,
  PRelu: 32,
  PriorBox: 33,
  Proposal: 34,
  QuantizedAvgPool: 35,
  QuantizedBiasAdd: 36,
  QuantizedConcat: 37,
  QuantizedLogistic: 38,
  QuantizedMatMul: 39,
  QuantizedMaxPool: 40,
  QuantizedRelu: 41,
  QuantizedRelu6: 42,
  QuantizedReshape: 43,
  QuantizedSoftmax: 44,
  QuantizeMaxMin: 45,
  QuantizeV2: 46,
  Range: 47,
  Rank: 48,
  ReduceJoin: 49,
  ReductionParam: 50,
  Relu: 51,
  Relu6: 52,
  RequantizationRange: 53,
  Requantize: 54,
  Reshape: 55,
  Resize: 56,
  RoiPooling: 57,
  Scale: 58,
  Selu: 59,
  Size: 60,
  Slice: 61,
  SliceTf: 62,
  SpaceBatch: 63,
  SqueezeParam: 64,
  StridedSliceParam: 65,
  TensorConvertInfo: 66,
  TfQuantizedConv2D: 67,
  TopKV2: 68,
  Transpose: 69,
  UnaryOp: 70,
  MomentsParam: 71,
  RNNParam: 72,
  BatchMatMulParam: 73,
  QuantizedFloatParam: 74,
  DepthSpaceParam: 75,
  EltwiseInt8: 76,
  ReverseSequenceParam: 77,
  Extra: 78,
  Pool3D: 79,
  Convolution3D: 80,
  ELU: 81,
  DetectionPostProcessParam: 82,
  OneHotParam: 83,
  PadParam: 84
};

/**
 * @enum {string}
 */
MNN.OpParameterName = {
  '0': 'NONE',
  '1': 'QuantizedAdd',
  '2': 'ArgMax',
  '3': 'AsString',
  '4': 'Axis',
  '5': 'BatchNorm',
  '6': 'BinaryOp',
  '7': 'Blob',
  '8': 'CastParam',
  '9': 'Convolution2D',
  '10': 'Crop',
  '11': 'CropAndResize',
  '12': 'Dequantize',
  '13': 'DetectionOutput',
  '14': 'Eltwise',
  '15': 'ExpandDims',
  '16': 'Fill',
  '17': 'Flatten',
  '18': 'Gather',
  '19': 'GatherV2',
  '20': 'InnerProduct',
  '21': 'Input',
  '22': 'Interp',
  '23': 'LRN',
  '24': 'LSTM',
  '25': 'MatMul',
  '26': 'NonMaxSuppressionV2',
  '27': 'Normalize',
  '28': 'PackParam',
  '29': 'Permute',
  '30': 'Plugin',
  '31': 'Pool',
  '32': 'PRelu',
  '33': 'PriorBox',
  '34': 'Proposal',
  '35': 'QuantizedAvgPool',
  '36': 'QuantizedBiasAdd',
  '37': 'QuantizedConcat',
  '38': 'QuantizedLogistic',
  '39': 'QuantizedMatMul',
  '40': 'QuantizedMaxPool',
  '41': 'QuantizedRelu',
  '42': 'QuantizedRelu6',
  '43': 'QuantizedReshape',
  '44': 'QuantizedSoftmax',
  '45': 'QuantizeMaxMin',
  '46': 'QuantizeV2',
  '47': 'Range',
  '48': 'Rank',
  '49': 'ReduceJoin',
  '50': 'ReductionParam',
  '51': 'Relu',
  '52': 'Relu6',
  '53': 'RequantizationRange',
  '54': 'Requantize',
  '55': 'Reshape',
  '56': 'Resize',
  '57': 'RoiPooling',
  '58': 'Scale',
  '59': 'Selu',
  '60': 'Size',
  '61': 'Slice',
  '62': 'SliceTf',
  '63': 'SpaceBatch',
  '64': 'SqueezeParam',
  '65': 'StridedSliceParam',
  '66': 'TensorConvertInfo',
  '67': 'TfQuantizedConv2D',
  '68': 'TopKV2',
  '69': 'Transpose',
  '70': 'UnaryOp',
  '71': 'MomentsParam',
  '72': 'RNNParam',
  '73': 'BatchMatMulParam',
  '74': 'QuantizedFloatParam',
  '75': 'DepthSpaceParam',
  '76': 'EltwiseInt8',
  '77': 'ReverseSequenceParam',
  '78': 'Extra',
  '79': 'Pool3D',
  '80': 'Convolution3D',
  '81': 'ELU',
  '82': 'DetectionPostProcessParam',
  '83': 'OneHotParam',
  '84': 'PadParam'
};

/**
 * @enum {number}
 */
MNN.ForwardType = {
  CPU: 0,
  METAL: 1,
  OPENCL: 2,
  OPENGLES: 3,
  VULKAN: 4
};

/**
 * @enum {string}
 */
MNN.ForwardTypeName = {
  '0': 'CPU',
  '1': 'METAL',
  '2': 'OPENCL',
  '3': 'OPENGLES',
  '4': 'VULKAN'
};

/**
 * @enum {number}
 */
MNN.Usage = {
  INFERENCE: 0,
  TRAIN: 1
};

/**
 * @enum {string}
 */
MNN.UsageName = {
  '0': 'INFERENCE',
  '1': 'TRAIN'
};

/**
 * @constructor
 */
MNN.Blob = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Blob}
 */
MNN.Blob.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob}
 */
MNN.Blob.getRootAsBlob = function(bb, obj) {
  return (obj || new MNN.Blob).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob}
 */
MNN.Blob.getSizePrefixedRootAsBlob = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Blob).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Blob.prototype.dims = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Blob.prototype.dimsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Blob.prototype.dimsArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {MNN.MNN_DATA_FORMAT}
 */
MNN.Blob.prototype.dataFormat = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.MNN_DATA_FORMAT} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.MNN_DATA_FORMAT.NCHW;
};

/**
 * @returns {MNN.DataType}
 */
MNN.Blob.prototype.dataType = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_FLOAT;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Blob.prototype.uint8s = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
};

/**
 * @returns {number}
 */
MNN.Blob.prototype.uint8sLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Uint8Array}
 */
MNN.Blob.prototype.uint8sArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Blob.prototype.int8s = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
};

/**
 * @returns {number}
 */
MNN.Blob.prototype.int8sLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int8Array}
 */
MNN.Blob.prototype.int8sArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Blob.prototype.int32s = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Blob.prototype.int32sLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Blob.prototype.int32sArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {flatbuffers.Long}
 */
MNN.Blob.prototype.int64s = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.readInt64(this.bb.__vector(this.bb_pos + offset) + index * 8) : this.bb.createLong(0, 0);
};

/**
 * @returns {number}
 */
MNN.Blob.prototype.int64sLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Blob.prototype.float32s = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Blob.prototype.float32sLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.Blob.prototype.float32sArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array}
 */
MNN.Blob.prototype.strings = function(index, optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
};

/**
 * @returns {number}
 */
MNN.Blob.prototype.stringsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Blob.startBlob = function(builder) {
  builder.startObject(9);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimsOffset
 */
MNN.Blob.addDims = function(builder, dimsOffset) {
  builder.addFieldOffset(0, dimsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Blob.createDimsVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Blob.startDimsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.MNN_DATA_FORMAT} dataFormat
 */
MNN.Blob.addDataFormat = function(builder, dataFormat) {
  builder.addFieldInt8(1, dataFormat, MNN.MNN_DATA_FORMAT.NCHW);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} dataType
 */
MNN.Blob.addDataType = function(builder, dataType) {
  builder.addFieldInt32(2, dataType, MNN.DataType.DT_FLOAT);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} uint8sOffset
 */
MNN.Blob.addUint8s = function(builder, uint8sOffset) {
  builder.addFieldOffset(3, uint8sOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Blob.createUint8sVector = function(builder, data) {
  builder.startVector(1, data.length, 1);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt8(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Blob.startUint8sVector = function(builder, numElems) {
  builder.startVector(1, numElems, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} int8sOffset
 */
MNN.Blob.addInt8s = function(builder, int8sOffset) {
  builder.addFieldOffset(4, int8sOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Blob.createInt8sVector = function(builder, data) {
  builder.startVector(1, data.length, 1);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt8(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Blob.startInt8sVector = function(builder, numElems) {
  builder.startVector(1, numElems, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} int32sOffset
 */
MNN.Blob.addInt32s = function(builder, int32sOffset) {
  builder.addFieldOffset(5, int32sOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Blob.createInt32sVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Blob.startInt32sVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} int64sOffset
 */
MNN.Blob.addInt64s = function(builder, int64sOffset) {
  builder.addFieldOffset(6, int64sOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Long>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Blob.createInt64sVector = function(builder, data) {
  builder.startVector(8, data.length, 8);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt64(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Blob.startInt64sVector = function(builder, numElems) {
  builder.startVector(8, numElems, 8);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} float32sOffset
 */
MNN.Blob.addFloat32s = function(builder, float32sOffset) {
  builder.addFieldOffset(7, float32sOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Blob.createFloat32sVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Blob.startFloat32sVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} stringsOffset
 */
MNN.Blob.addStrings = function(builder, stringsOffset) {
  builder.addFieldOffset(8, stringsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Blob.createStringsVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addOffset(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Blob.startStringsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Blob.endBlob = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimsOffset
 * @param {MNN.MNN_DATA_FORMAT} dataFormat
 * @param {MNN.DataType} dataType
 * @param {flatbuffers.Offset} uint8sOffset
 * @param {flatbuffers.Offset} int8sOffset
 * @param {flatbuffers.Offset} int32sOffset
 * @param {flatbuffers.Offset} int64sOffset
 * @param {flatbuffers.Offset} float32sOffset
 * @param {flatbuffers.Offset} stringsOffset
 * @returns {flatbuffers.Offset}
 */
MNN.Blob.createBlob = function(builder, dimsOffset, dataFormat, dataType, uint8sOffset, int8sOffset, int32sOffset, int64sOffset, float32sOffset, stringsOffset) {
  MNN.Blob.startBlob(builder);
  MNN.Blob.addDims(builder, dimsOffset);
  MNN.Blob.addDataFormat(builder, dataFormat);
  MNN.Blob.addDataType(builder, dataType);
  MNN.Blob.addUint8s(builder, uint8sOffset);
  MNN.Blob.addInt8s(builder, int8sOffset);
  MNN.Blob.addInt32s(builder, int32sOffset);
  MNN.Blob.addInt64s(builder, int64sOffset);
  MNN.Blob.addFloat32s(builder, float32sOffset);
  MNN.Blob.addStrings(builder, stringsOffset);
  return MNN.Blob.endBlob(builder);
}

/**
 * @constructor
 */
MNN.ListValue = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.ListValue}
 */
MNN.ListValue.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.ListValue=} obj
 * @returns {MNN.ListValue}
 */
MNN.ListValue.getRootAsListValue = function(bb, obj) {
  return (obj || new MNN.ListValue).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.ListValue=} obj
 * @returns {MNN.ListValue}
 */
MNN.ListValue.getSizePrefixedRootAsListValue = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.ListValue).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array}
 */
MNN.ListValue.prototype.s = function(index, optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
};

/**
 * @returns {number}
 */
MNN.ListValue.prototype.sLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.ListValue.prototype.i = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.ListValue.prototype.iLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.ListValue.prototype.iArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.ListValue.prototype.f = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.ListValue.prototype.fLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.ListValue.prototype.fArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {boolean}
 */
MNN.ListValue.prototype.b = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? !!this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : false;
};

/**
 * @returns {number}
 */
MNN.ListValue.prototype.bLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int8Array}
 */
MNN.ListValue.prototype.bArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {MNN.DataType}
 */
MNN.ListValue.prototype.type = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4)) : /** @type {MNN.DataType} */ (0);
};

/**
 * @returns {number}
 */
MNN.ListValue.prototype.typeLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.ListValue.prototype.typeArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.ListValue.startListValue = function(builder) {
  builder.startObject(5);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} sOffset
 */
MNN.ListValue.addS = function(builder, sOffset) {
  builder.addFieldOffset(0, sOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
MNN.ListValue.createSVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addOffset(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.ListValue.startSVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} iOffset
 */
MNN.ListValue.addI = function(builder, iOffset) {
  builder.addFieldOffset(1, iOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.ListValue.createIVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.ListValue.startIVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} fOffset
 */
MNN.ListValue.addF = function(builder, fOffset) {
  builder.addFieldOffset(2, fOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.ListValue.createFVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.ListValue.startFVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} bOffset
 */
MNN.ListValue.addB = function(builder, bOffset) {
  builder.addFieldOffset(3, bOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<boolean>} data
 * @returns {flatbuffers.Offset}
 */
MNN.ListValue.createBVector = function(builder, data) {
  builder.startVector(1, data.length, 1);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt8(+data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.ListValue.startBVector = function(builder, numElems) {
  builder.startVector(1, numElems, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} typeOffset
 */
MNN.ListValue.addType = function(builder, typeOffset) {
  builder.addFieldOffset(4, typeOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<MNN.DataType>} data
 * @returns {flatbuffers.Offset}
 */
MNN.ListValue.createTypeVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.ListValue.startTypeVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.ListValue.endListValue = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} sOffset
 * @param {flatbuffers.Offset} iOffset
 * @param {flatbuffers.Offset} fOffset
 * @param {flatbuffers.Offset} bOffset
 * @param {flatbuffers.Offset} typeOffset
 * @returns {flatbuffers.Offset}
 */
MNN.ListValue.createListValue = function(builder, sOffset, iOffset, fOffset, bOffset, typeOffset) {
  MNN.ListValue.startListValue(builder);
  MNN.ListValue.addS(builder, sOffset);
  MNN.ListValue.addI(builder, iOffset);
  MNN.ListValue.addF(builder, fOffset);
  MNN.ListValue.addB(builder, bOffset);
  MNN.ListValue.addType(builder, typeOffset);
  return MNN.ListValue.endListValue(builder);
}

/**
 * @constructor
 */
MNN.Attribute = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Attribute}
 */
MNN.Attribute.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Attribute=} obj
 * @returns {MNN.Attribute}
 */
MNN.Attribute.getRootAsAttribute = function(bb, obj) {
  return (obj || new MNN.Attribute).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Attribute=} obj
 * @returns {MNN.Attribute}
 */
MNN.Attribute.getSizePrefixedRootAsAttribute = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Attribute).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
MNN.Attribute.prototype.s = function(optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
};

/**
 * @returns {number}
 */
MNN.Attribute.prototype.i = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {boolean}
 */
MNN.Attribute.prototype.b = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
MNN.Attribute.prototype.key = function(optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
};

/**
 * @returns {MNN.DataType}
 */
MNN.Attribute.prototype.type = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @returns {number}
 */
MNN.Attribute.prototype.f = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.Attribute.prototype.tensor = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.ListValue=} obj
 * @returns {MNN.ListValue|null}
 */
MNN.Attribute.prototype.list = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? (obj || new MNN.ListValue).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Attribute.startAttribute = function(builder) {
  builder.startObject(8);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} sOffset
 */
MNN.Attribute.addS = function(builder, sOffset) {
  builder.addFieldOffset(0, sOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} i
 */
MNN.Attribute.addI = function(builder, i) {
  builder.addFieldInt32(1, i, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} b
 */
MNN.Attribute.addB = function(builder, b) {
  builder.addFieldInt8(2, +b, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} keyOffset
 */
MNN.Attribute.addKey = function(builder, keyOffset) {
  builder.addFieldOffset(3, keyOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} type
 */
MNN.Attribute.addType = function(builder, type) {
  builder.addFieldInt32(4, type, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} f
 */
MNN.Attribute.addF = function(builder, f) {
  builder.addFieldFloat32(5, f, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} tensorOffset
 */
MNN.Attribute.addTensor = function(builder, tensorOffset) {
  builder.addFieldOffset(6, tensorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} listOffset
 */
MNN.Attribute.addList = function(builder, listOffset) {
  builder.addFieldOffset(7, listOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Attribute.endAttribute = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} sOffset
 * @param {number} i
 * @param {boolean} b
 * @param {flatbuffers.Offset} keyOffset
 * @param {MNN.DataType} type
 * @param {number} f
 * @param {flatbuffers.Offset} tensorOffset
 * @param {flatbuffers.Offset} listOffset
 * @returns {flatbuffers.Offset}
 */
MNN.Attribute.createAttribute = function(builder, sOffset, i, b, keyOffset, type, f, tensorOffset, listOffset) {
  MNN.Attribute.startAttribute(builder);
  MNN.Attribute.addS(builder, sOffset);
  MNN.Attribute.addI(builder, i);
  MNN.Attribute.addB(builder, b);
  MNN.Attribute.addKey(builder, keyOffset);
  MNN.Attribute.addType(builder, type);
  MNN.Attribute.addF(builder, f);
  MNN.Attribute.addTensor(builder, tensorOffset);
  MNN.Attribute.addList(builder, listOffset);
  return MNN.Attribute.endAttribute(builder);
}

/**
 * @constructor
 */
MNN.Convolution2DCommon = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Convolution2DCommon}
 */
MNN.Convolution2DCommon.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Convolution2DCommon=} obj
 * @returns {MNN.Convolution2DCommon}
 */
MNN.Convolution2DCommon.getRootAsConvolution2DCommon = function(bb, obj) {
  return (obj || new MNN.Convolution2DCommon).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Convolution2DCommon=} obj
 * @returns {MNN.Convolution2DCommon}
 */
MNN.Convolution2DCommon.getSizePrefixedRootAsConvolution2DCommon = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Convolution2DCommon).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.Convolution2DCommon.prototype.padX = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Convolution2DCommon.prototype.padY = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Convolution2DCommon.prototype.kernelX = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 1;
};

/**
 * @returns {number}
 */
MNN.Convolution2DCommon.prototype.kernelY = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 1;
};

/**
 * @returns {number}
 */
MNN.Convolution2DCommon.prototype.strideX = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 1;
};

/**
 * @returns {number}
 */
MNN.Convolution2DCommon.prototype.strideY = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 1;
};

/**
 * @returns {number}
 */
MNN.Convolution2DCommon.prototype.dilateX = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 1;
};

/**
 * @returns {number}
 */
MNN.Convolution2DCommon.prototype.dilateY = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 1;
};

/**
 * @returns {MNN.PadMode}
 */
MNN.Convolution2DCommon.prototype.padMode = function() {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? /** @type {MNN.PadMode} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.PadMode.CAFFE;
};

/**
 * @returns {number}
 */
MNN.Convolution2DCommon.prototype.group = function() {
  var offset = this.bb.__offset(this.bb_pos, 22);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 1;
};

/**
 * @returns {number}
 */
MNN.Convolution2DCommon.prototype.outputCount = function() {
  var offset = this.bb.__offset(this.bb_pos, 24);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Convolution2DCommon.prototype.inputCount = function() {
  var offset = this.bb.__offset(this.bb_pos, 26);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {boolean}
 */
MNN.Convolution2DCommon.prototype.relu = function() {
  var offset = this.bb.__offset(this.bb_pos, 28);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {boolean}
 */
MNN.Convolution2DCommon.prototype.relu6 = function() {
  var offset = this.bb.__offset(this.bb_pos, 30);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Convolution2DCommon.prototype.pads = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 32);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Convolution2DCommon.prototype.padsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 32);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Convolution2DCommon.prototype.padsArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 32);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Convolution2DCommon.startConvolution2DCommon = function(builder) {
  builder.startObject(15);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padX
 */
MNN.Convolution2DCommon.addPadX = function(builder, padX) {
  builder.addFieldInt32(0, padX, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padY
 */
MNN.Convolution2DCommon.addPadY = function(builder, padY) {
  builder.addFieldInt32(1, padY, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} kernelX
 */
MNN.Convolution2DCommon.addKernelX = function(builder, kernelX) {
  builder.addFieldInt32(2, kernelX, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} kernelY
 */
MNN.Convolution2DCommon.addKernelY = function(builder, kernelY) {
  builder.addFieldInt32(3, kernelY, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideX
 */
MNN.Convolution2DCommon.addStrideX = function(builder, strideX) {
  builder.addFieldInt32(4, strideX, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideY
 */
MNN.Convolution2DCommon.addStrideY = function(builder, strideY) {
  builder.addFieldInt32(5, strideY, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} dilateX
 */
MNN.Convolution2DCommon.addDilateX = function(builder, dilateX) {
  builder.addFieldInt32(6, dilateX, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} dilateY
 */
MNN.Convolution2DCommon.addDilateY = function(builder, dilateY) {
  builder.addFieldInt32(7, dilateY, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.PadMode} padMode
 */
MNN.Convolution2DCommon.addPadMode = function(builder, padMode) {
  builder.addFieldInt8(8, padMode, MNN.PadMode.CAFFE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} group
 */
MNN.Convolution2DCommon.addGroup = function(builder, group) {
  builder.addFieldInt32(9, group, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} outputCount
 */
MNN.Convolution2DCommon.addOutputCount = function(builder, outputCount) {
  builder.addFieldInt32(10, outputCount, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} inputCount
 */
MNN.Convolution2DCommon.addInputCount = function(builder, inputCount) {
  builder.addFieldInt32(11, inputCount, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} relu
 */
MNN.Convolution2DCommon.addRelu = function(builder, relu) {
  builder.addFieldInt8(12, +relu, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} relu6
 */
MNN.Convolution2DCommon.addRelu6 = function(builder, relu6) {
  builder.addFieldInt8(13, +relu6, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} padsOffset
 */
MNN.Convolution2DCommon.addPads = function(builder, padsOffset) {
  builder.addFieldOffset(14, padsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Convolution2DCommon.createPadsVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Convolution2DCommon.startPadsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Convolution2DCommon.endConvolution2DCommon = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padX
 * @param {number} padY
 * @param {number} kernelX
 * @param {number} kernelY
 * @param {number} strideX
 * @param {number} strideY
 * @param {number} dilateX
 * @param {number} dilateY
 * @param {MNN.PadMode} padMode
 * @param {number} group
 * @param {number} outputCount
 * @param {number} inputCount
 * @param {boolean} relu
 * @param {boolean} relu6
 * @param {flatbuffers.Offset} padsOffset
 * @returns {flatbuffers.Offset}
 */
MNN.Convolution2DCommon.createConvolution2DCommon = function(builder, padX, padY, kernelX, kernelY, strideX, strideY, dilateX, dilateY, padMode, group, outputCount, inputCount, relu, relu6, padsOffset) {
  MNN.Convolution2DCommon.startConvolution2DCommon(builder);
  MNN.Convolution2DCommon.addPadX(builder, padX);
  MNN.Convolution2DCommon.addPadY(builder, padY);
  MNN.Convolution2DCommon.addKernelX(builder, kernelX);
  MNN.Convolution2DCommon.addKernelY(builder, kernelY);
  MNN.Convolution2DCommon.addStrideX(builder, strideX);
  MNN.Convolution2DCommon.addStrideY(builder, strideY);
  MNN.Convolution2DCommon.addDilateX(builder, dilateX);
  MNN.Convolution2DCommon.addDilateY(builder, dilateY);
  MNN.Convolution2DCommon.addPadMode(builder, padMode);
  MNN.Convolution2DCommon.addGroup(builder, group);
  MNN.Convolution2DCommon.addOutputCount(builder, outputCount);
  MNN.Convolution2DCommon.addInputCount(builder, inputCount);
  MNN.Convolution2DCommon.addRelu(builder, relu);
  MNN.Convolution2DCommon.addRelu6(builder, relu6);
  MNN.Convolution2DCommon.addPads(builder, padsOffset);
  return MNN.Convolution2DCommon.endConvolution2DCommon(builder);
}

/**
 * @constructor
 */
MNN.Convolution3DCommon = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Convolution3DCommon}
 */
MNN.Convolution3DCommon.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Convolution3DCommon=} obj
 * @returns {MNN.Convolution3DCommon}
 */
MNN.Convolution3DCommon.getRootAsConvolution3DCommon = function(bb, obj) {
  return (obj || new MNN.Convolution3DCommon).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Convolution3DCommon=} obj
 * @returns {MNN.Convolution3DCommon}
 */
MNN.Convolution3DCommon.getSizePrefixedRootAsConvolution3DCommon = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Convolution3DCommon).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Convolution3DCommon.prototype.dilates = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Convolution3DCommon.prototype.dilatesLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Convolution3DCommon.prototype.dilatesArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Convolution3DCommon.prototype.strides = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Convolution3DCommon.prototype.stridesLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Convolution3DCommon.prototype.stridesArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Convolution3DCommon.prototype.kernels = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Convolution3DCommon.prototype.kernelsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Convolution3DCommon.prototype.kernelsArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Convolution3DCommon.prototype.pads = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Convolution3DCommon.prototype.padsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Convolution3DCommon.prototype.padsArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {MNN.PadMode}
 */
MNN.Convolution3DCommon.prototype.padMode = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? /** @type {MNN.PadMode} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.PadMode.CAFFE;
};

/**
 * @returns {number}
 */
MNN.Convolution3DCommon.prototype.inputCount = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Convolution3DCommon.prototype.outputCount = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {boolean}
 */
MNN.Convolution3DCommon.prototype.relu = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {boolean}
 */
MNN.Convolution3DCommon.prototype.relu6 = function() {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Convolution3DCommon.startConvolution3DCommon = function(builder) {
  builder.startObject(9);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dilatesOffset
 */
MNN.Convolution3DCommon.addDilates = function(builder, dilatesOffset) {
  builder.addFieldOffset(0, dilatesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Convolution3DCommon.createDilatesVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Convolution3DCommon.startDilatesVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} stridesOffset
 */
MNN.Convolution3DCommon.addStrides = function(builder, stridesOffset) {
  builder.addFieldOffset(1, stridesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Convolution3DCommon.createStridesVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Convolution3DCommon.startStridesVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} kernelsOffset
 */
MNN.Convolution3DCommon.addKernels = function(builder, kernelsOffset) {
  builder.addFieldOffset(2, kernelsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Convolution3DCommon.createKernelsVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Convolution3DCommon.startKernelsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} padsOffset
 */
MNN.Convolution3DCommon.addPads = function(builder, padsOffset) {
  builder.addFieldOffset(3, padsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Convolution3DCommon.createPadsVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Convolution3DCommon.startPadsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.PadMode} padMode
 */
MNN.Convolution3DCommon.addPadMode = function(builder, padMode) {
  builder.addFieldInt8(4, padMode, MNN.PadMode.CAFFE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} inputCount
 */
MNN.Convolution3DCommon.addInputCount = function(builder, inputCount) {
  builder.addFieldInt32(5, inputCount, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} outputCount
 */
MNN.Convolution3DCommon.addOutputCount = function(builder, outputCount) {
  builder.addFieldInt32(6, outputCount, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} relu
 */
MNN.Convolution3DCommon.addRelu = function(builder, relu) {
  builder.addFieldInt8(7, +relu, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} relu6
 */
MNN.Convolution3DCommon.addRelu6 = function(builder, relu6) {
  builder.addFieldInt8(8, +relu6, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Convolution3DCommon.endConvolution3DCommon = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dilatesOffset
 * @param {flatbuffers.Offset} stridesOffset
 * @param {flatbuffers.Offset} kernelsOffset
 * @param {flatbuffers.Offset} padsOffset
 * @param {MNN.PadMode} padMode
 * @param {number} inputCount
 * @param {number} outputCount
 * @param {boolean} relu
 * @param {boolean} relu6
 * @returns {flatbuffers.Offset}
 */
MNN.Convolution3DCommon.createConvolution3DCommon = function(builder, dilatesOffset, stridesOffset, kernelsOffset, padsOffset, padMode, inputCount, outputCount, relu, relu6) {
  MNN.Convolution3DCommon.startConvolution3DCommon(builder);
  MNN.Convolution3DCommon.addDilates(builder, dilatesOffset);
  MNN.Convolution3DCommon.addStrides(builder, stridesOffset);
  MNN.Convolution3DCommon.addKernels(builder, kernelsOffset);
  MNN.Convolution3DCommon.addPads(builder, padsOffset);
  MNN.Convolution3DCommon.addPadMode(builder, padMode);
  MNN.Convolution3DCommon.addInputCount(builder, inputCount);
  MNN.Convolution3DCommon.addOutputCount(builder, outputCount);
  MNN.Convolution3DCommon.addRelu(builder, relu);
  MNN.Convolution3DCommon.addRelu6(builder, relu6);
  return MNN.Convolution3DCommon.endConvolution3DCommon(builder);
}

/**
 * @constructor
 */
MNN.IDSTQuan = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.IDSTQuan}
 */
MNN.IDSTQuan.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.IDSTQuan=} obj
 * @returns {MNN.IDSTQuan}
 */
MNN.IDSTQuan.getRootAsIDSTQuan = function(bb, obj) {
  return (obj || new MNN.IDSTQuan).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.IDSTQuan=} obj
 * @returns {MNN.IDSTQuan}
 */
MNN.IDSTQuan.getSizePrefixedRootAsIDSTQuan = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.IDSTQuan).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.IDSTQuan.prototype.buffer = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
};

/**
 * @returns {number}
 */
MNN.IDSTQuan.prototype.bufferLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int8Array}
 */
MNN.IDSTQuan.prototype.bufferArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.IDSTQuan.prototype.alpha = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.IDSTQuan.prototype.alphaLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.IDSTQuan.prototype.alphaArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {number}
 */
MNN.IDSTQuan.prototype.type = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {boolean}
 */
MNN.IDSTQuan.prototype.useInt32 = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {number}
 */
MNN.IDSTQuan.prototype.quantScale = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @returns {number}
 */
MNN.IDSTQuan.prototype.scaleIn = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @returns {number}
 */
MNN.IDSTQuan.prototype.scaleOut = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @returns {number}
 */
MNN.IDSTQuan.prototype.aMax = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.IDSTQuan.prototype.aMin = function() {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.IDSTQuan.prototype.readType = function() {
  var offset = this.bb.__offset(this.bb_pos, 22);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {boolean}
 */
MNN.IDSTQuan.prototype.hasScaleInt = function() {
  var offset = this.bb.__offset(this.bb_pos, 24);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.IDSTQuan.startIDSTQuan = function(builder) {
  builder.startObject(11);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} bufferOffset
 */
MNN.IDSTQuan.addBuffer = function(builder, bufferOffset) {
  builder.addFieldOffset(0, bufferOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.IDSTQuan.createBufferVector = function(builder, data) {
  builder.startVector(1, data.length, 1);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt8(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.IDSTQuan.startBufferVector = function(builder, numElems) {
  builder.startVector(1, numElems, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} alphaOffset
 */
MNN.IDSTQuan.addAlpha = function(builder, alphaOffset) {
  builder.addFieldOffset(1, alphaOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.IDSTQuan.createAlphaVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.IDSTQuan.startAlphaVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} type
 */
MNN.IDSTQuan.addType = function(builder, type) {
  builder.addFieldInt32(2, type, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} useInt32
 */
MNN.IDSTQuan.addUseInt32 = function(builder, useInt32) {
  builder.addFieldInt8(3, +useInt32, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} quantScale
 */
MNN.IDSTQuan.addQuantScale = function(builder, quantScale) {
  builder.addFieldFloat32(4, quantScale, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} scaleIn
 */
MNN.IDSTQuan.addScaleIn = function(builder, scaleIn) {
  builder.addFieldFloat32(5, scaleIn, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} scaleOut
 */
MNN.IDSTQuan.addScaleOut = function(builder, scaleOut) {
  builder.addFieldFloat32(6, scaleOut, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} aMax
 */
MNN.IDSTQuan.addAMax = function(builder, aMax) {
  builder.addFieldInt32(7, aMax, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} aMin
 */
MNN.IDSTQuan.addAMin = function(builder, aMin) {
  builder.addFieldInt32(8, aMin, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} readType
 */
MNN.IDSTQuan.addReadType = function(builder, readType) {
  builder.addFieldInt32(9, readType, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} hasScaleInt
 */
MNN.IDSTQuan.addHasScaleInt = function(builder, hasScaleInt) {
  builder.addFieldInt8(10, +hasScaleInt, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.IDSTQuan.endIDSTQuan = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} bufferOffset
 * @param {flatbuffers.Offset} alphaOffset
 * @param {number} type
 * @param {boolean} useInt32
 * @param {number} quantScale
 * @param {number} scaleIn
 * @param {number} scaleOut
 * @param {number} aMax
 * @param {number} aMin
 * @param {number} readType
 * @param {boolean} hasScaleInt
 * @returns {flatbuffers.Offset}
 */
MNN.IDSTQuan.createIDSTQuan = function(builder, bufferOffset, alphaOffset, type, useInt32, quantScale, scaleIn, scaleOut, aMax, aMin, readType, hasScaleInt) {
  MNN.IDSTQuan.startIDSTQuan(builder);
  MNN.IDSTQuan.addBuffer(builder, bufferOffset);
  MNN.IDSTQuan.addAlpha(builder, alphaOffset);
  MNN.IDSTQuan.addType(builder, type);
  MNN.IDSTQuan.addUseInt32(builder, useInt32);
  MNN.IDSTQuan.addQuantScale(builder, quantScale);
  MNN.IDSTQuan.addScaleIn(builder, scaleIn);
  MNN.IDSTQuan.addScaleOut(builder, scaleOut);
  MNN.IDSTQuan.addAMax(builder, aMax);
  MNN.IDSTQuan.addAMin(builder, aMin);
  MNN.IDSTQuan.addReadType(builder, readType);
  MNN.IDSTQuan.addHasScaleInt(builder, hasScaleInt);
  return MNN.IDSTQuan.endIDSTQuan(builder);
}

/**
 * @constructor
 */
MNN.QuantizedFloatParam = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.QuantizedFloatParam}
 */
MNN.QuantizedFloatParam.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedFloatParam=} obj
 * @returns {MNN.QuantizedFloatParam}
 */
MNN.QuantizedFloatParam.getRootAsQuantizedFloatParam = function(bb, obj) {
  return (obj || new MNN.QuantizedFloatParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedFloatParam=} obj
 * @returns {MNN.QuantizedFloatParam}
 */
MNN.QuantizedFloatParam.getSizePrefixedRootAsQuantizedFloatParam = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.QuantizedFloatParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.QuantizedFloatParam.prototype.weight = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedFloatParam.prototype.weightLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int8Array}
 */
MNN.QuantizedFloatParam.prototype.weightArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.QuantizedFloatParam.prototype.bias = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedFloatParam.prototype.biasLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.QuantizedFloatParam.prototype.biasArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.QuantizedFloatParam.prototype.scale = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedFloatParam.prototype.scaleLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.QuantizedFloatParam.prototype.scaleArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.QuantizedFloatParam.prototype.tensorScale = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedFloatParam.prototype.tensorScaleLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.QuantizedFloatParam.prototype.tensorScaleArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.QuantizedFloatParam.startQuantizedFloatParam = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} weightOffset
 */
MNN.QuantizedFloatParam.addWeight = function(builder, weightOffset) {
  builder.addFieldOffset(0, weightOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedFloatParam.createWeightVector = function(builder, data) {
  builder.startVector(1, data.length, 1);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt8(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.QuantizedFloatParam.startWeightVector = function(builder, numElems) {
  builder.startVector(1, numElems, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} biasOffset
 */
MNN.QuantizedFloatParam.addBias = function(builder, biasOffset) {
  builder.addFieldOffset(1, biasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedFloatParam.createBiasVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.QuantizedFloatParam.startBiasVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} scaleOffset
 */
MNN.QuantizedFloatParam.addScale = function(builder, scaleOffset) {
  builder.addFieldOffset(2, scaleOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedFloatParam.createScaleVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.QuantizedFloatParam.startScaleVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} tensorScaleOffset
 */
MNN.QuantizedFloatParam.addTensorScale = function(builder, tensorScaleOffset) {
  builder.addFieldOffset(3, tensorScaleOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedFloatParam.createTensorScaleVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.QuantizedFloatParam.startTensorScaleVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedFloatParam.endQuantizedFloatParam = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} weightOffset
 * @param {flatbuffers.Offset} biasOffset
 * @param {flatbuffers.Offset} scaleOffset
 * @param {flatbuffers.Offset} tensorScaleOffset
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedFloatParam.createQuantizedFloatParam = function(builder, weightOffset, biasOffset, scaleOffset, tensorScaleOffset) {
  MNN.QuantizedFloatParam.startQuantizedFloatParam(builder);
  MNN.QuantizedFloatParam.addWeight(builder, weightOffset);
  MNN.QuantizedFloatParam.addBias(builder, biasOffset);
  MNN.QuantizedFloatParam.addScale(builder, scaleOffset);
  MNN.QuantizedFloatParam.addTensorScale(builder, tensorScaleOffset);
  return MNN.QuantizedFloatParam.endQuantizedFloatParam(builder);
}

/**
 * @constructor
 */
MNN.Convolution2D = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Convolution2D}
 */
MNN.Convolution2D.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Convolution2D=} obj
 * @returns {MNN.Convolution2D}
 */
MNN.Convolution2D.getRootAsConvolution2D = function(bb, obj) {
  return (obj || new MNN.Convolution2D).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Convolution2D=} obj
 * @returns {MNN.Convolution2D}
 */
MNN.Convolution2D.getSizePrefixedRootAsConvolution2D = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Convolution2D).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {MNN.Convolution2DCommon=} obj
 * @returns {MNN.Convolution2DCommon|null}
 */
MNN.Convolution2D.prototype.common = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? (obj || new MNN.Convolution2DCommon).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Convolution2D.prototype.weight = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Convolution2D.prototype.weightLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.Convolution2D.prototype.weightArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Convolution2D.prototype.bias = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Convolution2D.prototype.biasLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.Convolution2D.prototype.biasArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {MNN.IDSTQuan=} obj
 * @returns {MNN.IDSTQuan|null}
 */
MNN.Convolution2D.prototype.quanParameter = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? (obj || new MNN.IDSTQuan).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.QuantizedFloatParam=} obj
 * @returns {MNN.QuantizedFloatParam|null}
 */
MNN.Convolution2D.prototype.symmetricQuan = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? (obj || new MNN.QuantizedFloatParam).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Convolution2D.startConvolution2D = function(builder) {
  builder.startObject(5);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} commonOffset
 */
MNN.Convolution2D.addCommon = function(builder, commonOffset) {
  builder.addFieldOffset(0, commonOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} weightOffset
 */
MNN.Convolution2D.addWeight = function(builder, weightOffset) {
  builder.addFieldOffset(1, weightOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Convolution2D.createWeightVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Convolution2D.startWeightVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} biasOffset
 */
MNN.Convolution2D.addBias = function(builder, biasOffset) {
  builder.addFieldOffset(2, biasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Convolution2D.createBiasVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Convolution2D.startBiasVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} quanParameterOffset
 */
MNN.Convolution2D.addQuanParameter = function(builder, quanParameterOffset) {
  builder.addFieldOffset(3, quanParameterOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} symmetricQuanOffset
 */
MNN.Convolution2D.addSymmetricQuan = function(builder, symmetricQuanOffset) {
  builder.addFieldOffset(4, symmetricQuanOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Convolution2D.endConvolution2D = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} commonOffset
 * @param {flatbuffers.Offset} weightOffset
 * @param {flatbuffers.Offset} biasOffset
 * @param {flatbuffers.Offset} quanParameterOffset
 * @param {flatbuffers.Offset} symmetricQuanOffset
 * @returns {flatbuffers.Offset}
 */
MNN.Convolution2D.createConvolution2D = function(builder, commonOffset, weightOffset, biasOffset, quanParameterOffset, symmetricQuanOffset) {
  MNN.Convolution2D.startConvolution2D(builder);
  MNN.Convolution2D.addCommon(builder, commonOffset);
  MNN.Convolution2D.addWeight(builder, weightOffset);
  MNN.Convolution2D.addBias(builder, biasOffset);
  MNN.Convolution2D.addQuanParameter(builder, quanParameterOffset);
  MNN.Convolution2D.addSymmetricQuan(builder, symmetricQuanOffset);
  return MNN.Convolution2D.endConvolution2D(builder);
}

/**
 * @constructor
 */
MNN.Convolution3D = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Convolution3D}
 */
MNN.Convolution3D.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Convolution3D=} obj
 * @returns {MNN.Convolution3D}
 */
MNN.Convolution3D.getRootAsConvolution3D = function(bb, obj) {
  return (obj || new MNN.Convolution3D).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Convolution3D=} obj
 * @returns {MNN.Convolution3D}
 */
MNN.Convolution3D.getSizePrefixedRootAsConvolution3D = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Convolution3D).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {MNN.Convolution3DCommon=} obj
 * @returns {MNN.Convolution3DCommon|null}
 */
MNN.Convolution3D.prototype.common = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? (obj || new MNN.Convolution3DCommon).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Convolution3D.prototype.weight = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Convolution3D.prototype.weightLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.Convolution3D.prototype.weightArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Convolution3D.prototype.bias = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Convolution3D.prototype.biasLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.Convolution3D.prototype.biasArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Convolution3D.startConvolution3D = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} commonOffset
 */
MNN.Convolution3D.addCommon = function(builder, commonOffset) {
  builder.addFieldOffset(0, commonOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} weightOffset
 */
MNN.Convolution3D.addWeight = function(builder, weightOffset) {
  builder.addFieldOffset(1, weightOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Convolution3D.createWeightVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Convolution3D.startWeightVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} biasOffset
 */
MNN.Convolution3D.addBias = function(builder, biasOffset) {
  builder.addFieldOffset(2, biasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Convolution3D.createBiasVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Convolution3D.startBiasVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Convolution3D.endConvolution3D = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} commonOffset
 * @param {flatbuffers.Offset} weightOffset
 * @param {flatbuffers.Offset} biasOffset
 * @returns {flatbuffers.Offset}
 */
MNN.Convolution3D.createConvolution3D = function(builder, commonOffset, weightOffset, biasOffset) {
  MNN.Convolution3D.startConvolution3D(builder);
  MNN.Convolution3D.addCommon(builder, commonOffset);
  MNN.Convolution3D.addWeight(builder, weightOffset);
  MNN.Convolution3D.addBias(builder, biasOffset);
  return MNN.Convolution3D.endConvolution3D(builder);
}

/**
 * @constructor
 */
MNN.InnerProduct = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.InnerProduct}
 */
MNN.InnerProduct.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.InnerProduct=} obj
 * @returns {MNN.InnerProduct}
 */
MNN.InnerProduct.getRootAsInnerProduct = function(bb, obj) {
  return (obj || new MNN.InnerProduct).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.InnerProduct=} obj
 * @returns {MNN.InnerProduct}
 */
MNN.InnerProduct.getSizePrefixedRootAsInnerProduct = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.InnerProduct).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.InnerProduct.prototype.outputCount = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.InnerProduct.prototype.biasTerm = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.InnerProduct.prototype.weightSize = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.InnerProduct.prototype.weight = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.InnerProduct.prototype.weightLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.InnerProduct.prototype.weightArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.InnerProduct.prototype.bias = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.InnerProduct.prototype.biasLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.InnerProduct.prototype.biasArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {number}
 */
MNN.InnerProduct.prototype.axis = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {boolean}
 */
MNN.InnerProduct.prototype.transpose = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {MNN.IDSTQuan=} obj
 * @returns {MNN.IDSTQuan|null}
 */
MNN.InnerProduct.prototype.quanParameter = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? (obj || new MNN.IDSTQuan).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.InnerProduct.startInnerProduct = function(builder) {
  builder.startObject(8);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} outputCount
 */
MNN.InnerProduct.addOutputCount = function(builder, outputCount) {
  builder.addFieldInt32(0, outputCount, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} biasTerm
 */
MNN.InnerProduct.addBiasTerm = function(builder, biasTerm) {
  builder.addFieldInt32(1, biasTerm, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} weightSize
 */
MNN.InnerProduct.addWeightSize = function(builder, weightSize) {
  builder.addFieldInt32(2, weightSize, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} weightOffset
 */
MNN.InnerProduct.addWeight = function(builder, weightOffset) {
  builder.addFieldOffset(3, weightOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.InnerProduct.createWeightVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.InnerProduct.startWeightVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} biasOffset
 */
MNN.InnerProduct.addBias = function(builder, biasOffset) {
  builder.addFieldOffset(4, biasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.InnerProduct.createBiasVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.InnerProduct.startBiasVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 */
MNN.InnerProduct.addAxis = function(builder, axis) {
  builder.addFieldInt32(5, axis, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} transpose
 */
MNN.InnerProduct.addTranspose = function(builder, transpose) {
  builder.addFieldInt8(6, +transpose, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} quanParameterOffset
 */
MNN.InnerProduct.addQuanParameter = function(builder, quanParameterOffset) {
  builder.addFieldOffset(7, quanParameterOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.InnerProduct.endInnerProduct = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} outputCount
 * @param {number} biasTerm
 * @param {number} weightSize
 * @param {flatbuffers.Offset} weightOffset
 * @param {flatbuffers.Offset} biasOffset
 * @param {number} axis
 * @param {boolean} transpose
 * @param {flatbuffers.Offset} quanParameterOffset
 * @returns {flatbuffers.Offset}
 */
MNN.InnerProduct.createInnerProduct = function(builder, outputCount, biasTerm, weightSize, weightOffset, biasOffset, axis, transpose, quanParameterOffset) {
  MNN.InnerProduct.startInnerProduct(builder);
  MNN.InnerProduct.addOutputCount(builder, outputCount);
  MNN.InnerProduct.addBiasTerm(builder, biasTerm);
  MNN.InnerProduct.addWeightSize(builder, weightSize);
  MNN.InnerProduct.addWeight(builder, weightOffset);
  MNN.InnerProduct.addBias(builder, biasOffset);
  MNN.InnerProduct.addAxis(builder, axis);
  MNN.InnerProduct.addTranspose(builder, transpose);
  MNN.InnerProduct.addQuanParameter(builder, quanParameterOffset);
  return MNN.InnerProduct.endInnerProduct(builder);
}

/**
 * @constructor
 */
MNN.Pool = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Pool}
 */
MNN.Pool.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Pool=} obj
 * @returns {MNN.Pool}
 */
MNN.Pool.getRootAsPool = function(bb, obj) {
  return (obj || new MNN.Pool).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Pool=} obj
 * @returns {MNN.Pool}
 */
MNN.Pool.getSizePrefixedRootAsPool = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Pool).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.Pool.prototype.padX = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Pool.prototype.padY = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {boolean}
 */
MNN.Pool.prototype.isGlobal = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {number}
 */
MNN.Pool.prototype.kernelX = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Pool.prototype.kernelY = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Pool.prototype.strideX = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Pool.prototype.strideY = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {MNN.PoolType}
 */
MNN.Pool.prototype.type = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? /** @type {MNN.PoolType} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.PoolType.MAXPOOL;
};

/**
 * @returns {MNN.PoolPadType}
 */
MNN.Pool.prototype.padType = function() {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? /** @type {MNN.PoolPadType} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.PoolPadType.CAFFE;
};

/**
 * @returns {MNN.DataType}
 */
MNN.Pool.prototype.dataType = function() {
  var offset = this.bb.__offset(this.bb_pos, 22);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_FLOAT;
};

/**
 * @returns {boolean}
 */
MNN.Pool.prototype.ceilModel = function() {
  var offset = this.bb.__offset(this.bb_pos, 24);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : true;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Pool.prototype.pads = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 26);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Pool.prototype.padsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 26);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Pool.prototype.padsArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 26);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Pool.startPool = function(builder) {
  builder.startObject(12);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padX
 */
MNN.Pool.addPadX = function(builder, padX) {
  builder.addFieldInt32(0, padX, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padY
 */
MNN.Pool.addPadY = function(builder, padY) {
  builder.addFieldInt32(1, padY, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} isGlobal
 */
MNN.Pool.addIsGlobal = function(builder, isGlobal) {
  builder.addFieldInt8(2, +isGlobal, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} kernelX
 */
MNN.Pool.addKernelX = function(builder, kernelX) {
  builder.addFieldInt32(3, kernelX, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} kernelY
 */
MNN.Pool.addKernelY = function(builder, kernelY) {
  builder.addFieldInt32(4, kernelY, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideX
 */
MNN.Pool.addStrideX = function(builder, strideX) {
  builder.addFieldInt32(5, strideX, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideY
 */
MNN.Pool.addStrideY = function(builder, strideY) {
  builder.addFieldInt32(6, strideY, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.PoolType} type
 */
MNN.Pool.addType = function(builder, type) {
  builder.addFieldInt8(7, type, MNN.PoolType.MAXPOOL);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.PoolPadType} padType
 */
MNN.Pool.addPadType = function(builder, padType) {
  builder.addFieldInt8(8, padType, MNN.PoolPadType.CAFFE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} dataType
 */
MNN.Pool.addDataType = function(builder, dataType) {
  builder.addFieldInt32(9, dataType, MNN.DataType.DT_FLOAT);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} ceilModel
 */
MNN.Pool.addCeilModel = function(builder, ceilModel) {
  builder.addFieldInt8(10, +ceilModel, +true);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} padsOffset
 */
MNN.Pool.addPads = function(builder, padsOffset) {
  builder.addFieldOffset(11, padsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Pool.createPadsVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Pool.startPadsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Pool.endPool = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padX
 * @param {number} padY
 * @param {boolean} isGlobal
 * @param {number} kernelX
 * @param {number} kernelY
 * @param {number} strideX
 * @param {number} strideY
 * @param {MNN.PoolType} type
 * @param {MNN.PoolPadType} padType
 * @param {MNN.DataType} dataType
 * @param {boolean} ceilModel
 * @param {flatbuffers.Offset} padsOffset
 * @returns {flatbuffers.Offset}
 */
MNN.Pool.createPool = function(builder, padX, padY, isGlobal, kernelX, kernelY, strideX, strideY, type, padType, dataType, ceilModel, padsOffset) {
  MNN.Pool.startPool(builder);
  MNN.Pool.addPadX(builder, padX);
  MNN.Pool.addPadY(builder, padY);
  MNN.Pool.addIsGlobal(builder, isGlobal);
  MNN.Pool.addKernelX(builder, kernelX);
  MNN.Pool.addKernelY(builder, kernelY);
  MNN.Pool.addStrideX(builder, strideX);
  MNN.Pool.addStrideY(builder, strideY);
  MNN.Pool.addType(builder, type);
  MNN.Pool.addPadType(builder, padType);
  MNN.Pool.addDataType(builder, dataType);
  MNN.Pool.addCeilModel(builder, ceilModel);
  MNN.Pool.addPads(builder, padsOffset);
  return MNN.Pool.endPool(builder);
}

/**
 * @constructor
 */
MNN.Pool3D = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Pool3D}
 */
MNN.Pool3D.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Pool3D=} obj
 * @returns {MNN.Pool3D}
 */
MNN.Pool3D.getRootAsPool3D = function(bb, obj) {
  return (obj || new MNN.Pool3D).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Pool3D=} obj
 * @returns {MNN.Pool3D}
 */
MNN.Pool3D.getSizePrefixedRootAsPool3D = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Pool3D).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Pool3D.prototype.strides = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Pool3D.prototype.stridesLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Pool3D.prototype.stridesArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Pool3D.prototype.kernels = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Pool3D.prototype.kernelsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Pool3D.prototype.kernelsArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Pool3D.prototype.pads = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Pool3D.prototype.padsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Pool3D.prototype.padsArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {MNN.PoolType}
 */
MNN.Pool3D.prototype.type = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? /** @type {MNN.PoolType} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.PoolType.MAXPOOL;
};

/**
 * @returns {MNN.PoolPadType}
 */
MNN.Pool3D.prototype.padType = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? /** @type {MNN.PoolPadType} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.PoolPadType.CAFFE;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Pool3D.startPool3D = function(builder) {
  builder.startObject(5);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} stridesOffset
 */
MNN.Pool3D.addStrides = function(builder, stridesOffset) {
  builder.addFieldOffset(0, stridesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Pool3D.createStridesVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Pool3D.startStridesVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} kernelsOffset
 */
MNN.Pool3D.addKernels = function(builder, kernelsOffset) {
  builder.addFieldOffset(1, kernelsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Pool3D.createKernelsVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Pool3D.startKernelsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} padsOffset
 */
MNN.Pool3D.addPads = function(builder, padsOffset) {
  builder.addFieldOffset(2, padsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Pool3D.createPadsVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Pool3D.startPadsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.PoolType} type
 */
MNN.Pool3D.addType = function(builder, type) {
  builder.addFieldInt8(3, type, MNN.PoolType.MAXPOOL);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.PoolPadType} padType
 */
MNN.Pool3D.addPadType = function(builder, padType) {
  builder.addFieldInt8(4, padType, MNN.PoolPadType.CAFFE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Pool3D.endPool3D = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} stridesOffset
 * @param {flatbuffers.Offset} kernelsOffset
 * @param {flatbuffers.Offset} padsOffset
 * @param {MNN.PoolType} type
 * @param {MNN.PoolPadType} padType
 * @returns {flatbuffers.Offset}
 */
MNN.Pool3D.createPool3D = function(builder, stridesOffset, kernelsOffset, padsOffset, type, padType) {
  MNN.Pool3D.startPool3D(builder);
  MNN.Pool3D.addStrides(builder, stridesOffset);
  MNN.Pool3D.addKernels(builder, kernelsOffset);
  MNN.Pool3D.addPads(builder, padsOffset);
  MNN.Pool3D.addType(builder, type);
  MNN.Pool3D.addPadType(builder, padType);
  return MNN.Pool3D.endPool3D(builder);
}

/**
 * @constructor
 */
MNN.Relu = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Relu}
 */
MNN.Relu.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Relu=} obj
 * @returns {MNN.Relu}
 */
MNN.Relu.getRootAsRelu = function(bb, obj) {
  return (obj || new MNN.Relu).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Relu=} obj
 * @returns {MNN.Relu}
 */
MNN.Relu.getSizePrefixedRootAsRelu = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Relu).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.Relu.prototype.slope = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Relu.startRelu = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} slope
 */
MNN.Relu.addSlope = function(builder, slope) {
  builder.addFieldFloat32(0, slope, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Relu.endRelu = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} slope
 * @returns {flatbuffers.Offset}
 */
MNN.Relu.createRelu = function(builder, slope) {
  MNN.Relu.startRelu(builder);
  MNN.Relu.addSlope(builder, slope);
  return MNN.Relu.endRelu(builder);
}

/**
 * @constructor
 */
MNN.Relu6 = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Relu6}
 */
MNN.Relu6.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Relu6=} obj
 * @returns {MNN.Relu6}
 */
MNN.Relu6.getRootAsRelu6 = function(bb, obj) {
  return (obj || new MNN.Relu6).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Relu6=} obj
 * @returns {MNN.Relu6}
 */
MNN.Relu6.getSizePrefixedRootAsRelu6 = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Relu6).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.Relu6.prototype.slope = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Relu6.startRelu6 = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} slope
 */
MNN.Relu6.addSlope = function(builder, slope) {
  builder.addFieldFloat32(0, slope, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Relu6.endRelu6 = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} slope
 * @returns {flatbuffers.Offset}
 */
MNN.Relu6.createRelu6 = function(builder, slope) {
  MNN.Relu6.startRelu6(builder);
  MNN.Relu6.addSlope(builder, slope);
  return MNN.Relu6.endRelu6(builder);
}

/**
 * @constructor
 */
MNN.PRelu = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.PRelu}
 */
MNN.PRelu.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.PRelu=} obj
 * @returns {MNN.PRelu}
 */
MNN.PRelu.getRootAsPRelu = function(bb, obj) {
  return (obj || new MNN.PRelu).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.PRelu=} obj
 * @returns {MNN.PRelu}
 */
MNN.PRelu.getSizePrefixedRootAsPRelu = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.PRelu).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.PRelu.prototype.slopeCount = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.PRelu.prototype.slope = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.PRelu.prototype.slopeLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.PRelu.prototype.slopeArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.PRelu.startPRelu = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} slopeCount
 */
MNN.PRelu.addSlopeCount = function(builder, slopeCount) {
  builder.addFieldInt32(0, slopeCount, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} slopeOffset
 */
MNN.PRelu.addSlope = function(builder, slopeOffset) {
  builder.addFieldOffset(1, slopeOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.PRelu.createSlopeVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.PRelu.startSlopeVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.PRelu.endPRelu = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} slopeCount
 * @param {flatbuffers.Offset} slopeOffset
 * @returns {flatbuffers.Offset}
 */
MNN.PRelu.createPRelu = function(builder, slopeCount, slopeOffset) {
  MNN.PRelu.startPRelu(builder);
  MNN.PRelu.addSlopeCount(builder, slopeCount);
  MNN.PRelu.addSlope(builder, slopeOffset);
  return MNN.PRelu.endPRelu(builder);
}

/**
 * @constructor
 */
MNN.ELU = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.ELU}
 */
MNN.ELU.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.ELU=} obj
 * @returns {MNN.ELU}
 */
MNN.ELU.getRootAsELU = function(bb, obj) {
  return (obj || new MNN.ELU).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.ELU=} obj
 * @returns {MNN.ELU}
 */
MNN.ELU.getSizePrefixedRootAsELU = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.ELU).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.ELU.prototype.alpha = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.ELU.startELU = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} alpha
 */
MNN.ELU.addAlpha = function(builder, alpha) {
  builder.addFieldFloat32(0, alpha, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.ELU.endELU = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} alpha
 * @returns {flatbuffers.Offset}
 */
MNN.ELU.createELU = function(builder, alpha) {
  MNN.ELU.startELU(builder);
  MNN.ELU.addAlpha(builder, alpha);
  return MNN.ELU.endELU(builder);
}

/**
 * @constructor
 */
MNN.LRN = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.LRN}
 */
MNN.LRN.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.LRN=} obj
 * @returns {MNN.LRN}
 */
MNN.LRN.getRootAsLRN = function(bb, obj) {
  return (obj || new MNN.LRN).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.LRN=} obj
 * @returns {MNN.LRN}
 */
MNN.LRN.getSizePrefixedRootAsLRN = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.LRN).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.LRN.prototype.regionType = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.LRN.prototype.localSize = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.LRN.prototype.alpha = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @returns {number}
 */
MNN.LRN.prototype.beta = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.LRN.startLRN = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} regionType
 */
MNN.LRN.addRegionType = function(builder, regionType) {
  builder.addFieldInt32(0, regionType, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} localSize
 */
MNN.LRN.addLocalSize = function(builder, localSize) {
  builder.addFieldInt32(1, localSize, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} alpha
 */
MNN.LRN.addAlpha = function(builder, alpha) {
  builder.addFieldFloat32(2, alpha, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} beta
 */
MNN.LRN.addBeta = function(builder, beta) {
  builder.addFieldFloat32(3, beta, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.LRN.endLRN = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} regionType
 * @param {number} localSize
 * @param {number} alpha
 * @param {number} beta
 * @returns {flatbuffers.Offset}
 */
MNN.LRN.createLRN = function(builder, regionType, localSize, alpha, beta) {
  MNN.LRN.startLRN(builder);
  MNN.LRN.addRegionType(builder, regionType);
  MNN.LRN.addLocalSize(builder, localSize);
  MNN.LRN.addAlpha(builder, alpha);
  MNN.LRN.addBeta(builder, beta);
  return MNN.LRN.endLRN(builder);
}

/**
 * @constructor
 */
MNN.ArgMax = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.ArgMax}
 */
MNN.ArgMax.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.ArgMax=} obj
 * @returns {MNN.ArgMax}
 */
MNN.ArgMax.getRootAsArgMax = function(bb, obj) {
  return (obj || new MNN.ArgMax).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.ArgMax=} obj
 * @returns {MNN.ArgMax}
 */
MNN.ArgMax.getSizePrefixedRootAsArgMax = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.ArgMax).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.ArgMax.prototype.outMaxVal = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.ArgMax.prototype.topK = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.ArgMax.prototype.axis = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.ArgMax.prototype.softmaxThreshold = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.ArgMax.startArgMax = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} outMaxVal
 */
MNN.ArgMax.addOutMaxVal = function(builder, outMaxVal) {
  builder.addFieldInt32(0, outMaxVal, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} topK
 */
MNN.ArgMax.addTopK = function(builder, topK) {
  builder.addFieldInt32(1, topK, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 */
MNN.ArgMax.addAxis = function(builder, axis) {
  builder.addFieldInt32(2, axis, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} softmaxThreshold
 */
MNN.ArgMax.addSoftmaxThreshold = function(builder, softmaxThreshold) {
  builder.addFieldInt32(3, softmaxThreshold, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.ArgMax.endArgMax = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} outMaxVal
 * @param {number} topK
 * @param {number} axis
 * @param {number} softmaxThreshold
 * @returns {flatbuffers.Offset}
 */
MNN.ArgMax.createArgMax = function(builder, outMaxVal, topK, axis, softmaxThreshold) {
  MNN.ArgMax.startArgMax(builder);
  MNN.ArgMax.addOutMaxVal(builder, outMaxVal);
  MNN.ArgMax.addTopK(builder, topK);
  MNN.ArgMax.addAxis(builder, axis);
  MNN.ArgMax.addSoftmaxThreshold(builder, softmaxThreshold);
  return MNN.ArgMax.endArgMax(builder);
}

/**
 * @constructor
 */
MNN.Axis = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Axis}
 */
MNN.Axis.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Axis=} obj
 * @returns {MNN.Axis}
 */
MNN.Axis.getRootAsAxis = function(bb, obj) {
  return (obj || new MNN.Axis).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Axis=} obj
 * @returns {MNN.Axis}
 */
MNN.Axis.getSizePrefixedRootAsAxis = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Axis).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.Axis.prototype.axis = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Axis.startAxis = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 */
MNN.Axis.addAxis = function(builder, axis) {
  builder.addFieldInt32(0, axis, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Axis.endAxis = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 * @returns {flatbuffers.Offset}
 */
MNN.Axis.createAxis = function(builder, axis) {
  MNN.Axis.startAxis(builder);
  MNN.Axis.addAxis(builder, axis);
  return MNN.Axis.endAxis(builder);
}

/**
 * @constructor
 */
MNN.Input = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Input}
 */
MNN.Input.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Input=} obj
 * @returns {MNN.Input}
 */
MNN.Input.getRootAsInput = function(bb, obj) {
  return (obj || new MNN.Input).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Input=} obj
 * @returns {MNN.Input}
 */
MNN.Input.getSizePrefixedRootAsInput = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Input).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Input.prototype.dims = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Input.prototype.dimsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Input.prototype.dimsArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {MNN.DataType}
 */
MNN.Input.prototype.dtype = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_FLOAT;
};

/**
 * @returns {MNN.MNN_DATA_FORMAT}
 */
MNN.Input.prototype.dformat = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? /** @type {MNN.MNN_DATA_FORMAT} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.MNN_DATA_FORMAT.NC4HW4;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Input.startInput = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimsOffset
 */
MNN.Input.addDims = function(builder, dimsOffset) {
  builder.addFieldOffset(0, dimsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Input.createDimsVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Input.startDimsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} dtype
 */
MNN.Input.addDtype = function(builder, dtype) {
  builder.addFieldInt32(1, dtype, MNN.DataType.DT_FLOAT);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.MNN_DATA_FORMAT} dformat
 */
MNN.Input.addDformat = function(builder, dformat) {
  builder.addFieldInt8(2, dformat, MNN.MNN_DATA_FORMAT.NC4HW4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Input.endInput = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimsOffset
 * @param {MNN.DataType} dtype
 * @param {MNN.MNN_DATA_FORMAT} dformat
 * @returns {flatbuffers.Offset}
 */
MNN.Input.createInput = function(builder, dimsOffset, dtype, dformat) {
  MNN.Input.startInput(builder);
  MNN.Input.addDims(builder, dimsOffset);
  MNN.Input.addDtype(builder, dtype);
  MNN.Input.addDformat(builder, dformat);
  return MNN.Input.endInput(builder);
}

/**
 * @constructor
 */
MNN.LSTM = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.LSTM}
 */
MNN.LSTM.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.LSTM=} obj
 * @returns {MNN.LSTM}
 */
MNN.LSTM.getRootAsLSTM = function(bb, obj) {
  return (obj || new MNN.LSTM).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.LSTM=} obj
 * @returns {MNN.LSTM}
 */
MNN.LSTM.getSizePrefixedRootAsLSTM = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.LSTM).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.LSTM.prototype.outputCount = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.LSTM.prototype.weightSize = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.LSTM.prototype.clippingThreshold = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.LSTM.prototype.weightI = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.LSTM.prototype.weightH = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.LSTM.prototype.bias = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.LSTM.prototype.weightIQ = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.LSTM.prototype.weightIA = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @returns {number}
 */
MNN.LSTM.prototype.quantScale = function() {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.LSTM.startLSTM = function(builder) {
  builder.startObject(9);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} outputCount
 */
MNN.LSTM.addOutputCount = function(builder, outputCount) {
  builder.addFieldInt32(0, outputCount, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} weightSize
 */
MNN.LSTM.addWeightSize = function(builder, weightSize) {
  builder.addFieldInt32(1, weightSize, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} clippingThreshold
 */
MNN.LSTM.addClippingThreshold = function(builder, clippingThreshold) {
  builder.addFieldFloat32(2, clippingThreshold, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} weightIOffset
 */
MNN.LSTM.addWeightI = function(builder, weightIOffset) {
  builder.addFieldOffset(3, weightIOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} weightHOffset
 */
MNN.LSTM.addWeightH = function(builder, weightHOffset) {
  builder.addFieldOffset(4, weightHOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} biasOffset
 */
MNN.LSTM.addBias = function(builder, biasOffset) {
  builder.addFieldOffset(5, biasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} weightIQOffset
 */
MNN.LSTM.addWeightIQ = function(builder, weightIQOffset) {
  builder.addFieldOffset(6, weightIQOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} weightIAOffset
 */
MNN.LSTM.addWeightIA = function(builder, weightIAOffset) {
  builder.addFieldOffset(7, weightIAOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} quantScale
 */
MNN.LSTM.addQuantScale = function(builder, quantScale) {
  builder.addFieldFloat32(8, quantScale, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.LSTM.endLSTM = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} outputCount
 * @param {number} weightSize
 * @param {number} clippingThreshold
 * @param {flatbuffers.Offset} weightIOffset
 * @param {flatbuffers.Offset} weightHOffset
 * @param {flatbuffers.Offset} biasOffset
 * @param {flatbuffers.Offset} weightIQOffset
 * @param {flatbuffers.Offset} weightIAOffset
 * @param {number} quantScale
 * @returns {flatbuffers.Offset}
 */
MNN.LSTM.createLSTM = function(builder, outputCount, weightSize, clippingThreshold, weightIOffset, weightHOffset, biasOffset, weightIQOffset, weightIAOffset, quantScale) {
  MNN.LSTM.startLSTM(builder);
  MNN.LSTM.addOutputCount(builder, outputCount);
  MNN.LSTM.addWeightSize(builder, weightSize);
  MNN.LSTM.addClippingThreshold(builder, clippingThreshold);
  MNN.LSTM.addWeightI(builder, weightIOffset);
  MNN.LSTM.addWeightH(builder, weightHOffset);
  MNN.LSTM.addBias(builder, biasOffset);
  MNN.LSTM.addWeightIQ(builder, weightIQOffset);
  MNN.LSTM.addWeightIA(builder, weightIAOffset);
  MNN.LSTM.addQuantScale(builder, quantScale);
  return MNN.LSTM.endLSTM(builder);
}

/**
 * @constructor
 */
MNN.Slice = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Slice}
 */
MNN.Slice.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Slice=} obj
 * @returns {MNN.Slice}
 */
MNN.Slice.getRootAsSlice = function(bb, obj) {
  return (obj || new MNN.Slice).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Slice=} obj
 * @returns {MNN.Slice}
 */
MNN.Slice.getSizePrefixedRootAsSlice = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Slice).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.Slice.prototype.axis = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Slice.prototype.slicePoints = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Slice.prototype.slicePointsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Slice.prototype.slicePointsArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {MNN.NetSource}
 */
MNN.Slice.prototype.sourceType = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? /** @type {MNN.NetSource} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.NetSource.CAFFE;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Slice.startSlice = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 */
MNN.Slice.addAxis = function(builder, axis) {
  builder.addFieldInt32(0, axis, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} slicePointsOffset
 */
MNN.Slice.addSlicePoints = function(builder, slicePointsOffset) {
  builder.addFieldOffset(1, slicePointsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Slice.createSlicePointsVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Slice.startSlicePointsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.NetSource} sourceType
 */
MNN.Slice.addSourceType = function(builder, sourceType) {
  builder.addFieldInt8(2, sourceType, MNN.NetSource.CAFFE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Slice.endSlice = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 * @param {flatbuffers.Offset} slicePointsOffset
 * @param {MNN.NetSource} sourceType
 * @returns {flatbuffers.Offset}
 */
MNN.Slice.createSlice = function(builder, axis, slicePointsOffset, sourceType) {
  MNN.Slice.startSlice(builder);
  MNN.Slice.addAxis(builder, axis);
  MNN.Slice.addSlicePoints(builder, slicePointsOffset);
  MNN.Slice.addSourceType(builder, sourceType);
  return MNN.Slice.endSlice(builder);
}

/**
 * @constructor
 */
MNN.BatchNorm = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.BatchNorm}
 */
MNN.BatchNorm.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.BatchNorm=} obj
 * @returns {MNN.BatchNorm}
 */
MNN.BatchNorm.getRootAsBatchNorm = function(bb, obj) {
  return (obj || new MNN.BatchNorm).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.BatchNorm=} obj
 * @returns {MNN.BatchNorm}
 */
MNN.BatchNorm.getSizePrefixedRootAsBatchNorm = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.BatchNorm).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.BatchNorm.prototype.channels = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.BatchNorm.prototype.slopeData = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.BatchNorm.prototype.slopeDataLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.BatchNorm.prototype.slopeDataArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.BatchNorm.prototype.meanData = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.BatchNorm.prototype.meanDataLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.BatchNorm.prototype.meanDataArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.BatchNorm.prototype.varData = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.BatchNorm.prototype.varDataLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.BatchNorm.prototype.varDataArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.BatchNorm.prototype.biasData = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.BatchNorm.prototype.biasDataLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.BatchNorm.prototype.biasDataArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.BatchNorm.prototype.Adata = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.BatchNorm.prototype.AdataLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.BatchNorm.prototype.AdataArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.BatchNorm.prototype.Bdata = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.BatchNorm.prototype.BdataLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.BatchNorm.prototype.BdataArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {number}
 */
MNN.BatchNorm.prototype.epsilon = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.001;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.BatchNorm.startBatchNorm = function(builder) {
  builder.startObject(8);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} channels
 */
MNN.BatchNorm.addChannels = function(builder, channels) {
  builder.addFieldInt32(0, channels, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} slopeDataOffset
 */
MNN.BatchNorm.addSlopeData = function(builder, slopeDataOffset) {
  builder.addFieldOffset(1, slopeDataOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.BatchNorm.createSlopeDataVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.BatchNorm.startSlopeDataVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} meanDataOffset
 */
MNN.BatchNorm.addMeanData = function(builder, meanDataOffset) {
  builder.addFieldOffset(2, meanDataOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.BatchNorm.createMeanDataVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.BatchNorm.startMeanDataVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} varDataOffset
 */
MNN.BatchNorm.addVarData = function(builder, varDataOffset) {
  builder.addFieldOffset(3, varDataOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.BatchNorm.createVarDataVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.BatchNorm.startVarDataVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} biasDataOffset
 */
MNN.BatchNorm.addBiasData = function(builder, biasDataOffset) {
  builder.addFieldOffset(4, biasDataOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.BatchNorm.createBiasDataVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.BatchNorm.startBiasDataVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} AdataOffset
 */
MNN.BatchNorm.addAdata = function(builder, AdataOffset) {
  builder.addFieldOffset(5, AdataOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.BatchNorm.createAdataVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.BatchNorm.startAdataVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} BdataOffset
 */
MNN.BatchNorm.addBdata = function(builder, BdataOffset) {
  builder.addFieldOffset(6, BdataOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.BatchNorm.createBdataVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.BatchNorm.startBdataVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} epsilon
 */
MNN.BatchNorm.addEpsilon = function(builder, epsilon) {
  builder.addFieldFloat32(7, epsilon, 0.001);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.BatchNorm.endBatchNorm = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} channels
 * @param {flatbuffers.Offset} slopeDataOffset
 * @param {flatbuffers.Offset} meanDataOffset
 * @param {flatbuffers.Offset} varDataOffset
 * @param {flatbuffers.Offset} biasDataOffset
 * @param {flatbuffers.Offset} AdataOffset
 * @param {flatbuffers.Offset} BdataOffset
 * @param {number} epsilon
 * @returns {flatbuffers.Offset}
 */
MNN.BatchNorm.createBatchNorm = function(builder, channels, slopeDataOffset, meanDataOffset, varDataOffset, biasDataOffset, AdataOffset, BdataOffset, epsilon) {
  MNN.BatchNorm.startBatchNorm(builder);
  MNN.BatchNorm.addChannels(builder, channels);
  MNN.BatchNorm.addSlopeData(builder, slopeDataOffset);
  MNN.BatchNorm.addMeanData(builder, meanDataOffset);
  MNN.BatchNorm.addVarData(builder, varDataOffset);
  MNN.BatchNorm.addBiasData(builder, biasDataOffset);
  MNN.BatchNorm.addAdata(builder, AdataOffset);
  MNN.BatchNorm.addBdata(builder, BdataOffset);
  MNN.BatchNorm.addEpsilon(builder, epsilon);
  return MNN.BatchNorm.endBatchNorm(builder);
}

/**
 * @constructor
 */
MNN.Scale = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Scale}
 */
MNN.Scale.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Scale=} obj
 * @returns {MNN.Scale}
 */
MNN.Scale.getRootAsScale = function(bb, obj) {
  return (obj || new MNN.Scale).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Scale=} obj
 * @returns {MNN.Scale}
 */
MNN.Scale.getSizePrefixedRootAsScale = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Scale).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.Scale.prototype.channels = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Scale.prototype.scaleData = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Scale.prototype.scaleDataLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.Scale.prototype.scaleDataArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Scale.prototype.biasData = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Scale.prototype.biasDataLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.Scale.prototype.biasDataArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Scale.startScale = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} channels
 */
MNN.Scale.addChannels = function(builder, channels) {
  builder.addFieldInt32(0, channels, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} scaleDataOffset
 */
MNN.Scale.addScaleData = function(builder, scaleDataOffset) {
  builder.addFieldOffset(1, scaleDataOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Scale.createScaleDataVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Scale.startScaleDataVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} biasDataOffset
 */
MNN.Scale.addBiasData = function(builder, biasDataOffset) {
  builder.addFieldOffset(2, biasDataOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Scale.createBiasDataVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Scale.startBiasDataVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Scale.endScale = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} channels
 * @param {flatbuffers.Offset} scaleDataOffset
 * @param {flatbuffers.Offset} biasDataOffset
 * @returns {flatbuffers.Offset}
 */
MNN.Scale.createScale = function(builder, channels, scaleDataOffset, biasDataOffset) {
  MNN.Scale.startScale(builder);
  MNN.Scale.addChannels(builder, channels);
  MNN.Scale.addScaleData(builder, scaleDataOffset);
  MNN.Scale.addBiasData(builder, biasDataOffset);
  return MNN.Scale.endScale(builder);
}

/**
 * @constructor
 */
MNN.Eltwise = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Eltwise}
 */
MNN.Eltwise.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Eltwise=} obj
 * @returns {MNN.Eltwise}
 */
MNN.Eltwise.getRootAsEltwise = function(bb, obj) {
  return (obj || new MNN.Eltwise).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Eltwise=} obj
 * @returns {MNN.Eltwise}
 */
MNN.Eltwise.getSizePrefixedRootAsEltwise = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Eltwise).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.EltwiseType}
 */
MNN.Eltwise.prototype.type = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.EltwiseType} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.EltwiseType.PROD;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Eltwise.prototype.coeff = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Eltwise.prototype.coeffLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.Eltwise.prototype.coeffArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Eltwise.startEltwise = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.EltwiseType} type
 */
MNN.Eltwise.addType = function(builder, type) {
  builder.addFieldInt8(0, type, MNN.EltwiseType.PROD);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} coeffOffset
 */
MNN.Eltwise.addCoeff = function(builder, coeffOffset) {
  builder.addFieldOffset(1, coeffOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Eltwise.createCoeffVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Eltwise.startCoeffVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Eltwise.endEltwise = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.EltwiseType} type
 * @param {flatbuffers.Offset} coeffOffset
 * @returns {flatbuffers.Offset}
 */
MNN.Eltwise.createEltwise = function(builder, type, coeffOffset) {
  MNN.Eltwise.startEltwise(builder);
  MNN.Eltwise.addType(builder, type);
  MNN.Eltwise.addCoeff(builder, coeffOffset);
  return MNN.Eltwise.endEltwise(builder);
}

/**
 * @constructor
 */
MNN.Flatten = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Flatten}
 */
MNN.Flatten.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Flatten=} obj
 * @returns {MNN.Flatten}
 */
MNN.Flatten.getRootAsFlatten = function(bb, obj) {
  return (obj || new MNN.Flatten).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Flatten=} obj
 * @returns {MNN.Flatten}
 */
MNN.Flatten.getSizePrefixedRootAsFlatten = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Flatten).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.Flatten.prototype.axis = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Flatten.prototype.endAxis = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Flatten.startFlatten = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 */
MNN.Flatten.addAxis = function(builder, axis) {
  builder.addFieldInt32(0, axis, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} endAxis
 */
MNN.Flatten.addEndAxis = function(builder, endAxis) {
  builder.addFieldInt32(1, endAxis, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Flatten.endFlatten = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 * @param {number} endAxis
 * @returns {flatbuffers.Offset}
 */
MNN.Flatten.createFlatten = function(builder, axis, endAxis) {
  MNN.Flatten.startFlatten(builder);
  MNN.Flatten.addAxis(builder, axis);
  MNN.Flatten.addEndAxis(builder, endAxis);
  return MNN.Flatten.endFlatten(builder);
}

/**
 * @constructor
 */
MNN.Permute = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Permute}
 */
MNN.Permute.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Permute=} obj
 * @returns {MNN.Permute}
 */
MNN.Permute.getRootAsPermute = function(bb, obj) {
  return (obj || new MNN.Permute).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Permute=} obj
 * @returns {MNN.Permute}
 */
MNN.Permute.getSizePrefixedRootAsPermute = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Permute).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Permute.prototype.dims = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Permute.prototype.dimsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Permute.prototype.dimsArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Permute.startPermute = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimsOffset
 */
MNN.Permute.addDims = function(builder, dimsOffset) {
  builder.addFieldOffset(0, dimsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Permute.createDimsVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Permute.startDimsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Permute.endPermute = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimsOffset
 * @returns {flatbuffers.Offset}
 */
MNN.Permute.createPermute = function(builder, dimsOffset) {
  MNN.Permute.startPermute(builder);
  MNN.Permute.addDims(builder, dimsOffset);
  return MNN.Permute.endPermute(builder);
}

/**
 * @constructor
 */
MNN.Reshape = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Reshape}
 */
MNN.Reshape.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Reshape=} obj
 * @returns {MNN.Reshape}
 */
MNN.Reshape.getRootAsReshape = function(bb, obj) {
  return (obj || new MNN.Reshape).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Reshape=} obj
 * @returns {MNN.Reshape}
 */
MNN.Reshape.getSizePrefixedRootAsReshape = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Reshape).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Reshape.prototype.dims = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Reshape.prototype.dimsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Reshape.prototype.dimsArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {MNN.MNN_DATA_FORMAT}
 */
MNN.Reshape.prototype.dimType = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.MNN_DATA_FORMAT} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.MNN_DATA_FORMAT.NCHW;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Reshape.startReshape = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimsOffset
 */
MNN.Reshape.addDims = function(builder, dimsOffset) {
  builder.addFieldOffset(0, dimsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Reshape.createDimsVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Reshape.startDimsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.MNN_DATA_FORMAT} dimType
 */
MNN.Reshape.addDimType = function(builder, dimType) {
  builder.addFieldInt8(1, dimType, MNN.MNN_DATA_FORMAT.NCHW);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Reshape.endReshape = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimsOffset
 * @param {MNN.MNN_DATA_FORMAT} dimType
 * @returns {flatbuffers.Offset}
 */
MNN.Reshape.createReshape = function(builder, dimsOffset, dimType) {
  MNN.Reshape.startReshape(builder);
  MNN.Reshape.addDims(builder, dimsOffset);
  MNN.Reshape.addDimType(builder, dimType);
  return MNN.Reshape.endReshape(builder);
}

/**
 * @constructor
 */
MNN.DetectionOutput = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.DetectionOutput}
 */
MNN.DetectionOutput.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.DetectionOutput=} obj
 * @returns {MNN.DetectionOutput}
 */
MNN.DetectionOutput.getRootAsDetectionOutput = function(bb, obj) {
  return (obj || new MNN.DetectionOutput).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.DetectionOutput=} obj
 * @returns {MNN.DetectionOutput}
 */
MNN.DetectionOutput.getSizePrefixedRootAsDetectionOutput = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.DetectionOutput).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.DetectionOutput.prototype.classCount = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.DetectionOutput.prototype.nmsThresholdold = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @returns {number}
 */
MNN.DetectionOutput.prototype.nmsTopK = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.DetectionOutput.prototype.keepTopK = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.DetectionOutput.prototype.confidenceThreshold = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @returns {number}
 */
MNN.DetectionOutput.prototype.shareLocation = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.DetectionOutput.prototype.backgroundLable = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.DetectionOutput.prototype.varianceEncodedTarget = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.DetectionOutput.prototype.codeType = function() {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.DetectionOutput.prototype.objectnessScore = function() {
  var offset = this.bb.__offset(this.bb_pos, 22);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.01;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.DetectionOutput.startDetectionOutput = function(builder) {
  builder.startObject(10);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} classCount
 */
MNN.DetectionOutput.addClassCount = function(builder, classCount) {
  builder.addFieldInt32(0, classCount, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} nmsThresholdold
 */
MNN.DetectionOutput.addNmsThresholdold = function(builder, nmsThresholdold) {
  builder.addFieldFloat32(1, nmsThresholdold, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} nmsTopK
 */
MNN.DetectionOutput.addNmsTopK = function(builder, nmsTopK) {
  builder.addFieldInt32(2, nmsTopK, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} keepTopK
 */
MNN.DetectionOutput.addKeepTopK = function(builder, keepTopK) {
  builder.addFieldInt32(3, keepTopK, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} confidenceThreshold
 */
MNN.DetectionOutput.addConfidenceThreshold = function(builder, confidenceThreshold) {
  builder.addFieldFloat32(4, confidenceThreshold, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} shareLocation
 */
MNN.DetectionOutput.addShareLocation = function(builder, shareLocation) {
  builder.addFieldInt32(5, shareLocation, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} backgroundLable
 */
MNN.DetectionOutput.addBackgroundLable = function(builder, backgroundLable) {
  builder.addFieldInt32(6, backgroundLable, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} varianceEncodedTarget
 */
MNN.DetectionOutput.addVarianceEncodedTarget = function(builder, varianceEncodedTarget) {
  builder.addFieldInt32(7, varianceEncodedTarget, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} codeType
 */
MNN.DetectionOutput.addCodeType = function(builder, codeType) {
  builder.addFieldInt32(8, codeType, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} objectnessScore
 */
MNN.DetectionOutput.addObjectnessScore = function(builder, objectnessScore) {
  builder.addFieldFloat32(9, objectnessScore, 0.01);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.DetectionOutput.endDetectionOutput = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} classCount
 * @param {number} nmsThresholdold
 * @param {number} nmsTopK
 * @param {number} keepTopK
 * @param {number} confidenceThreshold
 * @param {number} shareLocation
 * @param {number} backgroundLable
 * @param {number} varianceEncodedTarget
 * @param {number} codeType
 * @param {number} objectnessScore
 * @returns {flatbuffers.Offset}
 */
MNN.DetectionOutput.createDetectionOutput = function(builder, classCount, nmsThresholdold, nmsTopK, keepTopK, confidenceThreshold, shareLocation, backgroundLable, varianceEncodedTarget, codeType, objectnessScore) {
  MNN.DetectionOutput.startDetectionOutput(builder);
  MNN.DetectionOutput.addClassCount(builder, classCount);
  MNN.DetectionOutput.addNmsThresholdold(builder, nmsThresholdold);
  MNN.DetectionOutput.addNmsTopK(builder, nmsTopK);
  MNN.DetectionOutput.addKeepTopK(builder, keepTopK);
  MNN.DetectionOutput.addConfidenceThreshold(builder, confidenceThreshold);
  MNN.DetectionOutput.addShareLocation(builder, shareLocation);
  MNN.DetectionOutput.addBackgroundLable(builder, backgroundLable);
  MNN.DetectionOutput.addVarianceEncodedTarget(builder, varianceEncodedTarget);
  MNN.DetectionOutput.addCodeType(builder, codeType);
  MNN.DetectionOutput.addObjectnessScore(builder, objectnessScore);
  return MNN.DetectionOutput.endDetectionOutput(builder);
}

/**
 * @constructor
 */
MNN.RoiPooling = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.RoiPooling}
 */
MNN.RoiPooling.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.RoiPooling=} obj
 * @returns {MNN.RoiPooling}
 */
MNN.RoiPooling.getRootAsRoiPooling = function(bb, obj) {
  return (obj || new MNN.RoiPooling).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.RoiPooling=} obj
 * @returns {MNN.RoiPooling}
 */
MNN.RoiPooling.getSizePrefixedRootAsRoiPooling = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.RoiPooling).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.RoiPooling.prototype.pooledWidth = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.RoiPooling.prototype.pooledHeight = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.RoiPooling.prototype.spatialScale = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.RoiPooling.startRoiPooling = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} pooledWidth
 */
MNN.RoiPooling.addPooledWidth = function(builder, pooledWidth) {
  builder.addFieldInt32(0, pooledWidth, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} pooledHeight
 */
MNN.RoiPooling.addPooledHeight = function(builder, pooledHeight) {
  builder.addFieldInt32(1, pooledHeight, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} spatialScale
 */
MNN.RoiPooling.addSpatialScale = function(builder, spatialScale) {
  builder.addFieldFloat32(2, spatialScale, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.RoiPooling.endRoiPooling = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} pooledWidth
 * @param {number} pooledHeight
 * @param {number} spatialScale
 * @returns {flatbuffers.Offset}
 */
MNN.RoiPooling.createRoiPooling = function(builder, pooledWidth, pooledHeight, spatialScale) {
  MNN.RoiPooling.startRoiPooling(builder);
  MNN.RoiPooling.addPooledWidth(builder, pooledWidth);
  MNN.RoiPooling.addPooledHeight(builder, pooledHeight);
  MNN.RoiPooling.addSpatialScale(builder, spatialScale);
  return MNN.RoiPooling.endRoiPooling(builder);
}

/**
 * @constructor
 */
MNN.Proposal = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Proposal}
 */
MNN.Proposal.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Proposal=} obj
 * @returns {MNN.Proposal}
 */
MNN.Proposal.getRootAsProposal = function(bb, obj) {
  return (obj || new MNN.Proposal).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Proposal=} obj
 * @returns {MNN.Proposal}
 */
MNN.Proposal.getSizePrefixedRootAsProposal = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Proposal).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.Proposal.prototype.featStride = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Proposal.prototype.baseSize = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Proposal.prototype.preNmsTopN = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Proposal.prototype.afterNmsTopN = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Proposal.prototype.nmsThreshold = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @returns {number}
 */
MNN.Proposal.prototype.minSize = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.Proposal.prototype.ratios = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.Proposal.prototype.scales = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.Proposal.prototype.anchors = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Proposal.startProposal = function(builder) {
  builder.startObject(9);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} featStride
 */
MNN.Proposal.addFeatStride = function(builder, featStride) {
  builder.addFieldInt32(0, featStride, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} baseSize
 */
MNN.Proposal.addBaseSize = function(builder, baseSize) {
  builder.addFieldInt32(1, baseSize, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} preNmsTopN
 */
MNN.Proposal.addPreNmsTopN = function(builder, preNmsTopN) {
  builder.addFieldInt32(2, preNmsTopN, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} afterNmsTopN
 */
MNN.Proposal.addAfterNmsTopN = function(builder, afterNmsTopN) {
  builder.addFieldInt32(3, afterNmsTopN, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} nmsThreshold
 */
MNN.Proposal.addNmsThreshold = function(builder, nmsThreshold) {
  builder.addFieldFloat32(4, nmsThreshold, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} minSize
 */
MNN.Proposal.addMinSize = function(builder, minSize) {
  builder.addFieldInt32(5, minSize, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} ratiosOffset
 */
MNN.Proposal.addRatios = function(builder, ratiosOffset) {
  builder.addFieldOffset(6, ratiosOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} scalesOffset
 */
MNN.Proposal.addScales = function(builder, scalesOffset) {
  builder.addFieldOffset(7, scalesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} anchorsOffset
 */
MNN.Proposal.addAnchors = function(builder, anchorsOffset) {
  builder.addFieldOffset(8, anchorsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Proposal.endProposal = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} featStride
 * @param {number} baseSize
 * @param {number} preNmsTopN
 * @param {number} afterNmsTopN
 * @param {number} nmsThreshold
 * @param {number} minSize
 * @param {flatbuffers.Offset} ratiosOffset
 * @param {flatbuffers.Offset} scalesOffset
 * @param {flatbuffers.Offset} anchorsOffset
 * @returns {flatbuffers.Offset}
 */
MNN.Proposal.createProposal = function(builder, featStride, baseSize, preNmsTopN, afterNmsTopN, nmsThreshold, minSize, ratiosOffset, scalesOffset, anchorsOffset) {
  MNN.Proposal.startProposal(builder);
  MNN.Proposal.addFeatStride(builder, featStride);
  MNN.Proposal.addBaseSize(builder, baseSize);
  MNN.Proposal.addPreNmsTopN(builder, preNmsTopN);
  MNN.Proposal.addAfterNmsTopN(builder, afterNmsTopN);
  MNN.Proposal.addNmsThreshold(builder, nmsThreshold);
  MNN.Proposal.addMinSize(builder, minSize);
  MNN.Proposal.addRatios(builder, ratiosOffset);
  MNN.Proposal.addScales(builder, scalesOffset);
  MNN.Proposal.addAnchors(builder, anchorsOffset);
  return MNN.Proposal.endProposal(builder);
}

/**
 * @constructor
 */
MNN.Interp = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Interp}
 */
MNN.Interp.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Interp=} obj
 * @returns {MNN.Interp}
 */
MNN.Interp.getRootAsInterp = function(bb, obj) {
  return (obj || new MNN.Interp).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Interp=} obj
 * @returns {MNN.Interp}
 */
MNN.Interp.getSizePrefixedRootAsInterp = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Interp).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.Interp.prototype.widthScale = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @returns {number}
 */
MNN.Interp.prototype.heightScale = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @returns {number}
 */
MNN.Interp.prototype.outputWidth = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Interp.prototype.outputHeight = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Interp.prototype.resizeType = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {boolean}
 */
MNN.Interp.prototype.alignCorners = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {boolean}
 */
MNN.Interp.prototype.halfPixelCenters = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Interp.startInterp = function(builder) {
  builder.startObject(7);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} widthScale
 */
MNN.Interp.addWidthScale = function(builder, widthScale) {
  builder.addFieldFloat32(0, widthScale, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} heightScale
 */
MNN.Interp.addHeightScale = function(builder, heightScale) {
  builder.addFieldFloat32(1, heightScale, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} outputWidth
 */
MNN.Interp.addOutputWidth = function(builder, outputWidth) {
  builder.addFieldInt32(2, outputWidth, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} outputHeight
 */
MNN.Interp.addOutputHeight = function(builder, outputHeight) {
  builder.addFieldInt32(3, outputHeight, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} resizeType
 */
MNN.Interp.addResizeType = function(builder, resizeType) {
  builder.addFieldInt32(4, resizeType, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} alignCorners
 */
MNN.Interp.addAlignCorners = function(builder, alignCorners) {
  builder.addFieldInt8(5, +alignCorners, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} halfPixelCenters
 */
MNN.Interp.addHalfPixelCenters = function(builder, halfPixelCenters) {
  builder.addFieldInt8(6, +halfPixelCenters, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Interp.endInterp = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} widthScale
 * @param {number} heightScale
 * @param {number} outputWidth
 * @param {number} outputHeight
 * @param {number} resizeType
 * @param {boolean} alignCorners
 * @param {boolean} halfPixelCenters
 * @returns {flatbuffers.Offset}
 */
MNN.Interp.createInterp = function(builder, widthScale, heightScale, outputWidth, outputHeight, resizeType, alignCorners, halfPixelCenters) {
  MNN.Interp.startInterp(builder);
  MNN.Interp.addWidthScale(builder, widthScale);
  MNN.Interp.addHeightScale(builder, heightScale);
  MNN.Interp.addOutputWidth(builder, outputWidth);
  MNN.Interp.addOutputHeight(builder, outputHeight);
  MNN.Interp.addResizeType(builder, resizeType);
  MNN.Interp.addAlignCorners(builder, alignCorners);
  MNN.Interp.addHalfPixelCenters(builder, halfPixelCenters);
  return MNN.Interp.endInterp(builder);
}

/**
 * @constructor
 */
MNN.Resize = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Resize}
 */
MNN.Resize.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Resize=} obj
 * @returns {MNN.Resize}
 */
MNN.Resize.getRootAsResize = function(bb, obj) {
  return (obj || new MNN.Resize).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Resize=} obj
 * @returns {MNN.Resize}
 */
MNN.Resize.getSizePrefixedRootAsResize = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Resize).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.Resize.prototype.xScale = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @returns {number}
 */
MNN.Resize.prototype.yScale = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Resize.startResize = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} xScale
 */
MNN.Resize.addXScale = function(builder, xScale) {
  builder.addFieldFloat32(0, xScale, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} yScale
 */
MNN.Resize.addYScale = function(builder, yScale) {
  builder.addFieldFloat32(1, yScale, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Resize.endResize = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} xScale
 * @param {number} yScale
 * @returns {flatbuffers.Offset}
 */
MNN.Resize.createResize = function(builder, xScale, yScale) {
  MNN.Resize.startResize(builder);
  MNN.Resize.addXScale(builder, xScale);
  MNN.Resize.addYScale(builder, yScale);
  return MNN.Resize.endResize(builder);
}

/**
 * @constructor
 */
MNN.PriorBox = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.PriorBox}
 */
MNN.PriorBox.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.PriorBox=} obj
 * @returns {MNN.PriorBox}
 */
MNN.PriorBox.getRootAsPriorBox = function(bb, obj) {
  return (obj || new MNN.PriorBox).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.PriorBox=} obj
 * @returns {MNN.PriorBox}
 */
MNN.PriorBox.getSizePrefixedRootAsPriorBox = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.PriorBox).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.PriorBox.prototype.minSizes = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.PriorBox.prototype.minSizesLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.PriorBox.prototype.minSizesArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.PriorBox.prototype.maxSizes = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.PriorBox.prototype.maxSizesLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.PriorBox.prototype.maxSizesArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.PriorBox.prototype.aspectRatios = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.PriorBox.prototype.aspectRatiosLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.PriorBox.prototype.aspectRatiosArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.PriorBox.prototype.variances = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.PriorBox.prototype.variancesLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.PriorBox.prototype.variancesArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {boolean}
 */
MNN.PriorBox.prototype.flip = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {boolean}
 */
MNN.PriorBox.prototype.clip = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {number}
 */
MNN.PriorBox.prototype.imageWidth = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.PriorBox.prototype.imageHeight = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.PriorBox.prototype.stepWidth = function() {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.PriorBox.prototype.stepHeight = function() {
  var offset = this.bb.__offset(this.bb_pos, 22);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.PriorBox.prototype.offset = function() {
  var offset = this.bb.__offset(this.bb_pos, 24);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.PriorBox.startPriorBox = function(builder) {
  builder.startObject(11);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} minSizesOffset
 */
MNN.PriorBox.addMinSizes = function(builder, minSizesOffset) {
  builder.addFieldOffset(0, minSizesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.PriorBox.createMinSizesVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.PriorBox.startMinSizesVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} maxSizesOffset
 */
MNN.PriorBox.addMaxSizes = function(builder, maxSizesOffset) {
  builder.addFieldOffset(1, maxSizesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.PriorBox.createMaxSizesVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.PriorBox.startMaxSizesVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} aspectRatiosOffset
 */
MNN.PriorBox.addAspectRatios = function(builder, aspectRatiosOffset) {
  builder.addFieldOffset(2, aspectRatiosOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.PriorBox.createAspectRatiosVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.PriorBox.startAspectRatiosVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} variancesOffset
 */
MNN.PriorBox.addVariances = function(builder, variancesOffset) {
  builder.addFieldOffset(3, variancesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.PriorBox.createVariancesVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.PriorBox.startVariancesVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} flip
 */
MNN.PriorBox.addFlip = function(builder, flip) {
  builder.addFieldInt8(4, +flip, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} clip
 */
MNN.PriorBox.addClip = function(builder, clip) {
  builder.addFieldInt8(5, +clip, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} imageWidth
 */
MNN.PriorBox.addImageWidth = function(builder, imageWidth) {
  builder.addFieldInt32(6, imageWidth, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} imageHeight
 */
MNN.PriorBox.addImageHeight = function(builder, imageHeight) {
  builder.addFieldInt32(7, imageHeight, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} stepWidth
 */
MNN.PriorBox.addStepWidth = function(builder, stepWidth) {
  builder.addFieldInt32(8, stepWidth, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} stepHeight
 */
MNN.PriorBox.addStepHeight = function(builder, stepHeight) {
  builder.addFieldInt32(9, stepHeight, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} offset
 */
MNN.PriorBox.addOffset = function(builder, offset) {
  builder.addFieldFloat32(10, offset, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.PriorBox.endPriorBox = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} minSizesOffset
 * @param {flatbuffers.Offset} maxSizesOffset
 * @param {flatbuffers.Offset} aspectRatiosOffset
 * @param {flatbuffers.Offset} variancesOffset
 * @param {boolean} flip
 * @param {boolean} clip
 * @param {number} imageWidth
 * @param {number} imageHeight
 * @param {number} stepWidth
 * @param {number} stepHeight
 * @param {number} offset
 * @returns {flatbuffers.Offset}
 */
MNN.PriorBox.createPriorBox = function(builder, minSizesOffset, maxSizesOffset, aspectRatiosOffset, variancesOffset, flip, clip, imageWidth, imageHeight, stepWidth, stepHeight, offset) {
  MNN.PriorBox.startPriorBox(builder);
  MNN.PriorBox.addMinSizes(builder, minSizesOffset);
  MNN.PriorBox.addMaxSizes(builder, maxSizesOffset);
  MNN.PriorBox.addAspectRatios(builder, aspectRatiosOffset);
  MNN.PriorBox.addVariances(builder, variancesOffset);
  MNN.PriorBox.addFlip(builder, flip);
  MNN.PriorBox.addClip(builder, clip);
  MNN.PriorBox.addImageWidth(builder, imageWidth);
  MNN.PriorBox.addImageHeight(builder, imageHeight);
  MNN.PriorBox.addStepWidth(builder, stepWidth);
  MNN.PriorBox.addStepHeight(builder, stepHeight);
  MNN.PriorBox.addOffset(builder, offset);
  return MNN.PriorBox.endPriorBox(builder);
}

/**
 * @constructor
 */
MNN.Normalize = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Normalize}
 */
MNN.Normalize.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Normalize=} obj
 * @returns {MNN.Normalize}
 */
MNN.Normalize.getRootAsNormalize = function(bb, obj) {
  return (obj || new MNN.Normalize).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Normalize=} obj
 * @returns {MNN.Normalize}
 */
MNN.Normalize.getSizePrefixedRootAsNormalize = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Normalize).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.Normalize.prototype.acrossSpatial = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Normalize.prototype.channelShared = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Normalize.prototype.eps = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Normalize.prototype.scale = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Normalize.prototype.scaleLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.Normalize.prototype.scaleArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Normalize.startNormalize = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} acrossSpatial
 */
MNN.Normalize.addAcrossSpatial = function(builder, acrossSpatial) {
  builder.addFieldInt32(0, acrossSpatial, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} channelShared
 */
MNN.Normalize.addChannelShared = function(builder, channelShared) {
  builder.addFieldInt32(1, channelShared, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} eps
 */
MNN.Normalize.addEps = function(builder, eps) {
  builder.addFieldFloat32(2, eps, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} scaleOffset
 */
MNN.Normalize.addScale = function(builder, scaleOffset) {
  builder.addFieldOffset(3, scaleOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Normalize.createScaleVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Normalize.startScaleVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Normalize.endNormalize = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} acrossSpatial
 * @param {number} channelShared
 * @param {number} eps
 * @param {flatbuffers.Offset} scaleOffset
 * @returns {flatbuffers.Offset}
 */
MNN.Normalize.createNormalize = function(builder, acrossSpatial, channelShared, eps, scaleOffset) {
  MNN.Normalize.startNormalize(builder);
  MNN.Normalize.addAcrossSpatial(builder, acrossSpatial);
  MNN.Normalize.addChannelShared(builder, channelShared);
  MNN.Normalize.addEps(builder, eps);
  MNN.Normalize.addScale(builder, scaleOffset);
  return MNN.Normalize.endNormalize(builder);
}

/**
 * @constructor
 */
MNN.EltwiseInt8 = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.EltwiseInt8}
 */
MNN.EltwiseInt8.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.EltwiseInt8=} obj
 * @returns {MNN.EltwiseInt8}
 */
MNN.EltwiseInt8.getRootAsEltwiseInt8 = function(bb, obj) {
  return (obj || new MNN.EltwiseInt8).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.EltwiseInt8=} obj
 * @returns {MNN.EltwiseInt8}
 */
MNN.EltwiseInt8.getSizePrefixedRootAsEltwiseInt8 = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.EltwiseInt8).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.EltwiseType}
 */
MNN.EltwiseInt8.prototype.type = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.EltwiseType} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.EltwiseType.PROD;
};

/**
 * @param {MNN.QuantizedFloatParam=} obj
 * @returns {MNN.QuantizedFloatParam|null}
 */
MNN.EltwiseInt8.prototype.inputQuan0 = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new MNN.QuantizedFloatParam).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.QuantizedFloatParam=} obj
 * @returns {MNN.QuantizedFloatParam|null}
 */
MNN.EltwiseInt8.prototype.inputQuan1 = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? (obj || new MNN.QuantizedFloatParam).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.QuantizedFloatParam=} obj
 * @returns {MNN.QuantizedFloatParam|null}
 */
MNN.EltwiseInt8.prototype.outputQuan = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? (obj || new MNN.QuantizedFloatParam).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.EltwiseInt8.startEltwiseInt8 = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.EltwiseType} type
 */
MNN.EltwiseInt8.addType = function(builder, type) {
  builder.addFieldInt8(0, type, MNN.EltwiseType.PROD);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputQuan0Offset
 */
MNN.EltwiseInt8.addInputQuan0 = function(builder, inputQuan0Offset) {
  builder.addFieldOffset(1, inputQuan0Offset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputQuan1Offset
 */
MNN.EltwiseInt8.addInputQuan1 = function(builder, inputQuan1Offset) {
  builder.addFieldOffset(2, inputQuan1Offset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} outputQuanOffset
 */
MNN.EltwiseInt8.addOutputQuan = function(builder, outputQuanOffset) {
  builder.addFieldOffset(3, outputQuanOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.EltwiseInt8.endEltwiseInt8 = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.EltwiseType} type
 * @param {flatbuffers.Offset} inputQuan0Offset
 * @param {flatbuffers.Offset} inputQuan1Offset
 * @param {flatbuffers.Offset} outputQuanOffset
 * @returns {flatbuffers.Offset}
 */
MNN.EltwiseInt8.createEltwiseInt8 = function(builder, type, inputQuan0Offset, inputQuan1Offset, outputQuanOffset) {
  MNN.EltwiseInt8.startEltwiseInt8(builder);
  MNN.EltwiseInt8.addType(builder, type);
  MNN.EltwiseInt8.addInputQuan0(builder, inputQuan0Offset);
  MNN.EltwiseInt8.addInputQuan1(builder, inputQuan1Offset);
  MNN.EltwiseInt8.addOutputQuan(builder, outputQuanOffset);
  return MNN.EltwiseInt8.endEltwiseInt8(builder);
}

/**
 * @constructor
 */
MNN.BinaryOp = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.BinaryOp}
 */
MNN.BinaryOp.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.BinaryOp=} obj
 * @returns {MNN.BinaryOp}
 */
MNN.BinaryOp.getRootAsBinaryOp = function(bb, obj) {
  return (obj || new MNN.BinaryOp).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.BinaryOp=} obj
 * @returns {MNN.BinaryOp}
 */
MNN.BinaryOp.getSizePrefixedRootAsBinaryOp = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.BinaryOp).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.BinaryOp.prototype.opType = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {MNN.DataType}
 */
MNN.BinaryOp.prototype.T = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_FLOAT;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.BinaryOp.startBinaryOp = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} opType
 */
MNN.BinaryOp.addOpType = function(builder, opType) {
  builder.addFieldInt32(0, opType, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} T
 */
MNN.BinaryOp.addT = function(builder, T) {
  builder.addFieldInt32(1, T, MNN.DataType.DT_FLOAT);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.BinaryOp.endBinaryOp = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} opType
 * @param {MNN.DataType} T
 * @returns {flatbuffers.Offset}
 */
MNN.BinaryOp.createBinaryOp = function(builder, opType, T) {
  MNN.BinaryOp.startBinaryOp(builder);
  MNN.BinaryOp.addOpType(builder, opType);
  MNN.BinaryOp.addT(builder, T);
  return MNN.BinaryOp.endBinaryOp(builder);
}

/**
 * @constructor
 */
MNN.PackParam = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.PackParam}
 */
MNN.PackParam.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.PackParam=} obj
 * @returns {MNN.PackParam}
 */
MNN.PackParam.getRootAsPackParam = function(bb, obj) {
  return (obj || new MNN.PackParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.PackParam=} obj
 * @returns {MNN.PackParam}
 */
MNN.PackParam.getSizePrefixedRootAsPackParam = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.PackParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.PackParam.prototype.dataType = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @returns {number}
 */
MNN.PackParam.prototype.axis = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.PackParam.startPackParam = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} dataType
 */
MNN.PackParam.addDataType = function(builder, dataType) {
  builder.addFieldInt32(0, dataType, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 */
MNN.PackParam.addAxis = function(builder, axis) {
  builder.addFieldInt32(1, axis, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.PackParam.endPackParam = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} dataType
 * @param {number} axis
 * @returns {flatbuffers.Offset}
 */
MNN.PackParam.createPackParam = function(builder, dataType, axis) {
  MNN.PackParam.startPackParam(builder);
  MNN.PackParam.addDataType(builder, dataType);
  MNN.PackParam.addAxis(builder, axis);
  return MNN.PackParam.endPackParam(builder);
}

/**
 * @constructor
 */
MNN.StridedSliceParam = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.StridedSliceParam}
 */
MNN.StridedSliceParam.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.StridedSliceParam=} obj
 * @returns {MNN.StridedSliceParam}
 */
MNN.StridedSliceParam.getRootAsStridedSliceParam = function(bb, obj) {
  return (obj || new MNN.StridedSliceParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.StridedSliceParam=} obj
 * @returns {MNN.StridedSliceParam}
 */
MNN.StridedSliceParam.getSizePrefixedRootAsStridedSliceParam = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.StridedSliceParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.StridedSliceParam.prototype.Index = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @returns {MNN.DataType}
 */
MNN.StridedSliceParam.prototype.T = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @returns {number}
 */
MNN.StridedSliceParam.prototype.beginMask = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.StridedSliceParam.prototype.endMask = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.StridedSliceParam.prototype.ellipsisMask = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.StridedSliceParam.prototype.newAxisMask = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.StridedSliceParam.prototype.shrinkAxisMask = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.StridedSliceParam.startStridedSliceParam = function(builder) {
  builder.startObject(7);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} Index
 */
MNN.StridedSliceParam.addIndex = function(builder, Index) {
  builder.addFieldInt32(0, Index, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} T
 */
MNN.StridedSliceParam.addT = function(builder, T) {
  builder.addFieldInt32(1, T, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} beginMask
 */
MNN.StridedSliceParam.addBeginMask = function(builder, beginMask) {
  builder.addFieldInt32(2, beginMask, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} endMask
 */
MNN.StridedSliceParam.addEndMask = function(builder, endMask) {
  builder.addFieldInt32(3, endMask, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} ellipsisMask
 */
MNN.StridedSliceParam.addEllipsisMask = function(builder, ellipsisMask) {
  builder.addFieldInt32(4, ellipsisMask, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} newAxisMask
 */
MNN.StridedSliceParam.addNewAxisMask = function(builder, newAxisMask) {
  builder.addFieldInt32(5, newAxisMask, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} shrinkAxisMask
 */
MNN.StridedSliceParam.addShrinkAxisMask = function(builder, shrinkAxisMask) {
  builder.addFieldInt32(6, shrinkAxisMask, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.StridedSliceParam.endStridedSliceParam = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} Index
 * @param {MNN.DataType} T
 * @param {number} beginMask
 * @param {number} endMask
 * @param {number} ellipsisMask
 * @param {number} newAxisMask
 * @param {number} shrinkAxisMask
 * @returns {flatbuffers.Offset}
 */
MNN.StridedSliceParam.createStridedSliceParam = function(builder, Index, T, beginMask, endMask, ellipsisMask, newAxisMask, shrinkAxisMask) {
  MNN.StridedSliceParam.startStridedSliceParam(builder);
  MNN.StridedSliceParam.addIndex(builder, Index);
  MNN.StridedSliceParam.addT(builder, T);
  MNN.StridedSliceParam.addBeginMask(builder, beginMask);
  MNN.StridedSliceParam.addEndMask(builder, endMask);
  MNN.StridedSliceParam.addEllipsisMask(builder, ellipsisMask);
  MNN.StridedSliceParam.addNewAxisMask(builder, newAxisMask);
  MNN.StridedSliceParam.addShrinkAxisMask(builder, shrinkAxisMask);
  return MNN.StridedSliceParam.endStridedSliceParam(builder);
}

/**
 * @constructor
 */
MNN.SqueezeParam = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.SqueezeParam}
 */
MNN.SqueezeParam.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.SqueezeParam=} obj
 * @returns {MNN.SqueezeParam}
 */
MNN.SqueezeParam.getRootAsSqueezeParam = function(bb, obj) {
  return (obj || new MNN.SqueezeParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.SqueezeParam=} obj
 * @returns {MNN.SqueezeParam}
 */
MNN.SqueezeParam.getSizePrefixedRootAsSqueezeParam = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.SqueezeParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.SqueezeParam.prototype.squeezeDims = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.SqueezeParam.prototype.squeezeDimsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.SqueezeParam.prototype.squeezeDimsArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.SqueezeParam.startSqueezeParam = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} squeezeDimsOffset
 */
MNN.SqueezeParam.addSqueezeDims = function(builder, squeezeDimsOffset) {
  builder.addFieldOffset(0, squeezeDimsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.SqueezeParam.createSqueezeDimsVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.SqueezeParam.startSqueezeDimsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.SqueezeParam.endSqueezeParam = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} squeezeDimsOffset
 * @returns {flatbuffers.Offset}
 */
MNN.SqueezeParam.createSqueezeParam = function(builder, squeezeDimsOffset) {
  MNN.SqueezeParam.startSqueezeParam(builder);
  MNN.SqueezeParam.addSqueezeDims(builder, squeezeDimsOffset);
  return MNN.SqueezeParam.endSqueezeParam(builder);
}

/**
 * @constructor
 */
MNN.CastParam = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.CastParam}
 */
MNN.CastParam.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.CastParam=} obj
 * @returns {MNN.CastParam}
 */
MNN.CastParam.getRootAsCastParam = function(bb, obj) {
  return (obj || new MNN.CastParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.CastParam=} obj
 * @returns {MNN.CastParam}
 */
MNN.CastParam.getSizePrefixedRootAsCastParam = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.CastParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.CastParam.prototype.srcT = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @returns {MNN.DataType}
 */
MNN.CastParam.prototype.dstT = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.CastParam.startCastParam = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} srcT
 */
MNN.CastParam.addSrcT = function(builder, srcT) {
  builder.addFieldInt32(0, srcT, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} dstT
 */
MNN.CastParam.addDstT = function(builder, dstT) {
  builder.addFieldInt32(1, dstT, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.CastParam.endCastParam = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} srcT
 * @param {MNN.DataType} dstT
 * @returns {flatbuffers.Offset}
 */
MNN.CastParam.createCastParam = function(builder, srcT, dstT) {
  MNN.CastParam.startCastParam(builder);
  MNN.CastParam.addSrcT(builder, srcT);
  MNN.CastParam.addDstT(builder, dstT);
  return MNN.CastParam.endCastParam(builder);
}

/**
 * @constructor
 */
MNN.ReductionParam = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.ReductionParam}
 */
MNN.ReductionParam.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.ReductionParam=} obj
 * @returns {MNN.ReductionParam}
 */
MNN.ReductionParam.getRootAsReductionParam = function(bb, obj) {
  return (obj || new MNN.ReductionParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.ReductionParam=} obj
 * @returns {MNN.ReductionParam}
 */
MNN.ReductionParam.getSizePrefixedRootAsReductionParam = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.ReductionParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.ReductionType}
 */
MNN.ReductionParam.prototype.operation = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.ReductionType} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.ReductionType.SUM;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.ReductionParam.prototype.dim = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.ReductionParam.prototype.dimLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.ReductionParam.prototype.dimArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {number}
 */
MNN.ReductionParam.prototype.coeff = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @returns {boolean}
 */
MNN.ReductionParam.prototype.keepDims = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {MNN.DataType}
 */
MNN.ReductionParam.prototype.dType = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_FLOAT;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.ReductionParam.startReductionParam = function(builder) {
  builder.startObject(5);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.ReductionType} operation
 */
MNN.ReductionParam.addOperation = function(builder, operation) {
  builder.addFieldInt8(0, operation, MNN.ReductionType.SUM);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimOffset
 */
MNN.ReductionParam.addDim = function(builder, dimOffset) {
  builder.addFieldOffset(1, dimOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.ReductionParam.createDimVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.ReductionParam.startDimVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} coeff
 */
MNN.ReductionParam.addCoeff = function(builder, coeff) {
  builder.addFieldFloat32(2, coeff, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} keepDims
 */
MNN.ReductionParam.addKeepDims = function(builder, keepDims) {
  builder.addFieldInt8(3, +keepDims, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} dType
 */
MNN.ReductionParam.addDType = function(builder, dType) {
  builder.addFieldInt32(4, dType, MNN.DataType.DT_FLOAT);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.ReductionParam.endReductionParam = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.ReductionType} operation
 * @param {flatbuffers.Offset} dimOffset
 * @param {number} coeff
 * @param {boolean} keepDims
 * @param {MNN.DataType} dType
 * @returns {flatbuffers.Offset}
 */
MNN.ReductionParam.createReductionParam = function(builder, operation, dimOffset, coeff, keepDims, dType) {
  MNN.ReductionParam.startReductionParam(builder);
  MNN.ReductionParam.addOperation(builder, operation);
  MNN.ReductionParam.addDim(builder, dimOffset);
  MNN.ReductionParam.addCoeff(builder, coeff);
  MNN.ReductionParam.addKeepDims(builder, keepDims);
  MNN.ReductionParam.addDType(builder, dType);
  return MNN.ReductionParam.endReductionParam(builder);
}

/**
 * @constructor
 */
MNN.Gather = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Gather}
 */
MNN.Gather.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Gather=} obj
 * @returns {MNN.Gather}
 */
MNN.Gather.getRootAsGather = function(bb, obj) {
  return (obj || new MNN.Gather).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Gather=} obj
 * @returns {MNN.Gather}
 */
MNN.Gather.getSizePrefixedRootAsGather = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Gather).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.Gather.prototype.Tindices = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @returns {MNN.DataType}
 */
MNN.Gather.prototype.Tparams = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @returns {boolean}
 */
MNN.Gather.prototype.validateIndices = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {number}
 */
MNN.Gather.prototype.axis = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Gather.startGather = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} Tindices
 */
MNN.Gather.addTindices = function(builder, Tindices) {
  builder.addFieldInt32(0, Tindices, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} Tparams
 */
MNN.Gather.addTparams = function(builder, Tparams) {
  builder.addFieldInt32(1, Tparams, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} validateIndices
 */
MNN.Gather.addValidateIndices = function(builder, validateIndices) {
  builder.addFieldInt8(2, +validateIndices, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 */
MNN.Gather.addAxis = function(builder, axis) {
  builder.addFieldInt32(3, axis, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Gather.endGather = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} Tindices
 * @param {MNN.DataType} Tparams
 * @param {boolean} validateIndices
 * @param {number} axis
 * @returns {flatbuffers.Offset}
 */
MNN.Gather.createGather = function(builder, Tindices, Tparams, validateIndices, axis) {
  MNN.Gather.startGather(builder);
  MNN.Gather.addTindices(builder, Tindices);
  MNN.Gather.addTparams(builder, Tparams);
  MNN.Gather.addValidateIndices(builder, validateIndices);
  MNN.Gather.addAxis(builder, axis);
  return MNN.Gather.endGather(builder);
}

/**
 * @constructor
 */
MNN.ExpandDims = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.ExpandDims}
 */
MNN.ExpandDims.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.ExpandDims=} obj
 * @returns {MNN.ExpandDims}
 */
MNN.ExpandDims.getRootAsExpandDims = function(bb, obj) {
  return (obj || new MNN.ExpandDims).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.ExpandDims=} obj
 * @returns {MNN.ExpandDims}
 */
MNN.ExpandDims.getSizePrefixedRootAsExpandDims = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.ExpandDims).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.ExpandDims.prototype.T = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @returns {MNN.DataType}
 */
MNN.ExpandDims.prototype.Tdim = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @returns {number}
 */
MNN.ExpandDims.prototype.axis = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.ExpandDims.startExpandDims = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} T
 */
MNN.ExpandDims.addT = function(builder, T) {
  builder.addFieldInt32(0, T, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} Tdim
 */
MNN.ExpandDims.addTdim = function(builder, Tdim) {
  builder.addFieldInt32(1, Tdim, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 */
MNN.ExpandDims.addAxis = function(builder, axis) {
  builder.addFieldInt32(2, axis, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.ExpandDims.endExpandDims = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} T
 * @param {MNN.DataType} Tdim
 * @param {number} axis
 * @returns {flatbuffers.Offset}
 */
MNN.ExpandDims.createExpandDims = function(builder, T, Tdim, axis) {
  MNN.ExpandDims.startExpandDims(builder);
  MNN.ExpandDims.addT(builder, T);
  MNN.ExpandDims.addTdim(builder, Tdim);
  MNN.ExpandDims.addAxis(builder, axis);
  return MNN.ExpandDims.endExpandDims(builder);
}

/**
 * @constructor
 */
MNN.Selu = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Selu}
 */
MNN.Selu.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Selu=} obj
 * @returns {MNN.Selu}
 */
MNN.Selu.getRootAsSelu = function(bb, obj) {
  return (obj || new MNN.Selu).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Selu=} obj
 * @returns {MNN.Selu}
 */
MNN.Selu.getSizePrefixedRootAsSelu = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Selu).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.Selu.prototype.scale = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @returns {number}
 */
MNN.Selu.prototype.alpha = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Selu.startSelu = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} scale
 */
MNN.Selu.addScale = function(builder, scale) {
  builder.addFieldFloat32(0, scale, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} alpha
 */
MNN.Selu.addAlpha = function(builder, alpha) {
  builder.addFieldFloat32(1, alpha, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Selu.endSelu = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} scale
 * @param {number} alpha
 * @returns {flatbuffers.Offset}
 */
MNN.Selu.createSelu = function(builder, scale, alpha) {
  MNN.Selu.startSelu(builder);
  MNN.Selu.addScale(builder, scale);
  MNN.Selu.addAlpha(builder, alpha);
  return MNN.Selu.endSelu(builder);
}

/**
 * @constructor
 */
MNN.AsString = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.AsString}
 */
MNN.AsString.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.AsString=} obj
 * @returns {MNN.AsString}
 */
MNN.AsString.getRootAsAsString = function(bb, obj) {
  return (obj || new MNN.AsString).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.AsString=} obj
 * @returns {MNN.AsString}
 */
MNN.AsString.getSizePrefixedRootAsAsString = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.AsString).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.AsString.prototype.T = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @returns {number}
 */
MNN.AsString.prototype.precision = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {boolean}
 */
MNN.AsString.prototype.scientific = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {boolean}
 */
MNN.AsString.prototype.shortest = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {number}
 */
MNN.AsString.prototype.width = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
MNN.AsString.prototype.fillString = function(optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.AsString.startAsString = function(builder) {
  builder.startObject(6);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} T
 */
MNN.AsString.addT = function(builder, T) {
  builder.addFieldInt32(0, T, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} precision
 */
MNN.AsString.addPrecision = function(builder, precision) {
  builder.addFieldInt32(1, precision, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} scientific
 */
MNN.AsString.addScientific = function(builder, scientific) {
  builder.addFieldInt8(2, +scientific, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} shortest
 */
MNN.AsString.addShortest = function(builder, shortest) {
  builder.addFieldInt8(3, +shortest, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} width
 */
MNN.AsString.addWidth = function(builder, width) {
  builder.addFieldInt32(4, width, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} fillStringOffset
 */
MNN.AsString.addFillString = function(builder, fillStringOffset) {
  builder.addFieldOffset(5, fillStringOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.AsString.endAsString = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} T
 * @param {number} precision
 * @param {boolean} scientific
 * @param {boolean} shortest
 * @param {number} width
 * @param {flatbuffers.Offset} fillStringOffset
 * @returns {flatbuffers.Offset}
 */
MNN.AsString.createAsString = function(builder, T, precision, scientific, shortest, width, fillStringOffset) {
  MNN.AsString.startAsString(builder);
  MNN.AsString.addT(builder, T);
  MNN.AsString.addPrecision(builder, precision);
  MNN.AsString.addScientific(builder, scientific);
  MNN.AsString.addShortest(builder, shortest);
  MNN.AsString.addWidth(builder, width);
  MNN.AsString.addFillString(builder, fillStringOffset);
  return MNN.AsString.endAsString(builder);
}

/**
 * @constructor
 */
MNN.ReduceJoin = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.ReduceJoin}
 */
MNN.ReduceJoin.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.ReduceJoin=} obj
 * @returns {MNN.ReduceJoin}
 */
MNN.ReduceJoin.getRootAsReduceJoin = function(bb, obj) {
  return (obj || new MNN.ReduceJoin).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.ReduceJoin=} obj
 * @returns {MNN.ReduceJoin}
 */
MNN.ReduceJoin.getSizePrefixedRootAsReduceJoin = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.ReduceJoin).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {boolean}
 */
MNN.ReduceJoin.prototype.keepDims = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
MNN.ReduceJoin.prototype.separator = function(optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.ReduceJoin.startReduceJoin = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} keepDims
 */
MNN.ReduceJoin.addKeepDims = function(builder, keepDims) {
  builder.addFieldInt8(0, +keepDims, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} separatorOffset
 */
MNN.ReduceJoin.addSeparator = function(builder, separatorOffset) {
  builder.addFieldOffset(1, separatorOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.ReduceJoin.endReduceJoin = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} keepDims
 * @param {flatbuffers.Offset} separatorOffset
 * @returns {flatbuffers.Offset}
 */
MNN.ReduceJoin.createReduceJoin = function(builder, keepDims, separatorOffset) {
  MNN.ReduceJoin.startReduceJoin(builder);
  MNN.ReduceJoin.addKeepDims(builder, keepDims);
  MNN.ReduceJoin.addSeparator(builder, separatorOffset);
  return MNN.ReduceJoin.endReduceJoin(builder);
}

/**
 * @constructor
 */
MNN.UnaryOp = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.UnaryOp}
 */
MNN.UnaryOp.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.UnaryOp=} obj
 * @returns {MNN.UnaryOp}
 */
MNN.UnaryOp.getRootAsUnaryOp = function(bb, obj) {
  return (obj || new MNN.UnaryOp).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.UnaryOp=} obj
 * @returns {MNN.UnaryOp}
 */
MNN.UnaryOp.getSizePrefixedRootAsUnaryOp = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.UnaryOp).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.UnaryOpOperation}
 */
MNN.UnaryOp.prototype.opType = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.UnaryOpOperation} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.UnaryOpOperation.ABS;
};

/**
 * @returns {MNN.DataType}
 */
MNN.UnaryOp.prototype.T = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.UnaryOp.startUnaryOp = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.UnaryOpOperation} opType
 */
MNN.UnaryOp.addOpType = function(builder, opType) {
  builder.addFieldInt32(0, opType, MNN.UnaryOpOperation.ABS);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} T
 */
MNN.UnaryOp.addT = function(builder, T) {
  builder.addFieldInt32(1, T, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.UnaryOp.endUnaryOp = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.UnaryOpOperation} opType
 * @param {MNN.DataType} T
 * @returns {flatbuffers.Offset}
 */
MNN.UnaryOp.createUnaryOp = function(builder, opType, T) {
  MNN.UnaryOp.startUnaryOp(builder);
  MNN.UnaryOp.addOpType(builder, opType);
  MNN.UnaryOp.addT(builder, T);
  return MNN.UnaryOp.endUnaryOp(builder);
}

/**
 * @constructor
 */
MNN.TopKV2 = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.TopKV2}
 */
MNN.TopKV2.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.TopKV2=} obj
 * @returns {MNN.TopKV2}
 */
MNN.TopKV2.getRootAsTopKV2 = function(bb, obj) {
  return (obj || new MNN.TopKV2).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.TopKV2=} obj
 * @returns {MNN.TopKV2}
 */
MNN.TopKV2.getSizePrefixedRootAsTopKV2 = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.TopKV2).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.TopKV2.prototype.T = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_FLOAT;
};

/**
 * @returns {boolean}
 */
MNN.TopKV2.prototype.sorted = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.TopKV2.startTopKV2 = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} T
 */
MNN.TopKV2.addT = function(builder, T) {
  builder.addFieldInt32(0, T, MNN.DataType.DT_FLOAT);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} sorted
 */
MNN.TopKV2.addSorted = function(builder, sorted) {
  builder.addFieldInt8(1, +sorted, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.TopKV2.endTopKV2 = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} T
 * @param {boolean} sorted
 * @returns {flatbuffers.Offset}
 */
MNN.TopKV2.createTopKV2 = function(builder, T, sorted) {
  MNN.TopKV2.startTopKV2(builder);
  MNN.TopKV2.addT(builder, T);
  MNN.TopKV2.addSorted(builder, sorted);
  return MNN.TopKV2.endTopKV2(builder);
}

/**
 * @constructor
 */
MNN.CropAndResize = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.CropAndResize}
 */
MNN.CropAndResize.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.CropAndResize=} obj
 * @returns {MNN.CropAndResize}
 */
MNN.CropAndResize.getRootAsCropAndResize = function(bb, obj) {
  return (obj || new MNN.CropAndResize).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.CropAndResize=} obj
 * @returns {MNN.CropAndResize}
 */
MNN.CropAndResize.getSizePrefixedRootAsCropAndResize = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.CropAndResize).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.CropAndResize.prototype.extrapolationValue = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @returns {MNN.CropAndResizeMethod}
 */
MNN.CropAndResize.prototype.method = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.CropAndResizeMethod} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.CropAndResizeMethod.BILINEAR;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.CropAndResize.startCropAndResize = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} extrapolationValue
 */
MNN.CropAndResize.addExtrapolationValue = function(builder, extrapolationValue) {
  builder.addFieldFloat32(0, extrapolationValue, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.CropAndResizeMethod} method
 */
MNN.CropAndResize.addMethod = function(builder, method) {
  builder.addFieldInt8(1, method, MNN.CropAndResizeMethod.BILINEAR);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.CropAndResize.endCropAndResize = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} extrapolationValue
 * @param {MNN.CropAndResizeMethod} method
 * @returns {flatbuffers.Offset}
 */
MNN.CropAndResize.createCropAndResize = function(builder, extrapolationValue, method) {
  MNN.CropAndResize.startCropAndResize(builder);
  MNN.CropAndResize.addExtrapolationValue(builder, extrapolationValue);
  MNN.CropAndResize.addMethod(builder, method);
  return MNN.CropAndResize.endCropAndResize(builder);
}

/**
 * @constructor
 */
MNN.Fill = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Fill}
 */
MNN.Fill.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Fill=} obj
 * @returns {MNN.Fill}
 */
MNN.Fill.getRootAsFill = function(bb, obj) {
  return (obj || new MNN.Fill).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Fill=} obj
 * @returns {MNN.Fill}
 */
MNN.Fill.getSizePrefixedRootAsFill = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Fill).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Fill.startFill = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Fill.endFill = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Fill.createFill = function(builder) {
  MNN.Fill.startFill(builder);
  return MNN.Fill.endFill(builder);
}

/**
 * @constructor
 */
MNN.GatherV2 = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.GatherV2}
 */
MNN.GatherV2.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.GatherV2=} obj
 * @returns {MNN.GatherV2}
 */
MNN.GatherV2.getRootAsGatherV2 = function(bb, obj) {
  return (obj || new MNN.GatherV2).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.GatherV2=} obj
 * @returns {MNN.GatherV2}
 */
MNN.GatherV2.getSizePrefixedRootAsGatherV2 = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.GatherV2).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.GatherV2.prototype.Taxis = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @returns {MNN.DataType}
 */
MNN.GatherV2.prototype.Tindices = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @returns {MNN.DataType}
 */
MNN.GatherV2.prototype.Tparams = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.GatherV2.startGatherV2 = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} Taxis
 */
MNN.GatherV2.addTaxis = function(builder, Taxis) {
  builder.addFieldInt32(0, Taxis, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} Tindices
 */
MNN.GatherV2.addTindices = function(builder, Tindices) {
  builder.addFieldInt32(1, Tindices, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} Tparams
 */
MNN.GatherV2.addTparams = function(builder, Tparams) {
  builder.addFieldInt32(2, Tparams, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.GatherV2.endGatherV2 = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} Taxis
 * @param {MNN.DataType} Tindices
 * @param {MNN.DataType} Tparams
 * @returns {flatbuffers.Offset}
 */
MNN.GatherV2.createGatherV2 = function(builder, Taxis, Tindices, Tparams) {
  MNN.GatherV2.startGatherV2(builder);
  MNN.GatherV2.addTaxis(builder, Taxis);
  MNN.GatherV2.addTindices(builder, Tindices);
  MNN.GatherV2.addTparams(builder, Tparams);
  return MNN.GatherV2.endGatherV2(builder);
}

/**
 * @constructor
 */
MNN.NonMaxSuppressionV2 = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.NonMaxSuppressionV2}
 */
MNN.NonMaxSuppressionV2.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.NonMaxSuppressionV2=} obj
 * @returns {MNN.NonMaxSuppressionV2}
 */
MNN.NonMaxSuppressionV2.getRootAsNonMaxSuppressionV2 = function(bb, obj) {
  return (obj || new MNN.NonMaxSuppressionV2).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.NonMaxSuppressionV2=} obj
 * @returns {MNN.NonMaxSuppressionV2}
 */
MNN.NonMaxSuppressionV2.getSizePrefixedRootAsNonMaxSuppressionV2 = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.NonMaxSuppressionV2).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.NonMaxSuppressionV2.startNonMaxSuppressionV2 = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.NonMaxSuppressionV2.endNonMaxSuppressionV2 = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.NonMaxSuppressionV2.createNonMaxSuppressionV2 = function(builder) {
  MNN.NonMaxSuppressionV2.startNonMaxSuppressionV2(builder);
  return MNN.NonMaxSuppressionV2.endNonMaxSuppressionV2(builder);
}

/**
 * @constructor
 */
MNN.Range = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Range}
 */
MNN.Range.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Range=} obj
 * @returns {MNN.Range}
 */
MNN.Range.getRootAsRange = function(bb, obj) {
  return (obj || new MNN.Range).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Range=} obj
 * @returns {MNN.Range}
 */
MNN.Range.getSizePrefixedRootAsRange = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Range).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.Range.prototype.Tidx = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Range.startRange = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} Tidx
 */
MNN.Range.addTidx = function(builder, Tidx) {
  builder.addFieldInt32(0, Tidx, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Range.endRange = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} Tidx
 * @returns {flatbuffers.Offset}
 */
MNN.Range.createRange = function(builder, Tidx) {
  MNN.Range.startRange(builder);
  MNN.Range.addTidx(builder, Tidx);
  return MNN.Range.endRange(builder);
}

/**
 * @constructor
 */
MNN.Rank = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Rank}
 */
MNN.Rank.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Rank=} obj
 * @returns {MNN.Rank}
 */
MNN.Rank.getRootAsRank = function(bb, obj) {
  return (obj || new MNN.Rank).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Rank=} obj
 * @returns {MNN.Rank}
 */
MNN.Rank.getSizePrefixedRootAsRank = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Rank).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Rank.startRank = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Rank.endRank = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Rank.createRank = function(builder) {
  MNN.Rank.startRank(builder);
  return MNN.Rank.endRank(builder);
}

/**
 * @constructor
 */
MNN.Size = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Size}
 */
MNN.Size.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Size=} obj
 * @returns {MNN.Size}
 */
MNN.Size.getRootAsSize = function(bb, obj) {
  return (obj || new MNN.Size).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Size=} obj
 * @returns {MNN.Size}
 */
MNN.Size.getSizePrefixedRootAsSize = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Size).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.Size.prototype.outputDataType = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Size.startSize = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} outputDataType
 */
MNN.Size.addOutputDataType = function(builder, outputDataType) {
  builder.addFieldInt32(0, outputDataType, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Size.endSize = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} outputDataType
 * @returns {flatbuffers.Offset}
 */
MNN.Size.createSize = function(builder, outputDataType) {
  MNN.Size.startSize(builder);
  MNN.Size.addOutputDataType(builder, outputDataType);
  return MNN.Size.endSize(builder);
}

/**
 * @constructor
 */
MNN.Transpose = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Transpose}
 */
MNN.Transpose.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Transpose=} obj
 * @returns {MNN.Transpose}
 */
MNN.Transpose.getRootAsTranspose = function(bb, obj) {
  return (obj || new MNN.Transpose).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Transpose=} obj
 * @returns {MNN.Transpose}
 */
MNN.Transpose.getSizePrefixedRootAsTranspose = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Transpose).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.Transpose.prototype.Tperm = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Transpose.startTranspose = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} Tperm
 */
MNN.Transpose.addTperm = function(builder, Tperm) {
  builder.addFieldInt32(0, Tperm, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Transpose.endTranspose = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} Tperm
 * @returns {flatbuffers.Offset}
 */
MNN.Transpose.createTranspose = function(builder, Tperm) {
  MNN.Transpose.startTranspose(builder);
  MNN.Transpose.addTperm(builder, Tperm);
  return MNN.Transpose.endTranspose(builder);
}

/**
 * @constructor
 */
MNN.SliceTf = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.SliceTf}
 */
MNN.SliceTf.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.SliceTf=} obj
 * @returns {MNN.SliceTf}
 */
MNN.SliceTf.getRootAsSliceTf = function(bb, obj) {
  return (obj || new MNN.SliceTf).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.SliceTf=} obj
 * @returns {MNN.SliceTf}
 */
MNN.SliceTf.getSizePrefixedRootAsSliceTf = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.SliceTf).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.SliceTf.prototype.T = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.SliceTf.startSliceTf = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} T
 */
MNN.SliceTf.addT = function(builder, T) {
  builder.addFieldInt32(0, T, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.SliceTf.endSliceTf = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} T
 * @returns {flatbuffers.Offset}
 */
MNN.SliceTf.createSliceTf = function(builder, T) {
  MNN.SliceTf.startSliceTf(builder);
  MNN.SliceTf.addT(builder, T);
  return MNN.SliceTf.endSliceTf(builder);
}

/**
 * @constructor
 */
MNN.QuantizeMaxMin = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.QuantizeMaxMin}
 */
MNN.QuantizeMaxMin.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizeMaxMin=} obj
 * @returns {MNN.QuantizeMaxMin}
 */
MNN.QuantizeMaxMin.getRootAsQuantizeMaxMin = function(bb, obj) {
  return (obj || new MNN.QuantizeMaxMin).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizeMaxMin=} obj
 * @returns {MNN.QuantizeMaxMin}
 */
MNN.QuantizeMaxMin.getSizePrefixedRootAsQuantizeMaxMin = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.QuantizeMaxMin).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.QuantizeMaxMin.prototype.T = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.QuantizeMaxMin.startQuantizeMaxMin = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} T
 */
MNN.QuantizeMaxMin.addT = function(builder, T) {
  builder.addFieldInt32(0, T, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizeMaxMin.endQuantizeMaxMin = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} T
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizeMaxMin.createQuantizeMaxMin = function(builder, T) {
  MNN.QuantizeMaxMin.startQuantizeMaxMin(builder);
  MNN.QuantizeMaxMin.addT(builder, T);
  return MNN.QuantizeMaxMin.endQuantizeMaxMin(builder);
}

/**
 * @constructor
 */
MNN.Crop = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Crop}
 */
MNN.Crop.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Crop=} obj
 * @returns {MNN.Crop}
 */
MNN.Crop.getRootAsCrop = function(bb, obj) {
  return (obj || new MNN.Crop).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Crop=} obj
 * @returns {MNN.Crop}
 */
MNN.Crop.getSizePrefixedRootAsCrop = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Crop).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.Crop.prototype.axis = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 2;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Crop.prototype.offset = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Crop.prototype.offsetLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Crop.prototype.offsetArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Crop.startCrop = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 */
MNN.Crop.addAxis = function(builder, axis) {
  builder.addFieldInt32(0, axis, 2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} offsetOffset
 */
MNN.Crop.addOffset = function(builder, offsetOffset) {
  builder.addFieldOffset(1, offsetOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Crop.createOffsetVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Crop.startOffsetVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Crop.endCrop = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 * @param {flatbuffers.Offset} offsetOffset
 * @returns {flatbuffers.Offset}
 */
MNN.Crop.createCrop = function(builder, axis, offsetOffset) {
  MNN.Crop.startCrop(builder);
  MNN.Crop.addAxis(builder, axis);
  MNN.Crop.addOffset(builder, offsetOffset);
  return MNN.Crop.endCrop(builder);
}

/**
 * @constructor
 */
MNN.SpaceBatch = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.SpaceBatch}
 */
MNN.SpaceBatch.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.SpaceBatch=} obj
 * @returns {MNN.SpaceBatch}
 */
MNN.SpaceBatch.getRootAsSpaceBatch = function(bb, obj) {
  return (obj || new MNN.SpaceBatch).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.SpaceBatch=} obj
 * @returns {MNN.SpaceBatch}
 */
MNN.SpaceBatch.getSizePrefixedRootAsSpaceBatch = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.SpaceBatch).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.SpaceBatch.prototype.blockShape = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.SpaceBatch.prototype.padding = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.SpaceBatch.startSpaceBatch = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} blockShapeOffset
 */
MNN.SpaceBatch.addBlockShape = function(builder, blockShapeOffset) {
  builder.addFieldOffset(0, blockShapeOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} paddingOffset
 */
MNN.SpaceBatch.addPadding = function(builder, paddingOffset) {
  builder.addFieldOffset(1, paddingOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.SpaceBatch.endSpaceBatch = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} blockShapeOffset
 * @param {flatbuffers.Offset} paddingOffset
 * @returns {flatbuffers.Offset}
 */
MNN.SpaceBatch.createSpaceBatch = function(builder, blockShapeOffset, paddingOffset) {
  MNN.SpaceBatch.startSpaceBatch(builder);
  MNN.SpaceBatch.addBlockShape(builder, blockShapeOffset);
  MNN.SpaceBatch.addPadding(builder, paddingOffset);
  return MNN.SpaceBatch.endSpaceBatch(builder);
}

/**
 * @constructor
 */
MNN.MatMul = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.MatMul}
 */
MNN.MatMul.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.MatMul=} obj
 * @returns {MNN.MatMul}
 */
MNN.MatMul.getRootAsMatMul = function(bb, obj) {
  return (obj || new MNN.MatMul).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.MatMul=} obj
 * @returns {MNN.MatMul}
 */
MNN.MatMul.getSizePrefixedRootAsMatMul = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.MatMul).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.MatMul.prototype.T = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @returns {boolean}
 */
MNN.MatMul.prototype.transposeA = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {boolean}
 */
MNN.MatMul.prototype.transposeB = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.MatMul.prototype.weight = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.MatMul.prototype.weightLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.MatMul.prototype.weightArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.MatMul.prototype.bias = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.MatMul.prototype.biasLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.MatMul.prototype.biasArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.MatMul.startMatMul = function(builder) {
  builder.startObject(5);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} T
 */
MNN.MatMul.addT = function(builder, T) {
  builder.addFieldInt32(0, T, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} transposeA
 */
MNN.MatMul.addTransposeA = function(builder, transposeA) {
  builder.addFieldInt8(1, +transposeA, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} transposeB
 */
MNN.MatMul.addTransposeB = function(builder, transposeB) {
  builder.addFieldInt8(2, +transposeB, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} weightOffset
 */
MNN.MatMul.addWeight = function(builder, weightOffset) {
  builder.addFieldOffset(3, weightOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.MatMul.createWeightVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.MatMul.startWeightVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} biasOffset
 */
MNN.MatMul.addBias = function(builder, biasOffset) {
  builder.addFieldOffset(4, biasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.MatMul.createBiasVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.MatMul.startBiasVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.MatMul.endMatMul = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} T
 * @param {boolean} transposeA
 * @param {boolean} transposeB
 * @param {flatbuffers.Offset} weightOffset
 * @param {flatbuffers.Offset} biasOffset
 * @returns {flatbuffers.Offset}
 */
MNN.MatMul.createMatMul = function(builder, T, transposeA, transposeB, weightOffset, biasOffset) {
  MNN.MatMul.startMatMul(builder);
  MNN.MatMul.addT(builder, T);
  MNN.MatMul.addTransposeA(builder, transposeA);
  MNN.MatMul.addTransposeB(builder, transposeB);
  MNN.MatMul.addWeight(builder, weightOffset);
  MNN.MatMul.addBias(builder, biasOffset);
  return MNN.MatMul.endMatMul(builder);
}

/**
 * @constructor
 */
MNN.MomentsParam = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.MomentsParam}
 */
MNN.MomentsParam.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.MomentsParam=} obj
 * @returns {MNN.MomentsParam}
 */
MNN.MomentsParam.getRootAsMomentsParam = function(bb, obj) {
  return (obj || new MNN.MomentsParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.MomentsParam=} obj
 * @returns {MNN.MomentsParam}
 */
MNN.MomentsParam.getSizePrefixedRootAsMomentsParam = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.MomentsParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.MomentsParam.prototype.dim = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.MomentsParam.prototype.dimLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.MomentsParam.prototype.dimArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {boolean}
 */
MNN.MomentsParam.prototype.keepDims = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : true;
};

/**
 * @returns {MNN.DataType}
 */
MNN.MomentsParam.prototype.dType = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_FLOAT;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.MomentsParam.startMomentsParam = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimOffset
 */
MNN.MomentsParam.addDim = function(builder, dimOffset) {
  builder.addFieldOffset(0, dimOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.MomentsParam.createDimVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.MomentsParam.startDimVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} keepDims
 */
MNN.MomentsParam.addKeepDims = function(builder, keepDims) {
  builder.addFieldInt8(1, +keepDims, +true);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} dType
 */
MNN.MomentsParam.addDType = function(builder, dType) {
  builder.addFieldInt32(2, dType, MNN.DataType.DT_FLOAT);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.MomentsParam.endMomentsParam = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimOffset
 * @param {boolean} keepDims
 * @param {MNN.DataType} dType
 * @returns {flatbuffers.Offset}
 */
MNN.MomentsParam.createMomentsParam = function(builder, dimOffset, keepDims, dType) {
  MNN.MomentsParam.startMomentsParam(builder);
  MNN.MomentsParam.addDim(builder, dimOffset);
  MNN.MomentsParam.addKeepDims(builder, keepDims);
  MNN.MomentsParam.addDType(builder, dType);
  return MNN.MomentsParam.endMomentsParam(builder);
}

/**
 * @constructor
 */
MNN.RNNParam = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.RNNParam}
 */
MNN.RNNParam.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.RNNParam=} obj
 * @returns {MNN.RNNParam}
 */
MNN.RNNParam.getRootAsRNNParam = function(bb, obj) {
  return (obj || new MNN.RNNParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.RNNParam=} obj
 * @returns {MNN.RNNParam}
 */
MNN.RNNParam.getSizePrefixedRootAsRNNParam = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.RNNParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.RNNParam.prototype.numUnits = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {boolean}
 */
MNN.RNNParam.prototype.isBidirectionalRNN = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {boolean}
 */
MNN.RNNParam.prototype.keepAllOutputs = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.RNNParam.prototype.fwGateWeight = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.RNNParam.prototype.fwGateBias = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.RNNParam.prototype.fwCandidateWeight = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.RNNParam.prototype.fwCandidateBias = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.RNNParam.prototype.bwGateWeight = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.RNNParam.prototype.bwGateBias = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.RNNParam.prototype.bwCandidateWeight = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 22);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.RNNParam.prototype.bwCandidateBias = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 24);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.RNNParam.startRNNParam = function(builder) {
  builder.startObject(11);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numUnits
 */
MNN.RNNParam.addNumUnits = function(builder, numUnits) {
  builder.addFieldInt32(0, numUnits, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} isBidirectionalRNN
 */
MNN.RNNParam.addIsBidirectionalRNN = function(builder, isBidirectionalRNN) {
  builder.addFieldInt8(1, +isBidirectionalRNN, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} keepAllOutputs
 */
MNN.RNNParam.addKeepAllOutputs = function(builder, keepAllOutputs) {
  builder.addFieldInt8(2, +keepAllOutputs, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} fwGateWeightOffset
 */
MNN.RNNParam.addFwGateWeight = function(builder, fwGateWeightOffset) {
  builder.addFieldOffset(3, fwGateWeightOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} fwGateBiasOffset
 */
MNN.RNNParam.addFwGateBias = function(builder, fwGateBiasOffset) {
  builder.addFieldOffset(4, fwGateBiasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} fwCandidateWeightOffset
 */
MNN.RNNParam.addFwCandidateWeight = function(builder, fwCandidateWeightOffset) {
  builder.addFieldOffset(5, fwCandidateWeightOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} fwCandidateBiasOffset
 */
MNN.RNNParam.addFwCandidateBias = function(builder, fwCandidateBiasOffset) {
  builder.addFieldOffset(6, fwCandidateBiasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} bwGateWeightOffset
 */
MNN.RNNParam.addBwGateWeight = function(builder, bwGateWeightOffset) {
  builder.addFieldOffset(7, bwGateWeightOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} bwGateBiasOffset
 */
MNN.RNNParam.addBwGateBias = function(builder, bwGateBiasOffset) {
  builder.addFieldOffset(8, bwGateBiasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} bwCandidateWeightOffset
 */
MNN.RNNParam.addBwCandidateWeight = function(builder, bwCandidateWeightOffset) {
  builder.addFieldOffset(9, bwCandidateWeightOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} bwCandidateBiasOffset
 */
MNN.RNNParam.addBwCandidateBias = function(builder, bwCandidateBiasOffset) {
  builder.addFieldOffset(10, bwCandidateBiasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.RNNParam.endRNNParam = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numUnits
 * @param {boolean} isBidirectionalRNN
 * @param {boolean} keepAllOutputs
 * @param {flatbuffers.Offset} fwGateWeightOffset
 * @param {flatbuffers.Offset} fwGateBiasOffset
 * @param {flatbuffers.Offset} fwCandidateWeightOffset
 * @param {flatbuffers.Offset} fwCandidateBiasOffset
 * @param {flatbuffers.Offset} bwGateWeightOffset
 * @param {flatbuffers.Offset} bwGateBiasOffset
 * @param {flatbuffers.Offset} bwCandidateWeightOffset
 * @param {flatbuffers.Offset} bwCandidateBiasOffset
 * @returns {flatbuffers.Offset}
 */
MNN.RNNParam.createRNNParam = function(builder, numUnits, isBidirectionalRNN, keepAllOutputs, fwGateWeightOffset, fwGateBiasOffset, fwCandidateWeightOffset, fwCandidateBiasOffset, bwGateWeightOffset, bwGateBiasOffset, bwCandidateWeightOffset, bwCandidateBiasOffset) {
  MNN.RNNParam.startRNNParam(builder);
  MNN.RNNParam.addNumUnits(builder, numUnits);
  MNN.RNNParam.addIsBidirectionalRNN(builder, isBidirectionalRNN);
  MNN.RNNParam.addKeepAllOutputs(builder, keepAllOutputs);
  MNN.RNNParam.addFwGateWeight(builder, fwGateWeightOffset);
  MNN.RNNParam.addFwGateBias(builder, fwGateBiasOffset);
  MNN.RNNParam.addFwCandidateWeight(builder, fwCandidateWeightOffset);
  MNN.RNNParam.addFwCandidateBias(builder, fwCandidateBiasOffset);
  MNN.RNNParam.addBwGateWeight(builder, bwGateWeightOffset);
  MNN.RNNParam.addBwGateBias(builder, bwGateBiasOffset);
  MNN.RNNParam.addBwCandidateWeight(builder, bwCandidateWeightOffset);
  MNN.RNNParam.addBwCandidateBias(builder, bwCandidateBiasOffset);
  return MNN.RNNParam.endRNNParam(builder);
}

/**
 * @constructor
 */
MNN.BatchMatMulParam = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.BatchMatMulParam}
 */
MNN.BatchMatMulParam.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.BatchMatMulParam=} obj
 * @returns {MNN.BatchMatMulParam}
 */
MNN.BatchMatMulParam.getRootAsBatchMatMulParam = function(bb, obj) {
  return (obj || new MNN.BatchMatMulParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.BatchMatMulParam=} obj
 * @returns {MNN.BatchMatMulParam}
 */
MNN.BatchMatMulParam.getSizePrefixedRootAsBatchMatMulParam = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.BatchMatMulParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {boolean}
 */
MNN.BatchMatMulParam.prototype.adjX = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {boolean}
 */
MNN.BatchMatMulParam.prototype.adjY = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.BatchMatMulParam.startBatchMatMulParam = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} adjX
 */
MNN.BatchMatMulParam.addAdjX = function(builder, adjX) {
  builder.addFieldInt8(0, +adjX, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} adjY
 */
MNN.BatchMatMulParam.addAdjY = function(builder, adjY) {
  builder.addFieldInt8(1, +adjY, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.BatchMatMulParam.endBatchMatMulParam = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} adjX
 * @param {boolean} adjY
 * @returns {flatbuffers.Offset}
 */
MNN.BatchMatMulParam.createBatchMatMulParam = function(builder, adjX, adjY) {
  MNN.BatchMatMulParam.startBatchMatMulParam(builder);
  MNN.BatchMatMulParam.addAdjX(builder, adjX);
  MNN.BatchMatMulParam.addAdjY(builder, adjY);
  return MNN.BatchMatMulParam.endBatchMatMulParam(builder);
}

/**
 * @constructor
 */
MNN.DepthSpaceParam = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.DepthSpaceParam}
 */
MNN.DepthSpaceParam.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.DepthSpaceParam=} obj
 * @returns {MNN.DepthSpaceParam}
 */
MNN.DepthSpaceParam.getRootAsDepthSpaceParam = function(bb, obj) {
  return (obj || new MNN.DepthSpaceParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.DepthSpaceParam=} obj
 * @returns {MNN.DepthSpaceParam}
 */
MNN.DepthSpaceParam.getSizePrefixedRootAsDepthSpaceParam = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.DepthSpaceParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.DepthSpaceParam.prototype.blockSize = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.DepthSpaceParam.startDepthSpaceParam = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} blockSize
 */
MNN.DepthSpaceParam.addBlockSize = function(builder, blockSize) {
  builder.addFieldInt32(0, blockSize, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.DepthSpaceParam.endDepthSpaceParam = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} blockSize
 * @returns {flatbuffers.Offset}
 */
MNN.DepthSpaceParam.createDepthSpaceParam = function(builder, blockSize) {
  MNN.DepthSpaceParam.startDepthSpaceParam(builder);
  MNN.DepthSpaceParam.addBlockSize(builder, blockSize);
  return MNN.DepthSpaceParam.endDepthSpaceParam(builder);
}

/**
 * @constructor
 */
MNN.ReverseSequenceParam = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.ReverseSequenceParam}
 */
MNN.ReverseSequenceParam.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.ReverseSequenceParam=} obj
 * @returns {MNN.ReverseSequenceParam}
 */
MNN.ReverseSequenceParam.getRootAsReverseSequenceParam = function(bb, obj) {
  return (obj || new MNN.ReverseSequenceParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.ReverseSequenceParam=} obj
 * @returns {MNN.ReverseSequenceParam}
 */
MNN.ReverseSequenceParam.getSizePrefixedRootAsReverseSequenceParam = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.ReverseSequenceParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.ReverseSequenceParam.prototype.batchDim = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.ReverseSequenceParam.prototype.seqDim = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.ReverseSequenceParam.startReverseSequenceParam = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} batchDim
 */
MNN.ReverseSequenceParam.addBatchDim = function(builder, batchDim) {
  builder.addFieldInt32(0, batchDim, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} seqDim
 */
MNN.ReverseSequenceParam.addSeqDim = function(builder, seqDim) {
  builder.addFieldInt32(1, seqDim, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.ReverseSequenceParam.endReverseSequenceParam = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} batchDim
 * @param {number} seqDim
 * @returns {flatbuffers.Offset}
 */
MNN.ReverseSequenceParam.createReverseSequenceParam = function(builder, batchDim, seqDim) {
  MNN.ReverseSequenceParam.startReverseSequenceParam(builder);
  MNN.ReverseSequenceParam.addBatchDim(builder, batchDim);
  MNN.ReverseSequenceParam.addSeqDim(builder, seqDim);
  return MNN.ReverseSequenceParam.endReverseSequenceParam(builder);
}

/**
 * @constructor
 */
MNN.DetectionPostProcessParam = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.DetectionPostProcessParam}
 */
MNN.DetectionPostProcessParam.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.DetectionPostProcessParam=} obj
 * @returns {MNN.DetectionPostProcessParam}
 */
MNN.DetectionPostProcessParam.getRootAsDetectionPostProcessParam = function(bb, obj) {
  return (obj || new MNN.DetectionPostProcessParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.DetectionPostProcessParam=} obj
 * @returns {MNN.DetectionPostProcessParam}
 */
MNN.DetectionPostProcessParam.getSizePrefixedRootAsDetectionPostProcessParam = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.DetectionPostProcessParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.DetectionPostProcessParam.prototype.maxDetections = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.DetectionPostProcessParam.prototype.maxClassesPerDetection = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.DetectionPostProcessParam.prototype.detectionsPerClass = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.DetectionPostProcessParam.prototype.nmsScoreThreshold = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @returns {number}
 */
MNN.DetectionPostProcessParam.prototype.iouThreshold = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @returns {number}
 */
MNN.DetectionPostProcessParam.prototype.numClasses = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {boolean}
 */
MNN.DetectionPostProcessParam.prototype.useRegularNMS = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.DetectionPostProcessParam.prototype.centerSizeEncoding = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.DetectionPostProcessParam.prototype.centerSizeEncodingLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.DetectionPostProcessParam.prototype.centerSizeEncodingArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.DetectionPostProcessParam.startDetectionPostProcessParam = function(builder) {
  builder.startObject(8);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} maxDetections
 */
MNN.DetectionPostProcessParam.addMaxDetections = function(builder, maxDetections) {
  builder.addFieldInt32(0, maxDetections, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} maxClassesPerDetection
 */
MNN.DetectionPostProcessParam.addMaxClassesPerDetection = function(builder, maxClassesPerDetection) {
  builder.addFieldInt32(1, maxClassesPerDetection, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} detectionsPerClass
 */
MNN.DetectionPostProcessParam.addDetectionsPerClass = function(builder, detectionsPerClass) {
  builder.addFieldInt32(2, detectionsPerClass, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} nmsScoreThreshold
 */
MNN.DetectionPostProcessParam.addNmsScoreThreshold = function(builder, nmsScoreThreshold) {
  builder.addFieldFloat32(3, nmsScoreThreshold, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} iouThreshold
 */
MNN.DetectionPostProcessParam.addIouThreshold = function(builder, iouThreshold) {
  builder.addFieldFloat32(4, iouThreshold, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numClasses
 */
MNN.DetectionPostProcessParam.addNumClasses = function(builder, numClasses) {
  builder.addFieldInt32(5, numClasses, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} useRegularNMS
 */
MNN.DetectionPostProcessParam.addUseRegularNMS = function(builder, useRegularNMS) {
  builder.addFieldInt8(6, +useRegularNMS, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} centerSizeEncodingOffset
 */
MNN.DetectionPostProcessParam.addCenterSizeEncoding = function(builder, centerSizeEncodingOffset) {
  builder.addFieldOffset(7, centerSizeEncodingOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.DetectionPostProcessParam.createCenterSizeEncodingVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.DetectionPostProcessParam.startCenterSizeEncodingVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.DetectionPostProcessParam.endDetectionPostProcessParam = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} maxDetections
 * @param {number} maxClassesPerDetection
 * @param {number} detectionsPerClass
 * @param {number} nmsScoreThreshold
 * @param {number} iouThreshold
 * @param {number} numClasses
 * @param {boolean} useRegularNMS
 * @param {flatbuffers.Offset} centerSizeEncodingOffset
 * @returns {flatbuffers.Offset}
 */
MNN.DetectionPostProcessParam.createDetectionPostProcessParam = function(builder, maxDetections, maxClassesPerDetection, detectionsPerClass, nmsScoreThreshold, iouThreshold, numClasses, useRegularNMS, centerSizeEncodingOffset) {
  MNN.DetectionPostProcessParam.startDetectionPostProcessParam(builder);
  MNN.DetectionPostProcessParam.addMaxDetections(builder, maxDetections);
  MNN.DetectionPostProcessParam.addMaxClassesPerDetection(builder, maxClassesPerDetection);
  MNN.DetectionPostProcessParam.addDetectionsPerClass(builder, detectionsPerClass);
  MNN.DetectionPostProcessParam.addNmsScoreThreshold(builder, nmsScoreThreshold);
  MNN.DetectionPostProcessParam.addIouThreshold(builder, iouThreshold);
  MNN.DetectionPostProcessParam.addNumClasses(builder, numClasses);
  MNN.DetectionPostProcessParam.addUseRegularNMS(builder, useRegularNMS);
  MNN.DetectionPostProcessParam.addCenterSizeEncoding(builder, centerSizeEncodingOffset);
  return MNN.DetectionPostProcessParam.endDetectionPostProcessParam(builder);
}

/**
 * @constructor
 */
MNN.OneHotParam = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.OneHotParam}
 */
MNN.OneHotParam.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.OneHotParam=} obj
 * @returns {MNN.OneHotParam}
 */
MNN.OneHotParam.getRootAsOneHotParam = function(bb, obj) {
  return (obj || new MNN.OneHotParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.OneHotParam=} obj
 * @returns {MNN.OneHotParam}
 */
MNN.OneHotParam.getSizePrefixedRootAsOneHotParam = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.OneHotParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.OneHotParam.prototype.dType = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_FLOAT;
};

/**
 * @returns {number}
 */
MNN.OneHotParam.prototype.axis = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : -1;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.OneHotParam.startOneHotParam = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} dType
 */
MNN.OneHotParam.addDType = function(builder, dType) {
  builder.addFieldInt32(0, dType, MNN.DataType.DT_FLOAT);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 */
MNN.OneHotParam.addAxis = function(builder, axis) {
  builder.addFieldInt32(1, axis, -1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.OneHotParam.endOneHotParam = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} dType
 * @param {number} axis
 * @returns {flatbuffers.Offset}
 */
MNN.OneHotParam.createOneHotParam = function(builder, dType, axis) {
  MNN.OneHotParam.startOneHotParam(builder);
  MNN.OneHotParam.addDType(builder, dType);
  MNN.OneHotParam.addAxis(builder, axis);
  return MNN.OneHotParam.endOneHotParam(builder);
}

/**
 * @constructor
 */
MNN.PadParam = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.PadParam}
 */
MNN.PadParam.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.PadParam=} obj
 * @returns {MNN.PadParam}
 */
MNN.PadParam.getRootAsPadParam = function(bb, obj) {
  return (obj || new MNN.PadParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.PadParam=} obj
 * @returns {MNN.PadParam}
 */
MNN.PadParam.getSizePrefixedRootAsPadParam = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.PadParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.PadValueMode}
 */
MNN.PadParam.prototype.mode = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.PadValueMode} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.PadValueMode.CONSTANT;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.PadParam.startPadParam = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.PadValueMode} mode
 */
MNN.PadParam.addMode = function(builder, mode) {
  builder.addFieldInt8(0, mode, MNN.PadValueMode.CONSTANT);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.PadParam.endPadParam = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.PadValueMode} mode
 * @returns {flatbuffers.Offset}
 */
MNN.PadParam.createPadParam = function(builder, mode) {
  MNN.PadParam.startPadParam(builder);
  MNN.PadParam.addMode(builder, mode);
  return MNN.PadParam.endPadParam(builder);
}

/**
 * @constructor
 */
MNN.QuantizedParam = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.QuantizedParam}
 */
MNN.QuantizedParam.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedParam=} obj
 * @returns {MNN.QuantizedParam}
 */
MNN.QuantizedParam.getRootAsQuantizedParam = function(bb, obj) {
  return (obj || new MNN.QuantizedParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedParam=} obj
 * @returns {MNN.QuantizedParam}
 */
MNN.QuantizedParam.getSizePrefixedRootAsQuantizedParam = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.QuantizedParam).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.QuantizedParam.prototype.zeroPoint = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedParam.prototype.scale = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.QuantizedParam.startQuantizedParam = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} zeroPoint
 */
MNN.QuantizedParam.addZeroPoint = function(builder, zeroPoint) {
  builder.addFieldInt32(0, zeroPoint, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} scale
 */
MNN.QuantizedParam.addScale = function(builder, scale) {
  builder.addFieldFloat32(1, scale, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedParam.endQuantizedParam = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} zeroPoint
 * @param {number} scale
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedParam.createQuantizedParam = function(builder, zeroPoint, scale) {
  MNN.QuantizedParam.startQuantizedParam(builder);
  MNN.QuantizedParam.addZeroPoint(builder, zeroPoint);
  MNN.QuantizedParam.addScale(builder, scale);
  return MNN.QuantizedParam.endQuantizedParam(builder);
}

/**
 * @constructor
 */
MNN.QuantizedAdd = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.QuantizedAdd}
 */
MNN.QuantizedAdd.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedAdd=} obj
 * @returns {MNN.QuantizedAdd}
 */
MNN.QuantizedAdd.getRootAsQuantizedAdd = function(bb, obj) {
  return (obj || new MNN.QuantizedAdd).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedAdd=} obj
 * @returns {MNN.QuantizedAdd}
 */
MNN.QuantizedAdd.getSizePrefixedRootAsQuantizedAdd = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.QuantizedAdd).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.FusedActivation}
 */
MNN.QuantizedAdd.prototype.activationType = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.FusedActivation} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.FusedActivation.kTfLiteActNone;
};

/**
 * @param {MNN.QuantizedParam=} obj
 * @returns {MNN.QuantizedParam|null}
 */
MNN.QuantizedAdd.prototype.input1QuantizedParam = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new MNN.QuantizedParam).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.QuantizedParam=} obj
 * @returns {MNN.QuantizedParam|null}
 */
MNN.QuantizedAdd.prototype.input2QuantizedParam = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? (obj || new MNN.QuantizedParam).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.QuantizedParam=} obj
 * @returns {MNN.QuantizedParam|null}
 */
MNN.QuantizedAdd.prototype.outputQuantizedParam = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? (obj || new MNN.QuantizedParam).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.QuantizedAdd.startQuantizedAdd = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.FusedActivation} activationType
 */
MNN.QuantizedAdd.addActivationType = function(builder, activationType) {
  builder.addFieldInt8(0, activationType, MNN.FusedActivation.kTfLiteActNone);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} input1QuantizedParamOffset
 */
MNN.QuantizedAdd.addInput1QuantizedParam = function(builder, input1QuantizedParamOffset) {
  builder.addFieldOffset(1, input1QuantizedParamOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} input2QuantizedParamOffset
 */
MNN.QuantizedAdd.addInput2QuantizedParam = function(builder, input2QuantizedParamOffset) {
  builder.addFieldOffset(2, input2QuantizedParamOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} outputQuantizedParamOffset
 */
MNN.QuantizedAdd.addOutputQuantizedParam = function(builder, outputQuantizedParamOffset) {
  builder.addFieldOffset(3, outputQuantizedParamOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedAdd.endQuantizedAdd = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.FusedActivation} activationType
 * @param {flatbuffers.Offset} input1QuantizedParamOffset
 * @param {flatbuffers.Offset} input2QuantizedParamOffset
 * @param {flatbuffers.Offset} outputQuantizedParamOffset
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedAdd.createQuantizedAdd = function(builder, activationType, input1QuantizedParamOffset, input2QuantizedParamOffset, outputQuantizedParamOffset) {
  MNN.QuantizedAdd.startQuantizedAdd(builder);
  MNN.QuantizedAdd.addActivationType(builder, activationType);
  MNN.QuantizedAdd.addInput1QuantizedParam(builder, input1QuantizedParamOffset);
  MNN.QuantizedAdd.addInput2QuantizedParam(builder, input2QuantizedParamOffset);
  MNN.QuantizedAdd.addOutputQuantizedParam(builder, outputQuantizedParamOffset);
  return MNN.QuantizedAdd.endQuantizedAdd(builder);
}

/**
 * @constructor
 */
MNN.Dequantize = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Dequantize}
 */
MNN.Dequantize.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Dequantize=} obj
 * @returns {MNN.Dequantize}
 */
MNN.Dequantize.getRootAsDequantize = function(bb, obj) {
  return (obj || new MNN.Dequantize).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Dequantize=} obj
 * @returns {MNN.Dequantize}
 */
MNN.Dequantize.getSizePrefixedRootAsDequantize = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Dequantize).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {MNN.QuantizedParam=} obj
 * @returns {MNN.QuantizedParam|null}
 */
MNN.Dequantize.prototype.inputQuantizedParam = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? (obj || new MNN.QuantizedParam).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @returns {MNN.QuantizeMode}
 */
MNN.Dequantize.prototype.mode = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.QuantizeMode} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.QuantizeMode.MIN_COMBINED;
};

/**
 * @returns {MNN.ModeFormat}
 */
MNN.Dequantize.prototype.modelFormat = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? /** @type {MNN.ModeFormat} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.ModeFormat.TENSORFLOW;
};

/**
 * @returns {MNN.DataType}
 */
MNN.Dequantize.prototype.type = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Dequantize.startDequantize = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputQuantizedParamOffset
 */
MNN.Dequantize.addInputQuantizedParam = function(builder, inputQuantizedParamOffset) {
  builder.addFieldOffset(0, inputQuantizedParamOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.QuantizeMode} mode
 */
MNN.Dequantize.addMode = function(builder, mode) {
  builder.addFieldInt8(1, mode, MNN.QuantizeMode.MIN_COMBINED);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.ModeFormat} modelFormat
 */
MNN.Dequantize.addModelFormat = function(builder, modelFormat) {
  builder.addFieldInt8(2, modelFormat, MNN.ModeFormat.TENSORFLOW);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} type
 */
MNN.Dequantize.addType = function(builder, type) {
  builder.addFieldInt32(3, type, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Dequantize.endDequantize = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputQuantizedParamOffset
 * @param {MNN.QuantizeMode} mode
 * @param {MNN.ModeFormat} modelFormat
 * @param {MNN.DataType} type
 * @returns {flatbuffers.Offset}
 */
MNN.Dequantize.createDequantize = function(builder, inputQuantizedParamOffset, mode, modelFormat, type) {
  MNN.Dequantize.startDequantize(builder);
  MNN.Dequantize.addInputQuantizedParam(builder, inputQuantizedParamOffset);
  MNN.Dequantize.addMode(builder, mode);
  MNN.Dequantize.addModelFormat(builder, modelFormat);
  MNN.Dequantize.addType(builder, type);
  return MNN.Dequantize.endDequantize(builder);
}

/**
 * @constructor
 */
MNN.QuantizedAvgPool = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.QuantizedAvgPool}
 */
MNN.QuantizedAvgPool.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedAvgPool=} obj
 * @returns {MNN.QuantizedAvgPool}
 */
MNN.QuantizedAvgPool.getRootAsQuantizedAvgPool = function(bb, obj) {
  return (obj || new MNN.QuantizedAvgPool).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedAvgPool=} obj
 * @returns {MNN.QuantizedAvgPool}
 */
MNN.QuantizedAvgPool.getSizePrefixedRootAsQuantizedAvgPool = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.QuantizedAvgPool).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.QuantizedAvgPool.prototype.kernelX = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedAvgPool.prototype.kernelY = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {MNN.ModeFormat}
 */
MNN.QuantizedAvgPool.prototype.modelFormat = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? /** @type {MNN.ModeFormat} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.ModeFormat.TENSORFLOW;
};

/**
 * @returns {number}
 */
MNN.QuantizedAvgPool.prototype.outputActivationMax = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedAvgPool.prototype.outputActivationMin = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {MNN.PoolPadType}
 */
MNN.QuantizedAvgPool.prototype.padType = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? /** @type {MNN.PoolPadType} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.PoolPadType.CAFFE;
};

/**
 * @returns {number}
 */
MNN.QuantizedAvgPool.prototype.padX = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedAvgPool.prototype.padY = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedAvgPool.prototype.strideX = function() {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedAvgPool.prototype.strideY = function() {
  var offset = this.bb.__offset(this.bb_pos, 22);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {MNN.DataType}
 */
MNN.QuantizedAvgPool.prototype.type = function() {
  var offset = this.bb.__offset(this.bb_pos, 24);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.QuantizedAvgPool.startQuantizedAvgPool = function(builder) {
  builder.startObject(11);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} kernelX
 */
MNN.QuantizedAvgPool.addKernelX = function(builder, kernelX) {
  builder.addFieldInt32(0, kernelX, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} kernelY
 */
MNN.QuantizedAvgPool.addKernelY = function(builder, kernelY) {
  builder.addFieldInt32(1, kernelY, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.ModeFormat} modelFormat
 */
MNN.QuantizedAvgPool.addModelFormat = function(builder, modelFormat) {
  builder.addFieldInt8(2, modelFormat, MNN.ModeFormat.TENSORFLOW);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} outputActivationMax
 */
MNN.QuantizedAvgPool.addOutputActivationMax = function(builder, outputActivationMax) {
  builder.addFieldInt32(3, outputActivationMax, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} outputActivationMin
 */
MNN.QuantizedAvgPool.addOutputActivationMin = function(builder, outputActivationMin) {
  builder.addFieldInt32(4, outputActivationMin, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.PoolPadType} padType
 */
MNN.QuantizedAvgPool.addPadType = function(builder, padType) {
  builder.addFieldInt8(5, padType, MNN.PoolPadType.CAFFE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padX
 */
MNN.QuantizedAvgPool.addPadX = function(builder, padX) {
  builder.addFieldInt32(6, padX, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padY
 */
MNN.QuantizedAvgPool.addPadY = function(builder, padY) {
  builder.addFieldInt32(7, padY, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideX
 */
MNN.QuantizedAvgPool.addStrideX = function(builder, strideX) {
  builder.addFieldInt32(8, strideX, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideY
 */
MNN.QuantizedAvgPool.addStrideY = function(builder, strideY) {
  builder.addFieldInt32(9, strideY, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} type
 */
MNN.QuantizedAvgPool.addType = function(builder, type) {
  builder.addFieldInt32(10, type, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedAvgPool.endQuantizedAvgPool = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} kernelX
 * @param {number} kernelY
 * @param {MNN.ModeFormat} modelFormat
 * @param {number} outputActivationMax
 * @param {number} outputActivationMin
 * @param {MNN.PoolPadType} padType
 * @param {number} padX
 * @param {number} padY
 * @param {number} strideX
 * @param {number} strideY
 * @param {MNN.DataType} type
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedAvgPool.createQuantizedAvgPool = function(builder, kernelX, kernelY, modelFormat, outputActivationMax, outputActivationMin, padType, padX, padY, strideX, strideY, type) {
  MNN.QuantizedAvgPool.startQuantizedAvgPool(builder);
  MNN.QuantizedAvgPool.addKernelX(builder, kernelX);
  MNN.QuantizedAvgPool.addKernelY(builder, kernelY);
  MNN.QuantizedAvgPool.addModelFormat(builder, modelFormat);
  MNN.QuantizedAvgPool.addOutputActivationMax(builder, outputActivationMax);
  MNN.QuantizedAvgPool.addOutputActivationMin(builder, outputActivationMin);
  MNN.QuantizedAvgPool.addPadType(builder, padType);
  MNN.QuantizedAvgPool.addPadX(builder, padX);
  MNN.QuantizedAvgPool.addPadY(builder, padY);
  MNN.QuantizedAvgPool.addStrideX(builder, strideX);
  MNN.QuantizedAvgPool.addStrideY(builder, strideY);
  MNN.QuantizedAvgPool.addType(builder, type);
  return MNN.QuantizedAvgPool.endQuantizedAvgPool(builder);
}

/**
 * @constructor
 */
MNN.QuantizedBiasAdd = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.QuantizedBiasAdd}
 */
MNN.QuantizedBiasAdd.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedBiasAdd=} obj
 * @returns {MNN.QuantizedBiasAdd}
 */
MNN.QuantizedBiasAdd.getRootAsQuantizedBiasAdd = function(bb, obj) {
  return (obj || new MNN.QuantizedBiasAdd).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedBiasAdd=} obj
 * @returns {MNN.QuantizedBiasAdd}
 */
MNN.QuantizedBiasAdd.getSizePrefixedRootAsQuantizedBiasAdd = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.QuantizedBiasAdd).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.QuantizedBiasAdd.prototype.bias = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedBiasAdd.prototype.biasLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.QuantizedBiasAdd.prototype.biasArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {MNN.DataType}
 */
MNN.QuantizedBiasAdd.prototype.inputType = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @returns {number}
 */
MNN.QuantizedBiasAdd.prototype.max = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedBiasAdd.prototype.min = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {MNN.DataType}
 */
MNN.QuantizedBiasAdd.prototype.outputType = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.QuantizedBiasAdd.startQuantizedBiasAdd = function(builder) {
  builder.startObject(5);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} biasOffset
 */
MNN.QuantizedBiasAdd.addBias = function(builder, biasOffset) {
  builder.addFieldOffset(0, biasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedBiasAdd.createBiasVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.QuantizedBiasAdd.startBiasVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} inputType
 */
MNN.QuantizedBiasAdd.addInputType = function(builder, inputType) {
  builder.addFieldInt32(1, inputType, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} max
 */
MNN.QuantizedBiasAdd.addMax = function(builder, max) {
  builder.addFieldInt32(2, max, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} min
 */
MNN.QuantizedBiasAdd.addMin = function(builder, min) {
  builder.addFieldInt32(3, min, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} outputType
 */
MNN.QuantizedBiasAdd.addOutputType = function(builder, outputType) {
  builder.addFieldInt32(4, outputType, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedBiasAdd.endQuantizedBiasAdd = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} biasOffset
 * @param {MNN.DataType} inputType
 * @param {number} max
 * @param {number} min
 * @param {MNN.DataType} outputType
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedBiasAdd.createQuantizedBiasAdd = function(builder, biasOffset, inputType, max, min, outputType) {
  MNN.QuantizedBiasAdd.startQuantizedBiasAdd(builder);
  MNN.QuantizedBiasAdd.addBias(builder, biasOffset);
  MNN.QuantizedBiasAdd.addInputType(builder, inputType);
  MNN.QuantizedBiasAdd.addMax(builder, max);
  MNN.QuantizedBiasAdd.addMin(builder, min);
  MNN.QuantizedBiasAdd.addOutputType(builder, outputType);
  return MNN.QuantizedBiasAdd.endQuantizedBiasAdd(builder);
}

/**
 * @constructor
 */
MNN.QuantizedConcat = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.QuantizedConcat}
 */
MNN.QuantizedConcat.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedConcat=} obj
 * @returns {MNN.QuantizedConcat}
 */
MNN.QuantizedConcat.getRootAsQuantizedConcat = function(bb, obj) {
  return (obj || new MNN.QuantizedConcat).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedConcat=} obj
 * @returns {MNN.QuantizedConcat}
 */
MNN.QuantizedConcat.getSizePrefixedRootAsQuantizedConcat = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.QuantizedConcat).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.FusedActivation}
 */
MNN.QuantizedConcat.prototype.activationType = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.FusedActivation} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.FusedActivation.kTfLiteActNone;
};

/**
 * @returns {number}
 */
MNN.QuantizedConcat.prototype.axis = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.QuantizedConcat.prototype.inputScale = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readFloat32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedConcat.prototype.inputScaleLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Float32Array}
 */
MNN.QuantizedConcat.prototype.inputScaleArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? new Float32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.QuantizedConcat.prototype.inputZeroPoint = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedConcat.prototype.inputZeroPointLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.QuantizedConcat.prototype.inputZeroPointArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {MNN.QuantizedParam=} obj
 * @returns {MNN.QuantizedParam|null}
 */
MNN.QuantizedConcat.prototype.outputQuantizedParam = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? (obj || new MNN.QuantizedParam).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.QuantizedConcat.startQuantizedConcat = function(builder) {
  builder.startObject(5);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.FusedActivation} activationType
 */
MNN.QuantizedConcat.addActivationType = function(builder, activationType) {
  builder.addFieldInt8(0, activationType, MNN.FusedActivation.kTfLiteActNone);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} axis
 */
MNN.QuantizedConcat.addAxis = function(builder, axis) {
  builder.addFieldInt32(1, axis, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputScaleOffset
 */
MNN.QuantizedConcat.addInputScale = function(builder, inputScaleOffset) {
  builder.addFieldOffset(2, inputScaleOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedConcat.createInputScaleVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addFloat32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.QuantizedConcat.startInputScaleVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputZeroPointOffset
 */
MNN.QuantizedConcat.addInputZeroPoint = function(builder, inputZeroPointOffset) {
  builder.addFieldOffset(3, inputZeroPointOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedConcat.createInputZeroPointVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.QuantizedConcat.startInputZeroPointVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} outputQuantizedParamOffset
 */
MNN.QuantizedConcat.addOutputQuantizedParam = function(builder, outputQuantizedParamOffset) {
  builder.addFieldOffset(4, outputQuantizedParamOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedConcat.endQuantizedConcat = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.FusedActivation} activationType
 * @param {number} axis
 * @param {flatbuffers.Offset} inputScaleOffset
 * @param {flatbuffers.Offset} inputZeroPointOffset
 * @param {flatbuffers.Offset} outputQuantizedParamOffset
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedConcat.createQuantizedConcat = function(builder, activationType, axis, inputScaleOffset, inputZeroPointOffset, outputQuantizedParamOffset) {
  MNN.QuantizedConcat.startQuantizedConcat(builder);
  MNN.QuantizedConcat.addActivationType(builder, activationType);
  MNN.QuantizedConcat.addAxis(builder, axis);
  MNN.QuantizedConcat.addInputScale(builder, inputScaleOffset);
  MNN.QuantizedConcat.addInputZeroPoint(builder, inputZeroPointOffset);
  MNN.QuantizedConcat.addOutputQuantizedParam(builder, outputQuantizedParamOffset);
  return MNN.QuantizedConcat.endQuantizedConcat(builder);
}

/**
 * @constructor
 */
MNN.QuantizedLogistic = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.QuantizedLogistic}
 */
MNN.QuantizedLogistic.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedLogistic=} obj
 * @returns {MNN.QuantizedLogistic}
 */
MNN.QuantizedLogistic.getRootAsQuantizedLogistic = function(bb, obj) {
  return (obj || new MNN.QuantizedLogistic).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedLogistic=} obj
 * @returns {MNN.QuantizedLogistic}
 */
MNN.QuantizedLogistic.getSizePrefixedRootAsQuantizedLogistic = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.QuantizedLogistic).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {MNN.QuantizedParam=} obj
 * @returns {MNN.QuantizedParam|null}
 */
MNN.QuantizedLogistic.prototype.inputQuantizedParam = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? (obj || new MNN.QuantizedParam).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.QuantizedParam=} obj
 * @returns {MNN.QuantizedParam|null}
 */
MNN.QuantizedLogistic.prototype.outputQuantizedParam = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new MNN.QuantizedParam).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.QuantizedLogistic.startQuantizedLogistic = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputQuantizedParamOffset
 */
MNN.QuantizedLogistic.addInputQuantizedParam = function(builder, inputQuantizedParamOffset) {
  builder.addFieldOffset(0, inputQuantizedParamOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} outputQuantizedParamOffset
 */
MNN.QuantizedLogistic.addOutputQuantizedParam = function(builder, outputQuantizedParamOffset) {
  builder.addFieldOffset(1, outputQuantizedParamOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedLogistic.endQuantizedLogistic = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputQuantizedParamOffset
 * @param {flatbuffers.Offset} outputQuantizedParamOffset
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedLogistic.createQuantizedLogistic = function(builder, inputQuantizedParamOffset, outputQuantizedParamOffset) {
  MNN.QuantizedLogistic.startQuantizedLogistic(builder);
  MNN.QuantizedLogistic.addInputQuantizedParam(builder, inputQuantizedParamOffset);
  MNN.QuantizedLogistic.addOutputQuantizedParam(builder, outputQuantizedParamOffset);
  return MNN.QuantizedLogistic.endQuantizedLogistic(builder);
}

/**
 * @constructor
 */
MNN.QuantizedMatMul = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.QuantizedMatMul}
 */
MNN.QuantizedMatMul.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedMatMul=} obj
 * @returns {MNN.QuantizedMatMul}
 */
MNN.QuantizedMatMul.getRootAsQuantizedMatMul = function(bb, obj) {
  return (obj || new MNN.QuantizedMatMul).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedMatMul=} obj
 * @returns {MNN.QuantizedMatMul}
 */
MNN.QuantizedMatMul.getSizePrefixedRootAsQuantizedMatMul = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.QuantizedMatMul).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {boolean}
 */
MNN.QuantizedMatMul.prototype.transposeA = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @returns {boolean}
 */
MNN.QuantizedMatMul.prototype.transposeB = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.QuantizedMatMul.startQuantizedMatMul = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} transposeA
 */
MNN.QuantizedMatMul.addTransposeA = function(builder, transposeA) {
  builder.addFieldInt8(0, +transposeA, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} transposeB
 */
MNN.QuantizedMatMul.addTransposeB = function(builder, transposeB) {
  builder.addFieldInt8(1, +transposeB, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedMatMul.endQuantizedMatMul = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} transposeA
 * @param {boolean} transposeB
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedMatMul.createQuantizedMatMul = function(builder, transposeA, transposeB) {
  MNN.QuantizedMatMul.startQuantizedMatMul(builder);
  MNN.QuantizedMatMul.addTransposeA(builder, transposeA);
  MNN.QuantizedMatMul.addTransposeB(builder, transposeB);
  return MNN.QuantizedMatMul.endQuantizedMatMul(builder);
}

/**
 * @constructor
 */
MNN.QuantizedMaxPool = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.QuantizedMaxPool}
 */
MNN.QuantizedMaxPool.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedMaxPool=} obj
 * @returns {MNN.QuantizedMaxPool}
 */
MNN.QuantizedMaxPool.getRootAsQuantizedMaxPool = function(bb, obj) {
  return (obj || new MNN.QuantizedMaxPool).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedMaxPool=} obj
 * @returns {MNN.QuantizedMaxPool}
 */
MNN.QuantizedMaxPool.getSizePrefixedRootAsQuantizedMaxPool = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.QuantizedMaxPool).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.QuantizedMaxPool.prototype.kernelX = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedMaxPool.prototype.kernelY = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {MNN.ModeFormat}
 */
MNN.QuantizedMaxPool.prototype.modelFormat = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? /** @type {MNN.ModeFormat} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.ModeFormat.TENSORFLOW;
};

/**
 * @returns {number}
 */
MNN.QuantizedMaxPool.prototype.outputActivationMax = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedMaxPool.prototype.outputActivationMin = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {MNN.PoolPadType}
 */
MNN.QuantizedMaxPool.prototype.padType = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? /** @type {MNN.PoolPadType} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.PoolPadType.CAFFE;
};

/**
 * @returns {number}
 */
MNN.QuantizedMaxPool.prototype.padX = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedMaxPool.prototype.padY = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedMaxPool.prototype.strideX = function() {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedMaxPool.prototype.strideY = function() {
  var offset = this.bb.__offset(this.bb_pos, 22);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {MNN.DataType}
 */
MNN.QuantizedMaxPool.prototype.type = function() {
  var offset = this.bb.__offset(this.bb_pos, 24);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.QuantizedMaxPool.startQuantizedMaxPool = function(builder) {
  builder.startObject(11);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} kernelX
 */
MNN.QuantizedMaxPool.addKernelX = function(builder, kernelX) {
  builder.addFieldInt32(0, kernelX, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} kernelY
 */
MNN.QuantizedMaxPool.addKernelY = function(builder, kernelY) {
  builder.addFieldInt32(1, kernelY, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.ModeFormat} modelFormat
 */
MNN.QuantizedMaxPool.addModelFormat = function(builder, modelFormat) {
  builder.addFieldInt8(2, modelFormat, MNN.ModeFormat.TENSORFLOW);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} outputActivationMax
 */
MNN.QuantizedMaxPool.addOutputActivationMax = function(builder, outputActivationMax) {
  builder.addFieldInt32(3, outputActivationMax, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} outputActivationMin
 */
MNN.QuantizedMaxPool.addOutputActivationMin = function(builder, outputActivationMin) {
  builder.addFieldInt32(4, outputActivationMin, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.PoolPadType} padType
 */
MNN.QuantizedMaxPool.addPadType = function(builder, padType) {
  builder.addFieldInt8(5, padType, MNN.PoolPadType.CAFFE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padX
 */
MNN.QuantizedMaxPool.addPadX = function(builder, padX) {
  builder.addFieldInt32(6, padX, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} padY
 */
MNN.QuantizedMaxPool.addPadY = function(builder, padY) {
  builder.addFieldInt32(7, padY, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideX
 */
MNN.QuantizedMaxPool.addStrideX = function(builder, strideX) {
  builder.addFieldInt32(8, strideX, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} strideY
 */
MNN.QuantizedMaxPool.addStrideY = function(builder, strideY) {
  builder.addFieldInt32(9, strideY, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} type
 */
MNN.QuantizedMaxPool.addType = function(builder, type) {
  builder.addFieldInt32(10, type, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedMaxPool.endQuantizedMaxPool = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} kernelX
 * @param {number} kernelY
 * @param {MNN.ModeFormat} modelFormat
 * @param {number} outputActivationMax
 * @param {number} outputActivationMin
 * @param {MNN.PoolPadType} padType
 * @param {number} padX
 * @param {number} padY
 * @param {number} strideX
 * @param {number} strideY
 * @param {MNN.DataType} type
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedMaxPool.createQuantizedMaxPool = function(builder, kernelX, kernelY, modelFormat, outputActivationMax, outputActivationMin, padType, padX, padY, strideX, strideY, type) {
  MNN.QuantizedMaxPool.startQuantizedMaxPool(builder);
  MNN.QuantizedMaxPool.addKernelX(builder, kernelX);
  MNN.QuantizedMaxPool.addKernelY(builder, kernelY);
  MNN.QuantizedMaxPool.addModelFormat(builder, modelFormat);
  MNN.QuantizedMaxPool.addOutputActivationMax(builder, outputActivationMax);
  MNN.QuantizedMaxPool.addOutputActivationMin(builder, outputActivationMin);
  MNN.QuantizedMaxPool.addPadType(builder, padType);
  MNN.QuantizedMaxPool.addPadX(builder, padX);
  MNN.QuantizedMaxPool.addPadY(builder, padY);
  MNN.QuantizedMaxPool.addStrideX(builder, strideX);
  MNN.QuantizedMaxPool.addStrideY(builder, strideY);
  MNN.QuantizedMaxPool.addType(builder, type);
  return MNN.QuantizedMaxPool.endQuantizedMaxPool(builder);
}

/**
 * @constructor
 */
MNN.QuantizedRelu = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.QuantizedRelu}
 */
MNN.QuantizedRelu.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedRelu=} obj
 * @returns {MNN.QuantizedRelu}
 */
MNN.QuantizedRelu.getRootAsQuantizedRelu = function(bb, obj) {
  return (obj || new MNN.QuantizedRelu).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedRelu=} obj
 * @returns {MNN.QuantizedRelu}
 */
MNN.QuantizedRelu.getSizePrefixedRootAsQuantizedRelu = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.QuantizedRelu).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.QuantizedRelu.prototype.type = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.QuantizedRelu.startQuantizedRelu = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} type
 */
MNN.QuantizedRelu.addType = function(builder, type) {
  builder.addFieldInt32(0, type, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedRelu.endQuantizedRelu = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} type
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedRelu.createQuantizedRelu = function(builder, type) {
  MNN.QuantizedRelu.startQuantizedRelu(builder);
  MNN.QuantizedRelu.addType(builder, type);
  return MNN.QuantizedRelu.endQuantizedRelu(builder);
}

/**
 * @constructor
 */
MNN.QuantizedRelu6 = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.QuantizedRelu6}
 */
MNN.QuantizedRelu6.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedRelu6=} obj
 * @returns {MNN.QuantizedRelu6}
 */
MNN.QuantizedRelu6.getRootAsQuantizedRelu6 = function(bb, obj) {
  return (obj || new MNN.QuantizedRelu6).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedRelu6=} obj
 * @returns {MNN.QuantizedRelu6}
 */
MNN.QuantizedRelu6.getSizePrefixedRootAsQuantizedRelu6 = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.QuantizedRelu6).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.QuantizedRelu6.prototype.type = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.QuantizedRelu6.startQuantizedRelu6 = function(builder) {
  builder.startObject(1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} type
 */
MNN.QuantizedRelu6.addType = function(builder, type) {
  builder.addFieldInt32(0, type, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedRelu6.endQuantizedRelu6 = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} type
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedRelu6.createQuantizedRelu6 = function(builder, type) {
  MNN.QuantizedRelu6.startQuantizedRelu6(builder);
  MNN.QuantizedRelu6.addType(builder, type);
  return MNN.QuantizedRelu6.endQuantizedRelu6(builder);
}

/**
 * @constructor
 */
MNN.QuantizedReshape = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.QuantizedReshape}
 */
MNN.QuantizedReshape.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedReshape=} obj
 * @returns {MNN.QuantizedReshape}
 */
MNN.QuantizedReshape.getRootAsQuantizedReshape = function(bb, obj) {
  return (obj || new MNN.QuantizedReshape).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedReshape=} obj
 * @returns {MNN.QuantizedReshape}
 */
MNN.QuantizedReshape.getSizePrefixedRootAsQuantizedReshape = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.QuantizedReshape).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.QuantizedReshape.prototype.dims = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.QuantizedReshape.prototype.dimsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.QuantizedReshape.prototype.dimsArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {MNN.ModeFormat}
 */
MNN.QuantizedReshape.prototype.modelFormat = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.ModeFormat} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.ModeFormat.TENSORFLOW;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.QuantizedReshape.startQuantizedReshape = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimsOffset
 */
MNN.QuantizedReshape.addDims = function(builder, dimsOffset) {
  builder.addFieldOffset(0, dimsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedReshape.createDimsVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.QuantizedReshape.startDimsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.ModeFormat} modelFormat
 */
MNN.QuantizedReshape.addModelFormat = function(builder, modelFormat) {
  builder.addFieldInt8(1, modelFormat, MNN.ModeFormat.TENSORFLOW);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedReshape.endQuantizedReshape = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} dimsOffset
 * @param {MNN.ModeFormat} modelFormat
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedReshape.createQuantizedReshape = function(builder, dimsOffset, modelFormat) {
  MNN.QuantizedReshape.startQuantizedReshape(builder);
  MNN.QuantizedReshape.addDims(builder, dimsOffset);
  MNN.QuantizedReshape.addModelFormat(builder, modelFormat);
  return MNN.QuantizedReshape.endQuantizedReshape(builder);
}

/**
 * @constructor
 */
MNN.QuantizedSoftmax = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.QuantizedSoftmax}
 */
MNN.QuantizedSoftmax.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedSoftmax=} obj
 * @returns {MNN.QuantizedSoftmax}
 */
MNN.QuantizedSoftmax.getRootAsQuantizedSoftmax = function(bb, obj) {
  return (obj || new MNN.QuantizedSoftmax).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizedSoftmax=} obj
 * @returns {MNN.QuantizedSoftmax}
 */
MNN.QuantizedSoftmax.getSizePrefixedRootAsQuantizedSoftmax = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.QuantizedSoftmax).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {number}
 */
MNN.QuantizedSoftmax.prototype.beta = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @returns {number}
 */
MNN.QuantizedSoftmax.prototype.inputScale = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.QuantizedSoftmax.startQuantizedSoftmax = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} beta
 */
MNN.QuantizedSoftmax.addBeta = function(builder, beta) {
  builder.addFieldFloat32(0, beta, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} inputScale
 */
MNN.QuantizedSoftmax.addInputScale = function(builder, inputScale) {
  builder.addFieldFloat32(1, inputScale, 0.0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedSoftmax.endQuantizedSoftmax = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} beta
 * @param {number} inputScale
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizedSoftmax.createQuantizedSoftmax = function(builder, beta, inputScale) {
  MNN.QuantizedSoftmax.startQuantizedSoftmax(builder);
  MNN.QuantizedSoftmax.addBeta(builder, beta);
  MNN.QuantizedSoftmax.addInputScale(builder, inputScale);
  return MNN.QuantizedSoftmax.endQuantizedSoftmax(builder);
}

/**
 * @constructor
 */
MNN.QuantizeV2 = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.QuantizeV2}
 */
MNN.QuantizeV2.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizeV2=} obj
 * @returns {MNN.QuantizeV2}
 */
MNN.QuantizeV2.getRootAsQuantizeV2 = function(bb, obj) {
  return (obj || new MNN.QuantizeV2).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.QuantizeV2=} obj
 * @returns {MNN.QuantizeV2}
 */
MNN.QuantizeV2.getSizePrefixedRootAsQuantizeV2 = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.QuantizeV2).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.DataType}
 */
MNN.QuantizeV2.prototype.type = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.DataType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.DataType.DT_INVALID;
};

/**
 * @returns {MNN.QuantizeMode}
 */
MNN.QuantizeV2.prototype.mode = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.QuantizeMode} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.QuantizeMode.MIN_COMBINED;
};

/**
 * @returns {MNN.QuantizeRoundMode}
 */
MNN.QuantizeV2.prototype.roundMode = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? /** @type {MNN.QuantizeRoundMode} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.QuantizeRoundMode.HALF_AWAY_FROM_ZERO;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.QuantizeV2.startQuantizeV2 = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} type
 */
MNN.QuantizeV2.addType = function(builder, type) {
  builder.addFieldInt32(0, type, MNN.DataType.DT_INVALID);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.QuantizeMode} mode
 */
MNN.QuantizeV2.addMode = function(builder, mode) {
  builder.addFieldInt8(1, mode, MNN.QuantizeMode.MIN_COMBINED);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.QuantizeRoundMode} roundMode
 */
MNN.QuantizeV2.addRoundMode = function(builder, roundMode) {
  builder.addFieldInt8(2, roundMode, MNN.QuantizeRoundMode.HALF_AWAY_FROM_ZERO);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizeV2.endQuantizeV2 = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.DataType} type
 * @param {MNN.QuantizeMode} mode
 * @param {MNN.QuantizeRoundMode} roundMode
 * @returns {flatbuffers.Offset}
 */
MNN.QuantizeV2.createQuantizeV2 = function(builder, type, mode, roundMode) {
  MNN.QuantizeV2.startQuantizeV2(builder);
  MNN.QuantizeV2.addType(builder, type);
  MNN.QuantizeV2.addMode(builder, mode);
  MNN.QuantizeV2.addRoundMode(builder, roundMode);
  return MNN.QuantizeV2.endQuantizeV2(builder);
}

/**
 * @constructor
 */
MNN.RequantizationRange = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.RequantizationRange}
 */
MNN.RequantizationRange.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.RequantizationRange=} obj
 * @returns {MNN.RequantizationRange}
 */
MNN.RequantizationRange.getRootAsRequantizationRange = function(bb, obj) {
  return (obj || new MNN.RequantizationRange).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.RequantizationRange=} obj
 * @returns {MNN.RequantizationRange}
 */
MNN.RequantizationRange.getSizePrefixedRootAsRequantizationRange = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.RequantizationRange).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.RequantizationRange.startRequantizationRange = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.RequantizationRange.endRequantizationRange = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.RequantizationRange.createRequantizationRange = function(builder) {
  MNN.RequantizationRange.startRequantizationRange(builder);
  return MNN.RequantizationRange.endRequantizationRange(builder);
}

/**
 * @constructor
 */
MNN.Requantize = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Requantize}
 */
MNN.Requantize.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Requantize=} obj
 * @returns {MNN.Requantize}
 */
MNN.Requantize.getRootAsRequantize = function(bb, obj) {
  return (obj || new MNN.Requantize).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Requantize=} obj
 * @returns {MNN.Requantize}
 */
MNN.Requantize.getSizePrefixedRootAsRequantize = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Requantize).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Requantize.startRequantize = function(builder) {
  builder.startObject(0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Requantize.endRequantize = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Requantize.createRequantize = function(builder) {
  MNN.Requantize.startRequantize(builder);
  return MNN.Requantize.endRequantize(builder);
}

/**
 * @constructor
 */
MNN.TfQuantizedConv2D = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.TfQuantizedConv2D}
 */
MNN.TfQuantizedConv2D.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.TfQuantizedConv2D=} obj
 * @returns {MNN.TfQuantizedConv2D}
 */
MNN.TfQuantizedConv2D.getRootAsTfQuantizedConv2D = function(bb, obj) {
  return (obj || new MNN.TfQuantizedConv2D).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.TfQuantizedConv2D=} obj
 * @returns {MNN.TfQuantizedConv2D}
 */
MNN.TfQuantizedConv2D.getSizePrefixedRootAsTfQuantizedConv2D = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.TfQuantizedConv2D).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.TfQuantizedConv2D.prototype.bias = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.TfQuantizedConv2D.prototype.biasLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.TfQuantizedConv2D.prototype.biasArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {boolean}
 */
MNN.TfQuantizedConv2D.prototype.biasflag = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {MNN.Convolution2DCommon=} obj
 * @returns {MNN.Convolution2DCommon|null}
 */
MNN.TfQuantizedConv2D.prototype.common = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? (obj || new MNN.Convolution2DCommon).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.TfQuantizedConv2D.prototype.weight = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
};

/**
 * @returns {number}
 */
MNN.TfQuantizedConv2D.prototype.weightLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Uint8Array}
 */
MNN.TfQuantizedConv2D.prototype.weightArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {MNN.FusedActivation}
 */
MNN.TfQuantizedConv2D.prototype.activationType = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? /** @type {MNN.FusedActivation} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.FusedActivation.kTfLiteActNone;
};

/**
 * @returns {number}
 */
MNN.TfQuantizedConv2D.prototype.multiplier = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.TfQuantizedConv2D.prototype.outMax = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.TfQuantizedConv2D.prototype.outMin = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.TfQuantizedConv2D.prototype.shift = function() {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {MNN.QuantizedParam=} obj
 * @returns {MNN.QuantizedParam|null}
 */
MNN.TfQuantizedConv2D.prototype.biasQuantizedParam = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 22);
  return offset ? (obj || new MNN.QuantizedParam).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @returns {number}
 */
MNN.TfQuantizedConv2D.prototype.depthMultiplier = function() {
  var offset = this.bb.__offset(this.bb_pos, 24);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {MNN.QuantizedParam=} obj
 * @returns {MNN.QuantizedParam|null}
 */
MNN.TfQuantizedConv2D.prototype.filterQuantizedParam = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 26);
  return offset ? (obj || new MNN.QuantizedParam).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {MNN.QuantizedParam=} obj
 * @returns {MNN.QuantizedParam|null}
 */
MNN.TfQuantizedConv2D.prototype.inputQuantizedParam = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 28);
  return offset ? (obj || new MNN.QuantizedParam).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @returns {MNN.ModeFormat}
 */
MNN.TfQuantizedConv2D.prototype.modelFormat = function() {
  var offset = this.bb.__offset(this.bb_pos, 30);
  return offset ? /** @type {MNN.ModeFormat} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.ModeFormat.TENSORFLOW;
};

/**
 * @param {MNN.QuantizedParam=} obj
 * @returns {MNN.QuantizedParam|null}
 */
MNN.TfQuantizedConv2D.prototype.outputQuantizedParam = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 32);
  return offset ? (obj || new MNN.QuantizedParam).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.TfQuantizedConv2D.startTfQuantizedConv2D = function(builder) {
  builder.startObject(15);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} biasOffset
 */
MNN.TfQuantizedConv2D.addBias = function(builder, biasOffset) {
  builder.addFieldOffset(0, biasOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.TfQuantizedConv2D.createBiasVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.TfQuantizedConv2D.startBiasVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} biasflag
 */
MNN.TfQuantizedConv2D.addBiasflag = function(builder, biasflag) {
  builder.addFieldInt8(1, +biasflag, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} commonOffset
 */
MNN.TfQuantizedConv2D.addCommon = function(builder, commonOffset) {
  builder.addFieldOffset(2, commonOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} weightOffset
 */
MNN.TfQuantizedConv2D.addWeight = function(builder, weightOffset) {
  builder.addFieldOffset(3, weightOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.TfQuantizedConv2D.createWeightVector = function(builder, data) {
  builder.startVector(1, data.length, 1);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt8(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.TfQuantizedConv2D.startWeightVector = function(builder, numElems) {
  builder.startVector(1, numElems, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.FusedActivation} activationType
 */
MNN.TfQuantizedConv2D.addActivationType = function(builder, activationType) {
  builder.addFieldInt8(4, activationType, MNN.FusedActivation.kTfLiteActNone);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} multiplier
 */
MNN.TfQuantizedConv2D.addMultiplier = function(builder, multiplier) {
  builder.addFieldInt32(5, multiplier, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} outMax
 */
MNN.TfQuantizedConv2D.addOutMax = function(builder, outMax) {
  builder.addFieldInt32(6, outMax, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} outMin
 */
MNN.TfQuantizedConv2D.addOutMin = function(builder, outMin) {
  builder.addFieldInt32(7, outMin, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} shift
 */
MNN.TfQuantizedConv2D.addShift = function(builder, shift) {
  builder.addFieldInt32(8, shift, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} biasQuantizedParamOffset
 */
MNN.TfQuantizedConv2D.addBiasQuantizedParam = function(builder, biasQuantizedParamOffset) {
  builder.addFieldOffset(9, biasQuantizedParamOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} depthMultiplier
 */
MNN.TfQuantizedConv2D.addDepthMultiplier = function(builder, depthMultiplier) {
  builder.addFieldInt32(10, depthMultiplier, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} filterQuantizedParamOffset
 */
MNN.TfQuantizedConv2D.addFilterQuantizedParam = function(builder, filterQuantizedParamOffset) {
  builder.addFieldOffset(11, filterQuantizedParamOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputQuantizedParamOffset
 */
MNN.TfQuantizedConv2D.addInputQuantizedParam = function(builder, inputQuantizedParamOffset) {
  builder.addFieldOffset(12, inputQuantizedParamOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.ModeFormat} modelFormat
 */
MNN.TfQuantizedConv2D.addModelFormat = function(builder, modelFormat) {
  builder.addFieldInt8(13, modelFormat, MNN.ModeFormat.TENSORFLOW);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} outputQuantizedParamOffset
 */
MNN.TfQuantizedConv2D.addOutputQuantizedParam = function(builder, outputQuantizedParamOffset) {
  builder.addFieldOffset(14, outputQuantizedParamOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.TfQuantizedConv2D.endTfQuantizedConv2D = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} biasOffset
 * @param {boolean} biasflag
 * @param {flatbuffers.Offset} commonOffset
 * @param {flatbuffers.Offset} weightOffset
 * @param {MNN.FusedActivation} activationType
 * @param {number} multiplier
 * @param {number} outMax
 * @param {number} outMin
 * @param {number} shift
 * @param {flatbuffers.Offset} biasQuantizedParamOffset
 * @param {number} depthMultiplier
 * @param {flatbuffers.Offset} filterQuantizedParamOffset
 * @param {flatbuffers.Offset} inputQuantizedParamOffset
 * @param {MNN.ModeFormat} modelFormat
 * @param {flatbuffers.Offset} outputQuantizedParamOffset
 * @returns {flatbuffers.Offset}
 */
MNN.TfQuantizedConv2D.createTfQuantizedConv2D = function(builder, biasOffset, biasflag, commonOffset, weightOffset, activationType, multiplier, outMax, outMin, shift, biasQuantizedParamOffset, depthMultiplier, filterQuantizedParamOffset, inputQuantizedParamOffset, modelFormat, outputQuantizedParamOffset) {
  MNN.TfQuantizedConv2D.startTfQuantizedConv2D(builder);
  MNN.TfQuantizedConv2D.addBias(builder, biasOffset);
  MNN.TfQuantizedConv2D.addBiasflag(builder, biasflag);
  MNN.TfQuantizedConv2D.addCommon(builder, commonOffset);
  MNN.TfQuantizedConv2D.addWeight(builder, weightOffset);
  MNN.TfQuantizedConv2D.addActivationType(builder, activationType);
  MNN.TfQuantizedConv2D.addMultiplier(builder, multiplier);
  MNN.TfQuantizedConv2D.addOutMax(builder, outMax);
  MNN.TfQuantizedConv2D.addOutMin(builder, outMin);
  MNN.TfQuantizedConv2D.addShift(builder, shift);
  MNN.TfQuantizedConv2D.addBiasQuantizedParam(builder, biasQuantizedParamOffset);
  MNN.TfQuantizedConv2D.addDepthMultiplier(builder, depthMultiplier);
  MNN.TfQuantizedConv2D.addFilterQuantizedParam(builder, filterQuantizedParamOffset);
  MNN.TfQuantizedConv2D.addInputQuantizedParam(builder, inputQuantizedParamOffset);
  MNN.TfQuantizedConv2D.addModelFormat(builder, modelFormat);
  MNN.TfQuantizedConv2D.addOutputQuantizedParam(builder, outputQuantizedParamOffset);
  return MNN.TfQuantizedConv2D.endTfQuantizedConv2D(builder);
}

/**
 * @constructor
 */
MNN.GpuBuffer = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.GpuBuffer}
 */
MNN.GpuBuffer.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.GpuBuffer=} obj
 * @returns {MNN.GpuBuffer}
 */
MNN.GpuBuffer.getRootAsGpuBuffer = function(bb, obj) {
  return (obj || new MNN.GpuBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.GpuBuffer=} obj
 * @returns {MNN.GpuBuffer}
 */
MNN.GpuBuffer.getSizePrefixedRootAsGpuBuffer = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.GpuBuffer).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.ACCESS_TYPE}
 */
MNN.GpuBuffer.prototype.access = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.ACCESS_TYPE} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.ACCESS_TYPE.READ_ONLY;
};

/**
 * @returns {MNN.STORAGE_TYPE}
 */
MNN.GpuBuffer.prototype.storage = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.STORAGE_TYPE} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.STORAGE_TYPE.BUFFER;
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.GpuBuffer.prototype.content = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.GpuBuffer.startGpuBuffer = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.ACCESS_TYPE} access
 */
MNN.GpuBuffer.addAccess = function(builder, access) {
  builder.addFieldInt8(0, access, MNN.ACCESS_TYPE.READ_ONLY);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.STORAGE_TYPE} storage
 */
MNN.GpuBuffer.addStorage = function(builder, storage) {
  builder.addFieldInt8(1, storage, MNN.STORAGE_TYPE.BUFFER);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} contentOffset
 */
MNN.GpuBuffer.addContent = function(builder, contentOffset) {
  builder.addFieldOffset(2, contentOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.GpuBuffer.endGpuBuffer = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.ACCESS_TYPE} access
 * @param {MNN.STORAGE_TYPE} storage
 * @param {flatbuffers.Offset} contentOffset
 * @returns {flatbuffers.Offset}
 */
MNN.GpuBuffer.createGpuBuffer = function(builder, access, storage, contentOffset) {
  MNN.GpuBuffer.startGpuBuffer(builder);
  MNN.GpuBuffer.addAccess(builder, access);
  MNN.GpuBuffer.addStorage(builder, storage);
  MNN.GpuBuffer.addContent(builder, contentOffset);
  return MNN.GpuBuffer.endGpuBuffer(builder);
}

/**
 * @constructor
 */
MNN.GpuPipeline = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.GpuPipeline}
 */
MNN.GpuPipeline.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.GpuPipeline=} obj
 * @returns {MNN.GpuPipeline}
 */
MNN.GpuPipeline.getRootAsGpuPipeline = function(bb, obj) {
  return (obj || new MNN.GpuPipeline).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.GpuPipeline=} obj
 * @returns {MNN.GpuPipeline}
 */
MNN.GpuPipeline.getSizePrefixedRootAsGpuPipeline = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.GpuPipeline).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.GpuPipeline.prototype.localSize = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.GpuPipeline.prototype.localSizeLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.GpuPipeline.prototype.localSizeArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
MNN.GpuPipeline.prototype.key = function(optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.GpuPipeline.prototype.metal = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
};

/**
 * @returns {number}
 */
MNN.GpuPipeline.prototype.metalLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int8Array}
 */
MNN.GpuPipeline.prototype.metalArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.GpuPipeline.prototype.vulkan = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
};

/**
 * @returns {number}
 */
MNN.GpuPipeline.prototype.vulkanLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int8Array}
 */
MNN.GpuPipeline.prototype.vulkanArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
MNN.GpuPipeline.prototype.openglComputeShader = function(optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
};

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
MNN.GpuPipeline.prototype.openclKernel = function(optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.GpuPipeline.startGpuPipeline = function(builder) {
  builder.startObject(6);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} localSizeOffset
 */
MNN.GpuPipeline.addLocalSize = function(builder, localSizeOffset) {
  builder.addFieldOffset(0, localSizeOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.GpuPipeline.createLocalSizeVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.GpuPipeline.startLocalSizeVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} keyOffset
 */
MNN.GpuPipeline.addKey = function(builder, keyOffset) {
  builder.addFieldOffset(1, keyOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} metalOffset
 */
MNN.GpuPipeline.addMetal = function(builder, metalOffset) {
  builder.addFieldOffset(2, metalOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.GpuPipeline.createMetalVector = function(builder, data) {
  builder.startVector(1, data.length, 1);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt8(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.GpuPipeline.startMetalVector = function(builder, numElems) {
  builder.startVector(1, numElems, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} vulkanOffset
 */
MNN.GpuPipeline.addVulkan = function(builder, vulkanOffset) {
  builder.addFieldOffset(3, vulkanOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.GpuPipeline.createVulkanVector = function(builder, data) {
  builder.startVector(1, data.length, 1);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt8(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.GpuPipeline.startVulkanVector = function(builder, numElems) {
  builder.startVector(1, numElems, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} openglComputeShaderOffset
 */
MNN.GpuPipeline.addOpenglComputeShader = function(builder, openglComputeShaderOffset) {
  builder.addFieldOffset(4, openglComputeShaderOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} openclKernelOffset
 */
MNN.GpuPipeline.addOpenclKernel = function(builder, openclKernelOffset) {
  builder.addFieldOffset(5, openclKernelOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.GpuPipeline.endGpuPipeline = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} localSizeOffset
 * @param {flatbuffers.Offset} keyOffset
 * @param {flatbuffers.Offset} metalOffset
 * @param {flatbuffers.Offset} vulkanOffset
 * @param {flatbuffers.Offset} openglComputeShaderOffset
 * @param {flatbuffers.Offset} openclKernelOffset
 * @returns {flatbuffers.Offset}
 */
MNN.GpuPipeline.createGpuPipeline = function(builder, localSizeOffset, keyOffset, metalOffset, vulkanOffset, openglComputeShaderOffset, openclKernelOffset) {
  MNN.GpuPipeline.startGpuPipeline(builder);
  MNN.GpuPipeline.addLocalSize(builder, localSizeOffset);
  MNN.GpuPipeline.addKey(builder, keyOffset);
  MNN.GpuPipeline.addMetal(builder, metalOffset);
  MNN.GpuPipeline.addVulkan(builder, vulkanOffset);
  MNN.GpuPipeline.addOpenglComputeShader(builder, openglComputeShaderOffset);
  MNN.GpuPipeline.addOpenclKernel(builder, openclKernelOffset);
  return MNN.GpuPipeline.endGpuPipeline(builder);
}

/**
 * @constructor
 */
MNN.GpuStage = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.GpuStage}
 */
MNN.GpuStage.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.GpuStage=} obj
 * @returns {MNN.GpuStage}
 */
MNN.GpuStage.getRootAsGpuStage = function(bb, obj) {
  return (obj || new MNN.GpuStage).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.GpuStage=} obj
 * @returns {MNN.GpuStage}
 */
MNN.GpuStage.getSizePrefixedRootAsGpuStage = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.GpuStage).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
MNN.GpuStage.prototype.pipeline = function(optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.GpuStage.prototype.groupSize = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.GpuStage.prototype.groupSizeLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.GpuStage.prototype.groupSizeArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.GpuStage.prototype.inputIndexes = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.GpuStage.prototype.inputIndexesLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.GpuStage.prototype.inputIndexesArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.GpuStage.prototype.outputIndexes = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.GpuStage.prototype.outputIndexesLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.GpuStage.prototype.outputIndexesArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @param {MNN.GpuBuffer=} obj
 * @returns {MNN.GpuBuffer}
 */
MNN.GpuStage.prototype.middleBuffer = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? (obj || new MNN.GpuBuffer).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

/**
 * @returns {number}
 */
MNN.GpuStage.prototype.middleBufferLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @param {number} index
 * @param {MNN.GpuBuffer=} obj
 * @returns {MNN.GpuBuffer}
 */
MNN.GpuStage.prototype.constBuffer = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? (obj || new MNN.GpuBuffer).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

/**
 * @returns {number}
 */
MNN.GpuStage.prototype.constBufferLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.GpuStage.prototype.globalSizeIndex = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.GpuStage.prototype.globalSizeDivide = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.GpuStage.prototype.globalSizeDivideLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.GpuStage.prototype.globalSizeDivideArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {boolean}
 */
MNN.GpuStage.prototype.requireSize = function() {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.GpuStage.startGpuStage = function(builder) {
  builder.startObject(9);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} pipelineOffset
 */
MNN.GpuStage.addPipeline = function(builder, pipelineOffset) {
  builder.addFieldOffset(0, pipelineOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} groupSizeOffset
 */
MNN.GpuStage.addGroupSize = function(builder, groupSizeOffset) {
  builder.addFieldOffset(1, groupSizeOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.GpuStage.createGroupSizeVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.GpuStage.startGroupSizeVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputIndexesOffset
 */
MNN.GpuStage.addInputIndexes = function(builder, inputIndexesOffset) {
  builder.addFieldOffset(2, inputIndexesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.GpuStage.createInputIndexesVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.GpuStage.startInputIndexesVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} outputIndexesOffset
 */
MNN.GpuStage.addOutputIndexes = function(builder, outputIndexesOffset) {
  builder.addFieldOffset(3, outputIndexesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.GpuStage.createOutputIndexesVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.GpuStage.startOutputIndexesVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} middleBufferOffset
 */
MNN.GpuStage.addMiddleBuffer = function(builder, middleBufferOffset) {
  builder.addFieldOffset(4, middleBufferOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
MNN.GpuStage.createMiddleBufferVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addOffset(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.GpuStage.startMiddleBufferVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} constBufferOffset
 */
MNN.GpuStage.addConstBuffer = function(builder, constBufferOffset) {
  builder.addFieldOffset(5, constBufferOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
MNN.GpuStage.createConstBufferVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addOffset(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.GpuStage.startConstBufferVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} globalSizeIndex
 */
MNN.GpuStage.addGlobalSizeIndex = function(builder, globalSizeIndex) {
  builder.addFieldInt32(6, globalSizeIndex, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} globalSizeDivideOffset
 */
MNN.GpuStage.addGlobalSizeDivide = function(builder, globalSizeDivideOffset) {
  builder.addFieldOffset(7, globalSizeDivideOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.GpuStage.createGlobalSizeDivideVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.GpuStage.startGlobalSizeDivideVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {boolean} requireSize
 */
MNN.GpuStage.addRequireSize = function(builder, requireSize) {
  builder.addFieldInt8(8, +requireSize, +false);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.GpuStage.endGpuStage = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} pipelineOffset
 * @param {flatbuffers.Offset} groupSizeOffset
 * @param {flatbuffers.Offset} inputIndexesOffset
 * @param {flatbuffers.Offset} outputIndexesOffset
 * @param {flatbuffers.Offset} middleBufferOffset
 * @param {flatbuffers.Offset} constBufferOffset
 * @param {number} globalSizeIndex
 * @param {flatbuffers.Offset} globalSizeDivideOffset
 * @param {boolean} requireSize
 * @returns {flatbuffers.Offset}
 */
MNN.GpuStage.createGpuStage = function(builder, pipelineOffset, groupSizeOffset, inputIndexesOffset, outputIndexesOffset, middleBufferOffset, constBufferOffset, globalSizeIndex, globalSizeDivideOffset, requireSize) {
  MNN.GpuStage.startGpuStage(builder);
  MNN.GpuStage.addPipeline(builder, pipelineOffset);
  MNN.GpuStage.addGroupSize(builder, groupSizeOffset);
  MNN.GpuStage.addInputIndexes(builder, inputIndexesOffset);
  MNN.GpuStage.addOutputIndexes(builder, outputIndexesOffset);
  MNN.GpuStage.addMiddleBuffer(builder, middleBufferOffset);
  MNN.GpuStage.addConstBuffer(builder, constBufferOffset);
  MNN.GpuStage.addGlobalSizeIndex(builder, globalSizeIndex);
  MNN.GpuStage.addGlobalSizeDivide(builder, globalSizeDivideOffset);
  MNN.GpuStage.addRequireSize(builder, requireSize);
  return MNN.GpuStage.endGpuStage(builder);
}

/**
 * @constructor
 */
MNN.GpuFunction = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.GpuFunction}
 */
MNN.GpuFunction.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.GpuFunction=} obj
 * @returns {MNN.GpuFunction}
 */
MNN.GpuFunction.getRootAsGpuFunction = function(bb, obj) {
  return (obj || new MNN.GpuFunction).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.GpuFunction=} obj
 * @returns {MNN.GpuFunction}
 */
MNN.GpuFunction.getSizePrefixedRootAsGpuFunction = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.GpuFunction).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @param {MNN.GpuStage=} obj
 * @returns {MNN.GpuStage}
 */
MNN.GpuFunction.prototype.stags = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? (obj || new MNN.GpuStage).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

/**
 * @returns {number}
 */
MNN.GpuFunction.prototype.stagsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
MNN.GpuFunction.prototype.name = function(optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.GpuFunction.startGpuFunction = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} stagsOffset
 */
MNN.GpuFunction.addStags = function(builder, stagsOffset) {
  builder.addFieldOffset(0, stagsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
MNN.GpuFunction.createStagsVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addOffset(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.GpuFunction.startStagsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} nameOffset
 */
MNN.GpuFunction.addName = function(builder, nameOffset) {
  builder.addFieldOffset(1, nameOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.GpuFunction.endGpuFunction = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} stagsOffset
 * @param {flatbuffers.Offset} nameOffset
 * @returns {flatbuffers.Offset}
 */
MNN.GpuFunction.createGpuFunction = function(builder, stagsOffset, nameOffset) {
  MNN.GpuFunction.startGpuFunction(builder);
  MNN.GpuFunction.addStags(builder, stagsOffset);
  MNN.GpuFunction.addName(builder, nameOffset);
  return MNN.GpuFunction.endGpuFunction(builder);
}

/**
 * @constructor
 */
MNN.GpuLibrary = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.GpuLibrary}
 */
MNN.GpuLibrary.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.GpuLibrary=} obj
 * @returns {MNN.GpuLibrary}
 */
MNN.GpuLibrary.getRootAsGpuLibrary = function(bb, obj) {
  return (obj || new MNN.GpuLibrary).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.GpuLibrary=} obj
 * @returns {MNN.GpuLibrary}
 */
MNN.GpuLibrary.getSizePrefixedRootAsGpuLibrary = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.GpuLibrary).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @param {MNN.GpuFunction=} obj
 * @returns {MNN.GpuFunction}
 */
MNN.GpuLibrary.prototype.functions = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? (obj || new MNN.GpuFunction).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

/**
 * @returns {number}
 */
MNN.GpuLibrary.prototype.functionsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @param {number} index
 * @param {MNN.GpuPipeline=} obj
 * @returns {MNN.GpuPipeline}
 */
MNN.GpuLibrary.prototype.pipeline = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new MNN.GpuPipeline).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

/**
 * @returns {number}
 */
MNN.GpuLibrary.prototype.pipelineLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
MNN.GpuLibrary.prototype.name = function(optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.GpuLibrary.startGpuLibrary = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} functionsOffset
 */
MNN.GpuLibrary.addFunctions = function(builder, functionsOffset) {
  builder.addFieldOffset(0, functionsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
MNN.GpuLibrary.createFunctionsVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addOffset(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.GpuLibrary.startFunctionsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} pipelineOffset
 */
MNN.GpuLibrary.addPipeline = function(builder, pipelineOffset) {
  builder.addFieldOffset(1, pipelineOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
MNN.GpuLibrary.createPipelineVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addOffset(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.GpuLibrary.startPipelineVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} nameOffset
 */
MNN.GpuLibrary.addName = function(builder, nameOffset) {
  builder.addFieldOffset(2, nameOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.GpuLibrary.endGpuLibrary = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} functionsOffset
 * @param {flatbuffers.Offset} pipelineOffset
 * @param {flatbuffers.Offset} nameOffset
 * @returns {flatbuffers.Offset}
 */
MNN.GpuLibrary.createGpuLibrary = function(builder, functionsOffset, pipelineOffset, nameOffset) {
  MNN.GpuLibrary.startGpuLibrary(builder);
  MNN.GpuLibrary.addFunctions(builder, functionsOffset);
  MNN.GpuLibrary.addPipeline(builder, pipelineOffset);
  MNN.GpuLibrary.addName(builder, nameOffset);
  return MNN.GpuLibrary.endGpuLibrary(builder);
}

/**
 * @constructor
 */
MNN.TensorConvertInfo = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.TensorConvertInfo}
 */
MNN.TensorConvertInfo.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.TensorConvertInfo=} obj
 * @returns {MNN.TensorConvertInfo}
 */
MNN.TensorConvertInfo.getRootAsTensorConvertInfo = function(bb, obj) {
  return (obj || new MNN.TensorConvertInfo).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.TensorConvertInfo=} obj
 * @returns {MNN.TensorConvertInfo}
 */
MNN.TensorConvertInfo.getSizePrefixedRootAsTensorConvertInfo = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.TensorConvertInfo).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @returns {MNN.MNN_DATA_FORMAT}
 */
MNN.TensorConvertInfo.prototype.source = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? /** @type {MNN.MNN_DATA_FORMAT} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.MNN_DATA_FORMAT.NCHW;
};

/**
 * @returns {MNN.MNN_DATA_FORMAT}
 */
MNN.TensorConvertInfo.prototype.dest = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.MNN_DATA_FORMAT} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.MNN_DATA_FORMAT.NCHW;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.TensorConvertInfo.startTensorConvertInfo = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.MNN_DATA_FORMAT} source
 */
MNN.TensorConvertInfo.addSource = function(builder, source) {
  builder.addFieldInt8(0, source, MNN.MNN_DATA_FORMAT.NCHW);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.MNN_DATA_FORMAT} dest
 */
MNN.TensorConvertInfo.addDest = function(builder, dest) {
  builder.addFieldInt8(1, dest, MNN.MNN_DATA_FORMAT.NCHW);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.TensorConvertInfo.endTensorConvertInfo = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.MNN_DATA_FORMAT} source
 * @param {MNN.MNN_DATA_FORMAT} dest
 * @returns {flatbuffers.Offset}
 */
MNN.TensorConvertInfo.createTensorConvertInfo = function(builder, source, dest) {
  MNN.TensorConvertInfo.startTensorConvertInfo(builder);
  MNN.TensorConvertInfo.addSource(builder, source);
  MNN.TensorConvertInfo.addDest(builder, dest);
  return MNN.TensorConvertInfo.endTensorConvertInfo(builder);
}

/**
 * @constructor
 */
MNN.Plugin = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Plugin}
 */
MNN.Plugin.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Plugin=} obj
 * @returns {MNN.Plugin}
 */
MNN.Plugin.getRootAsPlugin = function(bb, obj) {
  return (obj || new MNN.Plugin).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Plugin=} obj
 * @returns {MNN.Plugin}
 */
MNN.Plugin.getSizePrefixedRootAsPlugin = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Plugin).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
MNN.Plugin.prototype.type = function(optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
};

/**
 * @param {number} index
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob}
 */
MNN.Plugin.prototype.buffer = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

/**
 * @returns {number}
 */
MNN.Plugin.prototype.bufferLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Plugin.startPlugin = function(builder) {
  builder.startObject(2);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} typeOffset
 */
MNN.Plugin.addType = function(builder, typeOffset) {
  builder.addFieldOffset(0, typeOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} bufferOffset
 */
MNN.Plugin.addBuffer = function(builder, bufferOffset) {
  builder.addFieldOffset(1, bufferOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Plugin.createBufferVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addOffset(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Plugin.startBufferVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Plugin.endPlugin = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} typeOffset
 * @param {flatbuffers.Offset} bufferOffset
 * @returns {flatbuffers.Offset}
 */
MNN.Plugin.createPlugin = function(builder, typeOffset, bufferOffset) {
  MNN.Plugin.startPlugin(builder);
  MNN.Plugin.addType(builder, typeOffset);
  MNN.Plugin.addBuffer(builder, bufferOffset);
  return MNN.Plugin.endPlugin(builder);
}

/**
 * @constructor
 */
MNN.Extra = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Extra}
 */
MNN.Extra.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Extra=} obj
 * @returns {MNN.Extra}
 */
MNN.Extra.getRootAsExtra = function(bb, obj) {
  return (obj || new MNN.Extra).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Extra=} obj
 * @returns {MNN.Extra}
 */
MNN.Extra.getSizePrefixedRootAsExtra = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Extra).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
MNN.Extra.prototype.type = function(optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
};

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
MNN.Extra.prototype.engine = function(optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Extra.prototype.info = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
};

/**
 * @returns {number}
 */
MNN.Extra.prototype.infoLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int8Array}
 */
MNN.Extra.prototype.infoArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @param {number} index
 * @param {MNN.Attribute=} obj
 * @returns {MNN.Attribute}
 */
MNN.Extra.prototype.attr = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? (obj || new MNN.Attribute).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

/**
 * @returns {number}
 */
MNN.Extra.prototype.attrLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Extra.startExtra = function(builder) {
  builder.startObject(4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} typeOffset
 */
MNN.Extra.addType = function(builder, typeOffset) {
  builder.addFieldOffset(0, typeOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} engineOffset
 */
MNN.Extra.addEngine = function(builder, engineOffset) {
  builder.addFieldOffset(1, engineOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} infoOffset
 */
MNN.Extra.addInfo = function(builder, infoOffset) {
  builder.addFieldOffset(2, infoOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Extra.createInfoVector = function(builder, data) {
  builder.startVector(1, data.length, 1);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt8(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Extra.startInfoVector = function(builder, numElems) {
  builder.startVector(1, numElems, 1);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} attrOffset
 */
MNN.Extra.addAttr = function(builder, attrOffset) {
  builder.addFieldOffset(3, attrOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Extra.createAttrVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addOffset(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Extra.startAttrVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Extra.endExtra = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} typeOffset
 * @param {flatbuffers.Offset} engineOffset
 * @param {flatbuffers.Offset} infoOffset
 * @param {flatbuffers.Offset} attrOffset
 * @returns {flatbuffers.Offset}
 */
MNN.Extra.createExtra = function(builder, typeOffset, engineOffset, infoOffset, attrOffset) {
  MNN.Extra.startExtra(builder);
  MNN.Extra.addType(builder, typeOffset);
  MNN.Extra.addEngine(builder, engineOffset);
  MNN.Extra.addInfo(builder, infoOffset);
  MNN.Extra.addAttr(builder, attrOffset);
  return MNN.Extra.endExtra(builder);
}

/**
 * @constructor
 */
MNN.Op = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Op}
 */
MNN.Op.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Op=} obj
 * @returns {MNN.Op}
 */
MNN.Op.getRootAsOp = function(bb, obj) {
  return (obj || new MNN.Op).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Op=} obj
 * @returns {MNN.Op}
 */
MNN.Op.getSizePrefixedRootAsOp = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Op).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Op.prototype.inputIndexes = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Op.prototype.inputIndexesLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Op.prototype.inputIndexesArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {MNN.OpParameter}
 */
MNN.Op.prototype.mainType = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? /** @type {MNN.OpParameter} */ (this.bb.readUint8(this.bb_pos + offset)) : MNN.OpParameter.NONE;
};

/**
 * @param {flatbuffers.Table} obj
 * @returns {?flatbuffers.Table}
 */
MNN.Op.prototype.main = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
};

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
MNN.Op.prototype.name = function(optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
};

/**
 * @param {number} index
 * @returns {number}
 */
MNN.Op.prototype.outputIndexes = function(index) {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
};

/**
 * @returns {number}
 */
MNN.Op.prototype.outputIndexesLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {Int32Array}
 */
MNN.Op.prototype.outputIndexesArray = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
};

/**
 * @returns {MNN.OpType}
 */
MNN.Op.prototype.type = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? /** @type {MNN.OpType} */ (this.bb.readInt32(this.bb_pos + offset)) : MNN.OpType.AbsVal;
};

/**
 * @returns {MNN.MNN_DATA_FORMAT}
 */
MNN.Op.prototype.defaultDimentionFormat = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? /** @type {MNN.MNN_DATA_FORMAT} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.MNN_DATA_FORMAT.NHWC;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Op.startOp = function(builder) {
  builder.startObject(7);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputIndexesOffset
 */
MNN.Op.addInputIndexes = function(builder, inputIndexesOffset) {
  builder.addFieldOffset(0, inputIndexesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Op.createInputIndexesVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Op.startInputIndexesVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.OpParameter} mainType
 */
MNN.Op.addMainType = function(builder, mainType) {
  builder.addFieldInt8(1, mainType, MNN.OpParameter.NONE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} mainOffset
 */
MNN.Op.addMain = function(builder, mainOffset) {
  builder.addFieldOffset(2, mainOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} nameOffset
 */
MNN.Op.addName = function(builder, nameOffset) {
  builder.addFieldOffset(3, nameOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} outputIndexesOffset
 */
MNN.Op.addOutputIndexes = function(builder, outputIndexesOffset) {
  builder.addFieldOffset(4, outputIndexesOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<number>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Op.createOutputIndexesVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addInt32(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Op.startOutputIndexesVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.OpType} type
 */
MNN.Op.addType = function(builder, type) {
  builder.addFieldInt32(5, type, MNN.OpType.AbsVal);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.MNN_DATA_FORMAT} defaultDimentionFormat
 */
MNN.Op.addDefaultDimentionFormat = function(builder, defaultDimentionFormat) {
  builder.addFieldInt8(6, defaultDimentionFormat, MNN.MNN_DATA_FORMAT.NHWC);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Op.endOp = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} inputIndexesOffset
 * @param {MNN.OpParameter} mainType
 * @param {flatbuffers.Offset} mainOffset
 * @param {flatbuffers.Offset} nameOffset
 * @param {flatbuffers.Offset} outputIndexesOffset
 * @param {MNN.OpType} type
 * @param {MNN.MNN_DATA_FORMAT} defaultDimentionFormat
 * @returns {flatbuffers.Offset}
 */
MNN.Op.createOp = function(builder, inputIndexesOffset, mainType, mainOffset, nameOffset, outputIndexesOffset, type, defaultDimentionFormat) {
  MNN.Op.startOp(builder);
  MNN.Op.addInputIndexes(builder, inputIndexesOffset);
  MNN.Op.addMainType(builder, mainType);
  MNN.Op.addMain(builder, mainOffset);
  MNN.Op.addName(builder, nameOffset);
  MNN.Op.addOutputIndexes(builder, outputIndexesOffset);
  MNN.Op.addType(builder, type);
  MNN.Op.addDefaultDimentionFormat(builder, defaultDimentionFormat);
  return MNN.Op.endOp(builder);
}

/**
 * @constructor
 */
MNN.TensorDescribe = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.TensorDescribe}
 */
MNN.TensorDescribe.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.TensorDescribe=} obj
 * @returns {MNN.TensorDescribe}
 */
MNN.TensorDescribe.getRootAsTensorDescribe = function(bb, obj) {
  return (obj || new MNN.TensorDescribe).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.TensorDescribe=} obj
 * @returns {MNN.TensorDescribe}
 */
MNN.TensorDescribe.getSizePrefixedRootAsTensorDescribe = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.TensorDescribe).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {MNN.Blob=} obj
 * @returns {MNN.Blob|null}
 */
MNN.TensorDescribe.prototype.blob = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? (obj || new MNN.Blob).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @returns {number}
 */
MNN.TensorDescribe.prototype.index = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
MNN.TensorDescribe.prototype.name = function(optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.TensorDescribe.startTensorDescribe = function(builder) {
  builder.startObject(3);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} blobOffset
 */
MNN.TensorDescribe.addBlob = function(builder, blobOffset) {
  builder.addFieldOffset(0, blobOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} index
 */
MNN.TensorDescribe.addIndex = function(builder, index) {
  builder.addFieldInt32(1, index, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} nameOffset
 */
MNN.TensorDescribe.addName = function(builder, nameOffset) {
  builder.addFieldOffset(2, nameOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.TensorDescribe.endTensorDescribe = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} blobOffset
 * @param {number} index
 * @param {flatbuffers.Offset} nameOffset
 * @returns {flatbuffers.Offset}
 */
MNN.TensorDescribe.createTensorDescribe = function(builder, blobOffset, index, nameOffset) {
  MNN.TensorDescribe.startTensorDescribe(builder);
  MNN.TensorDescribe.addBlob(builder, blobOffset);
  MNN.TensorDescribe.addIndex(builder, index);
  MNN.TensorDescribe.addName(builder, nameOffset);
  return MNN.TensorDescribe.endTensorDescribe(builder);
}

/**
 * @constructor
 */
MNN.Net = function() {
  /**
   * @type {flatbuffers.ByteBuffer}
   */
  this.bb = null;

  /**
   * @type {number}
   */
  this.bb_pos = 0;
};

/**
 * @param {number} i
 * @param {flatbuffers.ByteBuffer} bb
 * @returns {MNN.Net}
 */
MNN.Net.prototype.__init = function(i, bb) {
  this.bb_pos = i;
  this.bb = bb;
  return this;
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Net=} obj
 * @returns {MNN.Net}
 */
MNN.Net.getRootAsNet = function(bb, obj) {
  return (obj || new MNN.Net).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.ByteBuffer} bb
 * @param {MNN.Net=} obj
 * @returns {MNN.Net}
 */
MNN.Net.getSizePrefixedRootAsNet = function(bb, obj) {
  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
  return (obj || new MNN.Net).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};

/**
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array|null}
 */
MNN.Net.prototype.bizCode = function(optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 4);
  return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
};

/**
 * @param {number} index
 * @param {MNN.TensorDescribe=} obj
 * @returns {MNN.TensorDescribe}
 */
MNN.Net.prototype.extraTensorDescribe = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? (obj || new MNN.TensorDescribe).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

/**
 * @returns {number}
 */
MNN.Net.prototype.extraTensorDescribeLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 6);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @param {MNN.GpuLibrary=} obj
 * @returns {MNN.GpuLibrary|null}
 */
MNN.Net.prototype.gpulibrary = function(obj) {
  var offset = this.bb.__offset(this.bb_pos, 8);
  return offset ? (obj || new MNN.GpuLibrary).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
};

/**
 * @param {number} index
 * @param {MNN.Op=} obj
 * @returns {MNN.Op}
 */
MNN.Net.prototype.oplists = function(index, obj) {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? (obj || new MNN.Op).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
};

/**
 * @returns {number}
 */
MNN.Net.prototype.oplistsLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 10);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @param {number} index
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array}
 */
MNN.Net.prototype.outputName = function(index, optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
};

/**
 * @returns {number}
 */
MNN.Net.prototype.outputNameLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 12);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {MNN.ForwardType}
 */
MNN.Net.prototype.preferForwardType = function() {
  var offset = this.bb.__offset(this.bb_pos, 14);
  return offset ? /** @type {MNN.ForwardType} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.ForwardType.CPU;
};

/**
 * @returns {MNN.NetSource}
 */
MNN.Net.prototype.sourceType = function() {
  var offset = this.bb.__offset(this.bb_pos, 16);
  return offset ? /** @type {MNN.NetSource} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.NetSource.CAFFE;
};

/**
 * @param {number} index
 * @param {flatbuffers.Encoding=} optionalEncoding
 * @returns {string|Uint8Array}
 */
MNN.Net.prototype.tensorName = function(index, optionalEncoding) {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
};

/**
 * @returns {number}
 */
MNN.Net.prototype.tensorNameLength = function() {
  var offset = this.bb.__offset(this.bb_pos, 18);
  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
};

/**
 * @returns {number}
 */
MNN.Net.prototype.tensorNumber = function() {
  var offset = this.bb.__offset(this.bb_pos, 20);
  return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};

/**
 * @returns {MNN.Usage}
 */
MNN.Net.prototype.usage = function() {
  var offset = this.bb.__offset(this.bb_pos, 22);
  return offset ? /** @type {MNN.Usage} */ (this.bb.readInt8(this.bb_pos + offset)) : MNN.Usage.INFERENCE;
};

/**
 * @param {flatbuffers.Builder} builder
 */
MNN.Net.startNet = function(builder) {
  builder.startObject(10);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} bizCodeOffset
 */
MNN.Net.addBizCode = function(builder, bizCodeOffset) {
  builder.addFieldOffset(0, bizCodeOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} extraTensorDescribeOffset
 */
MNN.Net.addExtraTensorDescribe = function(builder, extraTensorDescribeOffset) {
  builder.addFieldOffset(1, extraTensorDescribeOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Net.createExtraTensorDescribeVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addOffset(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Net.startExtraTensorDescribeVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} gpulibraryOffset
 */
MNN.Net.addGpulibrary = function(builder, gpulibraryOffset) {
  builder.addFieldOffset(2, gpulibraryOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} oplistsOffset
 */
MNN.Net.addOplists = function(builder, oplistsOffset) {
  builder.addFieldOffset(3, oplistsOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Net.createOplistsVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addOffset(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Net.startOplistsVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} outputNameOffset
 */
MNN.Net.addOutputName = function(builder, outputNameOffset) {
  builder.addFieldOffset(4, outputNameOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Net.createOutputNameVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addOffset(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Net.startOutputNameVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.ForwardType} preferForwardType
 */
MNN.Net.addPreferForwardType = function(builder, preferForwardType) {
  builder.addFieldInt8(5, preferForwardType, MNN.ForwardType.CPU);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.NetSource} sourceType
 */
MNN.Net.addSourceType = function(builder, sourceType) {
  builder.addFieldInt8(6, sourceType, MNN.NetSource.CAFFE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} tensorNameOffset
 */
MNN.Net.addTensorName = function(builder, tensorNameOffset) {
  builder.addFieldOffset(7, tensorNameOffset, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {Array.<flatbuffers.Offset>} data
 * @returns {flatbuffers.Offset}
 */
MNN.Net.createTensorNameVector = function(builder, data) {
  builder.startVector(4, data.length, 4);
  for (var i = data.length - 1; i >= 0; i--) {
    builder.addOffset(data[i]);
  }
  return builder.endVector();
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} numElems
 */
MNN.Net.startTensorNameVector = function(builder, numElems) {
  builder.startVector(4, numElems, 4);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {number} tensorNumber
 */
MNN.Net.addTensorNumber = function(builder, tensorNumber) {
  builder.addFieldInt32(8, tensorNumber, 0);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {MNN.Usage} usage
 */
MNN.Net.addUsage = function(builder, usage) {
  builder.addFieldInt8(9, usage, MNN.Usage.INFERENCE);
};

/**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
 */
MNN.Net.endNet = function(builder) {
  var offset = builder.endObject();
  return offset;
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} offset
 */
MNN.Net.finishNetBuffer = function(builder, offset) {
  builder.finish(offset);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} offset
 */
MNN.Net.finishSizePrefixedNetBuffer = function(builder, offset) {
  builder.finish(offset, undefined, true);
};

/**
 * @param {flatbuffers.Builder} builder
 * @param {flatbuffers.Offset} bizCodeOffset
 * @param {flatbuffers.Offset} extraTensorDescribeOffset
 * @param {flatbuffers.Offset} gpulibraryOffset
 * @param {flatbuffers.Offset} oplistsOffset
 * @param {flatbuffers.Offset} outputNameOffset
 * @param {MNN.ForwardType} preferForwardType
 * @param {MNN.NetSource} sourceType
 * @param {flatbuffers.Offset} tensorNameOffset
 * @param {number} tensorNumber
 * @param {MNN.Usage} usage
 * @returns {flatbuffers.Offset}
 */
MNN.Net.createNet = function(builder, bizCodeOffset, extraTensorDescribeOffset, gpulibraryOffset, oplistsOffset, outputNameOffset, preferForwardType, sourceType, tensorNameOffset, tensorNumber, usage) {
  MNN.Net.startNet(builder);
  MNN.Net.addBizCode(builder, bizCodeOffset);
  MNN.Net.addExtraTensorDescribe(builder, extraTensorDescribeOffset);
  MNN.Net.addGpulibrary(builder, gpulibraryOffset);
  MNN.Net.addOplists(builder, oplistsOffset);
  MNN.Net.addOutputName(builder, outputNameOffset);
  MNN.Net.addPreferForwardType(builder, preferForwardType);
  MNN.Net.addSourceType(builder, sourceType);
  MNN.Net.addTensorName(builder, tensorNameOffset);
  MNN.Net.addTensorNumber(builder, tensorNumber);
  MNN.Net.addUsage(builder, usage);
  return MNN.Net.endNet(builder);
}

if (typeof module !== 'undefined' && typeof module.exports === 'object') {
  module.exports = MNN;
}
